Turn on -Winconsistent-missing-override

src/Makefile

@@ -138,7 +138,6 @@ COMMON_CXXFLAGS += -fexceptions -fno-rtti
 COMMON_CXXFLAGS += -Wno-invalid-offsetof # allow the use of "offsetof", and we'll just have to make sure to only use it legally.
 COMMON_CXXFLAGS += -DENABLE_INTEL_JIT_EVENTS=$(ENABLE_INTEL_JIT_EVENTS)
 COMMON_CXXFLAGS += -I$(DEPS_DIR)/pypa-install/include
-COMMON_CXXFLAGS += -Wno-inconsistent-missing-override
 
 ifeq ($(ENABLE_VALGRIND),0)
 	COMMON_CXXFLAGS += -DNVALGRIND

src/analysis/scoping_analysis.cpp

@@ -24,9 +24,9 @@ class YieldVisitor : public NoopASTVisitor {
 public:
     YieldVisitor() : containsYield(false) {}
 
-    virtual bool visit_functiondef(AST_FunctionDef*) { return true; }
+    bool visit_functiondef(AST_FunctionDef*) override { return true; }
 
-    virtual bool visit_yield(AST_Yield*) {
+    bool visit_yield(AST_Yield*) override {
         containsYield = true;
         return true;
     }
@@ -55,25 +55,25 @@ static bool isCompilerCreatedName(const std::string& name) {
 
 class ModuleScopeInfo : public ScopeInfo {
 public:
-    virtual ScopeInfo* getParent() { return NULL; }
+    ScopeInfo* getParent() override { return NULL; }
 
-    virtual bool createsClosure() { return false; }
+    bool createsClosure() override { return false; }
 
-    virtual bool takesClosure() { return false; }
+    bool takesClosure() override { return false; }
 
     bool passesThroughClosure() override { return false; }
 
-    virtual bool refersToGlobal(const std::string& name) {
+    bool refersToGlobal(const std::string& name) override {
         if (isCompilerCreatedName(name))
             return false;
 
         // assert(name[0] != '#' && "should test this");
         return true;
     }
-    virtual bool refersToClosure(const std::string name) { return false; }
-    virtual bool saveInClosure(const std::string name) { return false; }
+    bool refersToClosure(const std::string name) override { return false; }
+    bool saveInClosure(const std::string name) override { return false; }
 
-    virtual const std::unordered_set<std::string>& getClassDefLocalNames() { RELEASE_ASSERT(0, ""); }
+    const std::unordered_set<std::string>& getClassDefLocalNames() override { RELEASE_ASSERT(0, ""); }
 };
 
 struct ScopingAnalysis::ScopeNameUsage {
@@ -120,17 +120,19 @@ public:
         assert(usage);
     }
 
-    virtual ~ScopeInfoBase() { delete this->usage; }
+    ~ScopeInfoBase() override { delete this->usage; }
 
-    virtual ScopeInfo* getParent() { return parent; }
+    ScopeInfo* getParent() override { return parent; }
 
-    virtual bool createsClosure() { return usage->referenced_from_nested.size() > 0; }
+    bool createsClosure() override { return usage->referenced_from_nested.size() > 0; }
 
-    virtual bool takesClosure() { return usage->got_from_closure.size() > 0 || usage->passthrough_accesses.size() > 0; }
+    bool takesClosure() override {
+        return usage->got_from_closure.size() > 0 || usage->passthrough_accesses.size() > 0;
+    }
 
     bool passesThroughClosure() override { return usage->passthrough_accesses.size() > 0 && !createsClosure(); }
 
-    virtual bool refersToGlobal(const std::string& name) {
+    bool refersToGlobal(const std::string& name) override {
         // HAX
         if (isCompilerCreatedName(name))
             return false;
@@ -139,20 +141,20 @@ public:
             return true;
         return usage->written.count(name) == 0 && usage->got_from_closure.count(name) == 0;
     }
-    virtual bool refersToClosure(const std::string name) {
+    bool refersToClosure(const std::string name) override {
         // HAX
         if (isCompilerCreatedName(name))
             return false;
         return usage->got_from_closure.count(name) != 0;
     }
-    virtual bool saveInClosure(const std::string name) {
+    bool saveInClosure(const std::string name) override {
         // HAX
         if (isCompilerCreatedName(name))
             return false;
         return usage->referenced_from_nested.count(name) != 0;
     }
 
-    virtual const std::unordered_set<std::string>& getClassDefLocalNames() {
+    const std::unordered_set<std::string>& getClassDefLocalNames() override {
         RELEASE_ASSERT(usage->node->type == AST_TYPE::ClassDef, "");
         return usage->written;
     }
@@ -177,7 +179,7 @@ public:
 
     void doRead(const std::string& name) { cur->read.insert(name); }
 
-    virtual bool visit_name(AST_Name* node) {
+    bool visit_name(AST_Name* node) override {
         switch (node->ctx_type) {
             case AST_TYPE::Load:
                 doRead(node->id);
@@ -193,55 +195,55 @@ public:
         return true;
     }
 
-    virtual bool visit_assert(AST_Assert* node) { return false; }
-    virtual bool visit_assign(AST_Assign* node) { return false; }
-    virtual bool visit_augassign(AST_AugAssign* node) { return false; }
-    virtual bool visit_attribute(AST_Attribute* node) { return false; }
-    virtual bool visit_binop(AST_BinOp* node) { return false; }
-    virtual bool visit_boolop(AST_BoolOp* node) { return false; }
-    virtual bool visit_break(AST_Break* node) { return false; }
-    virtual bool visit_call(AST_Call* node) { return false; }
-    virtual bool visit_compare(AST_Compare* node) { return false; }
-    virtual bool visit_comprehension(AST_comprehension* node) { return false; }
-    // virtual bool visit_classdef(AST_ClassDef *node) { return false; }
-    virtual bool visit_continue(AST_Continue* node) { return false; }
-    virtual bool visit_dict(AST_Dict* node) { return false; }
-    virtual bool visit_dictcomp(AST_DictComp* node) { return false; }
-    virtual bool visit_excepthandler(AST_ExceptHandler* node) { return false; }
-    virtual bool visit_expr(AST_Expr* node) { return false; }
-    virtual bool visit_for(AST_For* node) { return false; }
-    // virtual bool visit_functiondef(AST_FunctionDef *node) { return false; }
-    // virtual bool visit_global(AST_Global *node) { return false; }
-    virtual bool visit_if(AST_If* node) { return false; }
-    virtual bool visit_ifexp(AST_IfExp* node) { return false; }
-    virtual bool visit_index(AST_Index* node) { return false; }
-    virtual bool visit_keyword(AST_keyword* node) { return false; }
-    virtual bool visit_list(AST_List* node) { return false; }
-    virtual bool visit_listcomp(AST_ListComp* node) { return false; }
-    // virtual bool visit_module(AST_Module *node) { return false; }
-    // virtual bool visit_name(AST_Name *node) { return false; }
-    virtual bool visit_num(AST_Num* node) { return false; }
-    virtual bool visit_pass(AST_Pass* node) { return false; }
-    virtual bool visit_print(AST_Print* node) { return false; }
-    virtual bool visit_raise(AST_Raise* node) { return false; }
-    virtual bool visit_repr(AST_Repr* node) { return false; }
-    virtual bool visit_return(AST_Return* node) { return false; }
-    virtual bool visit_slice(AST_Slice* node) { return false; }
-    virtual bool visit_str(AST_Str* node) { return false; }
-    virtual bool visit_subscript(AST_Subscript* node) { return false; }
-    virtual bool visit_tryexcept(AST_TryExcept* node) { return false; }
-    virtual bool visit_tryfinally(AST_TryFinally* node) { return false; }
-    virtual bool visit_tuple(AST_Tuple* node) { return false; }
-    virtual bool visit_unaryop(AST_UnaryOp* node) { return false; }
-    virtual bool visit_while(AST_While* node) { return false; }
-    virtual bool visit_with(AST_With* node) { return false; }
-    virtual bool visit_yield(AST_Yield* node) { return false; }
-
-    virtual bool visit_branch(AST_Branch* node) { return false; }
-    virtual bool visit_jump(AST_Jump* node) { return false; }
-
-
-    virtual bool visit_delete(AST_Delete* node) {
+    bool visit_assert(AST_Assert* node) override { return false; }
+    bool visit_assign(AST_Assign* node) override { return false; }
+    bool visit_augassign(AST_AugAssign* node) override { return false; }
+    bool visit_attribute(AST_Attribute* node) override { return false; }
+    bool visit_binop(AST_BinOp* node) override { return false; }
+    bool visit_boolop(AST_BoolOp* node) override { return false; }
+    bool visit_break(AST_Break* node) override { return false; }
+    bool visit_call(AST_Call* node) override { return false; }
+    bool visit_compare(AST_Compare* node) override { return false; }
+    bool visit_comprehension(AST_comprehension* node) override { return false; }
+    // bool visit_classdef(AST_ClassDef *node) override { return false; }
+    bool visit_continue(AST_Continue* node) override { return false; }
+    bool visit_dict(AST_Dict* node) override { return false; }
+    bool visit_dictcomp(AST_DictComp* node) override { return false; }
+    bool visit_excepthandler(AST_ExceptHandler* node) override { return false; }
+    bool visit_expr(AST_Expr* node) override { return false; }
+    bool visit_for(AST_For* node) override { return false; }
+    // bool visit_functiondef(AST_FunctionDef *node) override { return false; }
+    // bool visit_global(AST_Global *node) override { return false; }
+    bool visit_if(AST_If* node) override { return false; }
+    bool visit_ifexp(AST_IfExp* node) override { return false; }
+    bool visit_index(AST_Index* node) override { return false; }
+    bool visit_keyword(AST_keyword* node) override { return false; }
+    bool visit_list(AST_List* node) override { return false; }
+    bool visit_listcomp(AST_ListComp* node) override { return false; }
+    // bool visit_module(AST_Module *node) override { return false; }
+    // bool visit_name(AST_Name *node) override { return false; }
+    bool visit_num(AST_Num* node) override { return false; }
+    bool visit_pass(AST_Pass* node) override { return false; }
+    bool visit_print(AST_Print* node) override { return false; }
+    bool visit_raise(AST_Raise* node) override { return false; }
+    bool visit_repr(AST_Repr* node) override { return false; }
+    bool visit_return(AST_Return* node) override { return false; }
+    bool visit_slice(AST_Slice* node) override { return false; }
+    bool visit_str(AST_Str* node) override { return false; }
+    bool visit_subscript(AST_Subscript* node) override { return false; }
+    bool visit_tryexcept(AST_TryExcept* node) override { return false; }
+    bool visit_tryfinally(AST_TryFinally* node) override { return false; }
+    bool visit_tuple(AST_Tuple* node) override { return false; }
+    bool visit_unaryop(AST_UnaryOp* node) override { return false; }
+    bool visit_while(AST_While* node) override { return false; }
+    bool visit_with(AST_With* node) override { return false; }
+    bool visit_yield(AST_Yield* node) override { return false; }
+
+    bool visit_branch(AST_Branch* node) override { return false; }
+    bool visit_jump(AST_Jump* node) override { return false; }
+
+
+    bool visit_delete(AST_Delete* node) override {
         for (auto t : node->targets) {
             if (t->type == AST_TYPE::Name) {
                 doWrite(ast_cast<AST_Name>(t)->id);
@@ -250,7 +252,7 @@ public:
         return false;
     }
 
-    virtual bool visit_global(AST_Global* node) {
+    bool visit_global(AST_Global* node) override {
         for (int i = 0; i < node->names.size(); i++) {
             const std::string& name = node->names[i];
             cur->forced_globals.insert(name);
@@ -258,7 +260,7 @@ public:
         return true;
     }
 
-    virtual bool visit_classdef(AST_ClassDef* node) {
+    bool visit_classdef(AST_ClassDef* node) override {
         if (node == orig_node) {
             for (AST_stmt* s : node->body)
                 s->accept(this);
@@ -276,7 +278,7 @@ public:
         }
     }
 
-    virtual bool visit_functiondef(AST_FunctionDef* node) {
+    bool visit_functiondef(AST_FunctionDef* node) override {
         if (node == orig_node) {
             for (AST_expr* e : node->args->args)
                 e->accept(this);
@@ -300,7 +302,7 @@ public:
         }
     }
 
-    virtual bool visit_generatorexp(AST_GeneratorExp* node) {
+    bool visit_generatorexp(AST_GeneratorExp* node) override {
         if (node == orig_node) {
             bool first = true;
             for (AST_comprehension* c : node->generators) {
@@ -320,7 +322,7 @@ public:
         return true;
     }
 
-    virtual bool visit_lambda(AST_Lambda* node) {
+    bool visit_lambda(AST_Lambda* node) override {
         if (node == orig_node) {
             for (AST_expr* e : node->args->args)
                 e->accept(this);
@@ -339,7 +341,7 @@ public:
         return true;
     }
 
-    virtual bool visit_import(AST_Import* node) {
+    bool visit_import(AST_Import* node) override {
         for (int i = 0; i < node->names.size(); i++) {
             AST_alias* alias = node->names[i];
             if (alias->asname.size())
@@ -350,7 +352,7 @@ public:
         return true;
     }
 
-    virtual bool visit_importfrom(AST_ImportFrom* node) {
+    bool visit_importfrom(AST_ImportFrom* node) override {
         for (int i = 0; i < node->names.size(); i++) {
             AST_alias* alias = node->names[i];
             if (alias->asname.size())

src/analysis/type_analysis.cpp

@@ -36,8 +36,8 @@ namespace pyston {
 
 class NullTypeAnalysis : public TypeAnalysis {
 public:
-    virtual ConcreteCompilerType* getTypeAtBlockStart(const std::string& name, CFGBlock* block);
-    virtual ConcreteCompilerType* getTypeAtBlockEnd(const std::string& name, CFGBlock* block);
+    ConcreteCompilerType* getTypeAtBlockStart(const std::string& name, CFGBlock* block) override;
+    ConcreteCompilerType* getTypeAtBlockEnd(const std::string& name, CFGBlock* block) override;
 
     BoxedClass* speculatedExprClass(AST_expr*) override { return NULL; }
 };
@@ -168,7 +168,7 @@ private:
         }
     }
 
-    virtual void* visit_attribute(AST_Attribute* node) {
+    void* visit_attribute(AST_Attribute* node) override {
         CompilerType* t = getType(node->value);
         CompilerType* rtn = t->getattrType(&node->attr, false);
 
@@ -190,7 +190,7 @@ private:
         return rtn;
     }
 
-    virtual void* visit_clsattribute(AST_ClsAttribute* node) {
+    void* visit_clsattribute(AST_ClsAttribute* node) override {
         CompilerType* t = getType(node->value);
         CompilerType* rtn = t->getattrType(&node->attr, true);
         if (VERBOSITY() >= 2 && rtn == UNDEF) {
@@ -207,7 +207,7 @@ private:
         return type == STR || type == INT || type == FLOAT || type == LIST || type == DICT;
     }
 
-    virtual void* visit_augbinop(AST_AugBinOp* node) {
+    void* visit_augbinop(AST_AugBinOp* node) override {
         CompilerType* left = getType(node->left);
         CompilerType* right = getType(node->right);
         if (!hasFixedBinops(left) || !hasFixedBinops(right))
@@ -236,7 +236,7 @@ private:
         return rtn;
     }
 
-    virtual void* visit_binop(AST_BinOp* node) {
+    void* visit_binop(AST_BinOp* node) override {
         CompilerType* left = getType(node->left);
         CompilerType* right = getType(node->right);
         if (!hasFixedBinops(left) || !hasFixedBinops(right))
@@ -265,7 +265,7 @@ private:
         return rtn;
     }
 
-    virtual void* visit_boolop(AST_BoolOp* node) {
+    void* visit_boolop(AST_BoolOp* node) override {
         int n = node->values.size();
 
         CompilerType* rtn = NULL;
@@ -280,7 +280,7 @@ private:
         return rtn;
     }
 
-    virtual void* visit_call(AST_Call* node) {
+    void* visit_call(AST_Call* node) override {
         CompilerType* func = getType(node->func);
 
         std::vector<CompilerType*> arg_types;
@@ -316,7 +316,7 @@ private:
         return rtn_type;
     }
 
-    virtual void* visit_compare(AST_Compare* node) {
+    void* visit_compare(AST_Compare* node) override {
         if (node->ops.size() == 1) {
             CompilerType* left = getType(node->left);
             CompilerType* right = getType(node->comparators[0]);
@@ -342,7 +342,7 @@ private:
         }
     }
 
-    virtual void* visit_dict(AST_Dict* node) {
+    void* visit_dict(AST_Dict* node) override {
         // Get all the sub-types, even though they're not necessary to
         // determine the expression type, so that things like speculations
         // can be processed.
@@ -354,11 +354,11 @@ private:
         return DICT;
     }
 
-    virtual void* visit_index(AST_Index* node) { return getType(node->value); }
+    void* visit_index(AST_Index* node) override { return getType(node->value); }
 
-    virtual void* visit_lambda(AST_Lambda* node) { return typeFromClass(function_cls); }
+    void* visit_lambda(AST_Lambda* node) override { return typeFromClass(function_cls); }
 
-    virtual void* visit_langprimitive(AST_LangPrimitive* node) {
+    void* visit_langprimitive(AST_LangPrimitive* node) override {
         switch (node->opcode) {
             case AST_LangPrimitive::ISINSTANCE:
                 return BOOL;
@@ -377,7 +377,7 @@ private:
         }
     }
 
-    virtual void* visit_list(AST_List* node) {
+    void* visit_list(AST_List* node) override {
         // Get all the sub-types, even though they're not necessary to
         // determine the expression type, so that things like speculations
         // can be processed.
@@ -388,7 +388,7 @@ private:
         return LIST;
     }
 
-    virtual void* visit_name(AST_Name* node) {
+    void* visit_name(AST_Name* node) override {
         if (scope_info->refersToGlobal(node->id)) {
             if (node->id == "xrange") {
                 // printf("TODO guard here and return the classobj\n");
@@ -412,7 +412,7 @@ private:
         return t;
     }
 
-    virtual void* visit_num(AST_Num* node) {
+    void* visit_num(AST_Num* node) override {
         switch (node->num_type) {
             case AST_Num::INT:
                 return INT;
@@ -426,15 +426,15 @@ private:
         abort();
     }
 
-    virtual void* visit_repr(AST_Repr* node) { return STR; }
+    void* visit_repr(AST_Repr* node) override { return STR; }
 
-    virtual void* visit_set(AST_Set* node) { return SET; }
+    void* visit_set(AST_Set* node) override { return SET; }
 
-    virtual void* visit_slice(AST_Slice* node) { return SLICE; }
+    void* visit_slice(AST_Slice* node) override { return SLICE; }
 
-    virtual void* visit_str(AST_Str* node) { return STR; }
+    void* visit_str(AST_Str* node) override { return STR; }
 
-    virtual void* visit_subscript(AST_Subscript* node) {
+    void* visit_subscript(AST_Subscript* node) override {
         CompilerType* val = getType(node->value);
         CompilerType* slice = getType(node->slice);
         static std::string name("__getitem__");
@@ -444,7 +444,7 @@ private:
         return getitem_type->callType(ArgPassSpec(1), args, NULL);
     }
 
-    virtual void* visit_tuple(AST_Tuple* node) {
+    void* visit_tuple(AST_Tuple* node) override {
         std::vector<CompilerType*> elt_types;
         for (int i = 0; i < node->elts.size(); i++) {
             elt_types.push_back(getType(node->elts[i]));
@@ -452,7 +452,7 @@ private:
         return makeTupleType(elt_types);
     }
 
-    virtual void* visit_unaryop(AST_UnaryOp* node) {
+    void* visit_unaryop(AST_UnaryOp* node) override {
         CompilerType* operand = getType(node->operand);
 
         // TODO this isn't the exact behavior
@@ -462,29 +462,29 @@ private:
         return attr_type->callType(ArgPassSpec(0), arg_types, NULL);
     }
 
-    virtual void* visit_yield(AST_Yield*) { return UNKNOWN; }
+    void* visit_yield(AST_Yield*) override { return UNKNOWN; }
 
 
-    virtual void visit_assert(AST_Assert* node) {
+    void visit_assert(AST_Assert* node) override {
         getType(node->test);
         if (node->msg)
             getType(node->msg);
     }
 
-    virtual void visit_assign(AST_Assign* node) {
+    void visit_assign(AST_Assign* node) override {
         CompilerType* t = getType(node->value);
         for (int i = 0; i < node->targets.size(); i++) {
             _doSet(node->targets[i], t);
         }
     }
 
-    virtual void visit_branch(AST_Branch* node) {
+    void visit_branch(AST_Branch* node) override {
         if (EXPAND_UNNEEDED) {
             getType(node->test);
         }
     }
 
-    virtual void visit_classdef(AST_ClassDef* node) {
+    void visit_classdef(AST_ClassDef* node) override {
         for (auto d : node->decorator_list) {
             getType(d);
         }
@@ -499,7 +499,7 @@ private:
         _doSet(node->name, t);
     }
 
-    virtual void visit_delete(AST_Delete* node) {
+    void visit_delete(AST_Delete* node) override {
         for (AST_expr* target : node->targets) {
             switch (target->type) {
                 case AST_TYPE::Subscript:
@@ -517,14 +517,14 @@ private:
         }
     }
 
-    virtual void visit_expr(AST_Expr* node) {
+    void visit_expr(AST_Expr* node) override {
         if (EXPAND_UNNEEDED) {
             if (node->value != NULL)
                 getType(node->value);
         }
     }
 
-    virtual void visit_functiondef(AST_FunctionDef* node) {
+    void visit_functiondef(AST_FunctionDef* node) override {
         for (auto d : node->decorator_list) {
             getType(d);
         }
@@ -536,9 +536,10 @@ private:
         _doSet(node->name, typeFromClass(function_cls));
     }
 
-    virtual void visit_global(AST_Global* node) {}
+    void visit_global(AST_Global* node) override {}
 
-    virtual void visit_alias(AST_alias* node) {
+    // not part of the visitor api:
+    void _visit_alias(AST_alias* node) {
         const std::string* name = &node->name;
         if (node->asname.size())
             name = &node->asname;
@@ -546,22 +547,22 @@ private:
         _doSet(*name, UNKNOWN);
     }
 
-    virtual void visit_import(AST_Import* node) {
+    void visit_import(AST_Import* node) override {
         for (AST_alias* alias : node->names)
-            visit_alias(alias);
+            _visit_alias(alias);
     }
 
-    virtual void visit_importfrom(AST_ImportFrom* node) {
+    void visit_importfrom(AST_ImportFrom* node) override {
         for (AST_alias* alias : node->names)
-            visit_alias(alias);
+            _visit_alias(alias);
     }
 
-    virtual void visit_invoke(AST_Invoke* node) { node->stmt->accept_stmt(this); }
+    void visit_invoke(AST_Invoke* node) override { node->stmt->accept_stmt(this); }
 
-    virtual void visit_jump(AST_Jump* node) {}
-    virtual void visit_pass(AST_Pass* node) {}
+    void visit_jump(AST_Jump* node) override {}
+    void visit_pass(AST_Pass* node) override {}
 
-    virtual void visit_print(AST_Print* node) {
+    void visit_print(AST_Print* node) override {
         if (node->dest)
             getType(node->dest);
 
@@ -572,7 +573,7 @@ private:
         }
     }
 
-    virtual void visit_raise(AST_Raise* node) {
+    void visit_raise(AST_Raise* node) override {
         if (EXPAND_UNNEEDED) {
             if (node->arg0)
                 getType(node->arg0);
@@ -583,14 +584,14 @@ private:
         }
     }
 
-    virtual void visit_return(AST_Return* node) {
+    void visit_return(AST_Return* node) override {
         if (EXPAND_UNNEEDED) {
             if (node->value != NULL)
                 getType(node->value);
         }
     }
 
-    virtual void visit_unreachable(AST_Unreachable* node) {}
+    void visit_unreachable(AST_Unreachable* node) override {}
 
 public:
     static void propagate(CFGBlock* block, const TypeMap& starting, TypeMap& ending, ExprTypeMap& expr_types,
@@ -614,11 +615,11 @@ private:
           speculation(speculation) {}
 
 public:
-    virtual ConcreteCompilerType* getTypeAtBlockEnd(const std::string& name, CFGBlock* block) {
+    ConcreteCompilerType* getTypeAtBlockEnd(const std::string& name, CFGBlock* block) override {
         assert(block->successors.size() > 0);
         return getTypeAtBlockStart(name, block->successors[0]);
     }
-    virtual ConcreteCompilerType* getTypeAtBlockStart(const std::string& name, CFGBlock* block) {
+    ConcreteCompilerType* getTypeAtBlockStart(const std::string& name, CFGBlock* block) override {
         CompilerType* base = starting_types[block][name];
         ASSERT(base != NULL, "%s %d", name.c_str(), block->idx);
 
@@ -627,7 +628,7 @@ public:
         return rtn;
     }
 
-    virtual BoxedClass* speculatedExprClass(AST_expr* call) { return type_speculations[call]; }
+    BoxedClass* speculatedExprClass(AST_expr* call) override { return type_speculations[call]; }
 
     static bool merge(CompilerType* lhs, CompilerType*& rhs) {
         assert(lhs);

src/codegen/compvars.cpp

@@ -93,8 +93,8 @@ public:
         return rtn;
     }
 
-    virtual CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
-                                   const std::vector<const std::string*>* keyword_names) {
+    CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
+                           const std::vector<const std::string*>* keyword_names) override {
         std::vector<CompilerType*> new_args(arg_types);
         new_args.insert(new_args.begin(), obj_type);
 
@@ -102,11 +102,11 @@ public:
         return function_type->callType(new_argspec, new_args, keyword_names);
     }
 
-    std::string debugName() {
+    std::string debugName() override {
         return "instanceMethod(" + obj_type->debugName() + " ; " + function_type->debugName() + ")";
     }
 
-    virtual void drop(IREmitter& emitter, VAR* var) {
+    void drop(IREmitter& emitter, VAR* var) override {
         checkVar(var);
         RawInstanceMethod* val = var->getValue();
         val->obj->decvref(emitter);
@@ -114,10 +114,9 @@ public:
         delete val;
     }
 
-    virtual CompilerVariable* call(IREmitter& emitter, const OpInfo& info,
-                                   ValuedCompilerVariable<RawInstanceMethod*>* var, ArgPassSpec argspec,
-                                   const std::vector<CompilerVariable*>& args,
-                                   const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* call(IREmitter& emitter, const OpInfo& info, ValuedCompilerVariable<RawInstanceMethod*>* var,
+                           ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
+                           const std::vector<const std::string*>* keyword_names) override {
         std::vector<CompilerVariable*> new_args;
         new_args.push_back(var->getValue()->obj);
         new_args.insert(new_args.end(), args.begin(), args.end());
@@ -126,10 +125,10 @@ public:
         return var->getValue()->func->call(emitter, info, new_argspec, new_args, keyword_names);
     }
 
-    virtual bool canConvertTo(ConcreteCompilerType* other_type) { return other_type == UNKNOWN; }
-    virtual ConcreteCompilerType* getConcreteType() { return typeFromClass(instancemethod_cls); }
-    virtual ConcreteCompilerType* getBoxType() { return getConcreteType(); }
-    virtual ConcreteCompilerVariable* makeConverted(IREmitter& emitter, VAR* var, ConcreteCompilerType* other_type) {
+    bool canConvertTo(ConcreteCompilerType* other_type) override { return other_type == UNKNOWN; }
+    ConcreteCompilerType* getConcreteType() override { return typeFromClass(instancemethod_cls); }
+    ConcreteCompilerType* getBoxType() override { return getConcreteType(); }
+    ConcreteCompilerVariable* makeConverted(IREmitter& emitter, VAR* var, ConcreteCompilerType* other_type) override {
         checkVar(var);
         assert(other_type == UNKNOWN || other_type == typeFromClass(instancemethod_cls));
 
@@ -147,7 +146,7 @@ public:
 
         return new ConcreteCompilerVariable(other_type, boxed, true);
     }
-    virtual CompilerVariable* dup(VAR* var, DupCache& cache) {
+    CompilerVariable* dup(VAR* var, DupCache& cache) override {
         checkVar(var);
 
         CompilerVariable* rtn = cache[var];
@@ -196,28 +195,28 @@ CompilerVariable* ConcreteCompilerType::dup(ConcreteCompilerVariable* v, DupCach
 
 class UnknownType : public ConcreteCompilerType {
 public:
-    llvm::Type* llvmType() { return g.llvm_value_type_ptr; }
+    llvm::Type* llvmType() override { return g.llvm_value_type_ptr; }
 
-    virtual std::string debugName() { return "AnyBox"; }
+    std::string debugName() override { return "AnyBox"; }
 
-    virtual void drop(IREmitter& emitter, VAR* var) { emitter.getGC()->dropPointer(emitter, var->getValue()); }
-    virtual void grab(IREmitter& emitter, VAR* var) { emitter.getGC()->grabPointer(emitter, var->getValue()); }
+    void drop(IREmitter& emitter, VAR* var) override { emitter.getGC()->dropPointer(emitter, var->getValue()); }
+    void grab(IREmitter& emitter, VAR* var) override { emitter.getGC()->grabPointer(emitter, var->getValue()); }
 
-    virtual bool isFitBy(BoxedClass* c) { return true; }
+    bool isFitBy(BoxedClass* c) override { return true; }
 
-    virtual CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                      const std::string* attr, bool cls_only);
-    virtual CompilerVariable* call(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                   ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
-                                   const std::vector<const std::string*>* keyword_names);
-    virtual CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                       const std::string* attr, bool clsonly, ArgPassSpec argspec,
-                                       const std::vector<CompilerVariable*>& args,
-                                       const std::vector<const std::string*>* keyword_names);
-    virtual ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var);
+    CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                              const std::string* attr, bool cls_only) override;
+    CompilerVariable* call(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var, ArgPassSpec argspec,
+                           const std::vector<CompilerVariable*>& args,
+                           const std::vector<const std::string*>* keyword_names) override;
+    CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                               const std::string* attr, bool clsonly, ArgPassSpec argspec,
+                               const std::vector<CompilerVariable*>& args,
+                               const std::vector<const std::string*>* keyword_names) override;
+    ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) override;
 
     void setattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var, const std::string* attr,
-                 CompilerVariable* v) {
+                 CompilerVariable* v) override {
         llvm::Constant* ptr = getStringConstantPtr(*attr + '\0');
         ConcreteCompilerVariable* converted = v->makeConverted(emitter, UNKNOWN);
         // g.funcs.setattr->dump();
@@ -240,7 +239,8 @@ public:
         converted->decvref(emitter);
     }
 
-    void delattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var, const std::string* attr) {
+    void delattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                 const std::string* attr) override {
         llvm::Constant* ptr = getStringConstantPtr(*attr + '\0');
 
         // TODO
@@ -260,7 +260,7 @@ public:
         }
     }
 
-    virtual llvm::Value* makeClassCheck(IREmitter& emitter, ConcreteCompilerVariable* var, BoxedClass* cls) {
+    llvm::Value* makeClassCheck(IREmitter& emitter, ConcreteCompilerVariable* var, BoxedClass* cls) override {
         assert(var->getValue()->getType() == g.llvm_value_type_ptr);
 
         static_assert(offsetof(Box, cls) % sizeof(void*) == 0, "");
@@ -273,15 +273,15 @@ public:
         return rtn;
     }
 
-    virtual CompilerType* getattrType(const std::string* attr, bool cls_only) { return UNKNOWN; }
-    virtual CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
-                                   const std::vector<const std::string*>* keyword_names) {
+    CompilerType* getattrType(const std::string* attr, bool cls_only) override { return UNKNOWN; }
+    CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
+                           const std::vector<const std::string*>* keyword_names) override {
         return UNKNOWN;
     }
-    virtual BoxedClass* guaranteedClass() { return NULL; }
-    virtual ConcreteCompilerType* getBoxType() { return this; }
-    virtual ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
-                                                    ConcreteCompilerType* other_type) {
+    BoxedClass* guaranteedClass() override { return NULL; }
+    ConcreteCompilerType* getBoxType() override { return this; }
+    ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
+                                            ConcreteCompilerType* other_type) override {
         if (other_type == this) {
             var->incvref();
             return var;
@@ -290,7 +290,7 @@ public:
         abort();
     }
 
-    virtual ConcreteCompilerVariable* len(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) {
+    ConcreteCompilerVariable* len(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) override {
         bool do_patchpoint = ENABLE_ICGENERICS && !info.isInterpreted();
         llvm::Value* rtn;
         if (do_patchpoint) {
@@ -307,8 +307,8 @@ public:
         return new ConcreteCompilerVariable(INT, rtn, true);
     }
 
-    virtual CompilerVariable* getitem(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                      CompilerVariable* slice) {
+    CompilerVariable* getitem(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                              CompilerVariable* slice) override {
         ConcreteCompilerVariable* converted_slice = slice->makeConverted(emitter, slice->getBoxType());
 
         bool do_patchpoint = ENABLE_ICGETITEMS && !info.isInterpreted();
@@ -664,18 +664,18 @@ private:
     AbstractFunctionType(const std::vector<Sig*>& sigs) : sigs(sigs) {}
 
 public:
-    virtual std::string debugName() { return "<AbstractFunctionType>"; }
+    std::string debugName() override { return "<AbstractFunctionType>"; }
 
-    virtual ConcreteCompilerType* getConcreteType() { return UNKNOWN; }
+    ConcreteCompilerType* getConcreteType() override { return UNKNOWN; }
 
-    virtual ConcreteCompilerType* getBoxType() { return UNKNOWN; }
+    ConcreteCompilerType* getBoxType() override { return UNKNOWN; }
 
-    virtual bool canConvertTo(ConcreteCompilerType* other_type) { return other_type == UNKNOWN; }
+    bool canConvertTo(ConcreteCompilerType* other_type) override { return other_type == UNKNOWN; }
 
-    virtual CompilerType* getattrType(const std::string* attr, bool cls_only) { return UNDEF; }
+    CompilerType* getattrType(const std::string* attr, bool cls_only) override { return UNDEF; }
 
-    virtual CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
-                                   const std::vector<const std::string*>* keyword_names) {
+    CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
+                           const std::vector<const std::string*>* keyword_names) override {
         RELEASE_ASSERT(!argspec.has_starargs, "");
         RELEASE_ASSERT(!argspec.has_kwargs, "");
         RELEASE_ASSERT(argspec.num_keywords == 0, "");
@@ -701,7 +701,7 @@ public:
         return UNDEF;
     }
 
-    virtual BoxedClass* guaranteedClass() { return NULL; }
+    BoxedClass* guaranteedClass() override { return NULL; }
 
     static CompilerType* fromRT(BoxedFunction* rtfunc, bool stripfirst) {
         std::vector<Sig*> sigs;
@@ -742,18 +742,18 @@ class IntType : public ConcreteCompilerType {
 public:
     IntType() {}
 
-    llvm::Type* llvmType() { return g.i64; }
+    llvm::Type* llvmType() override { return g.i64; }
 
-    virtual bool isFitBy(BoxedClass* c) { return false; }
+    bool isFitBy(BoxedClass* c) override { return false; }
 
-    virtual void drop(IREmitter& emitter, ConcreteCompilerVariable* var) {
+    void drop(IREmitter& emitter, ConcreteCompilerVariable* var) override {
         // pass
     }
-    virtual void grab(IREmitter& emitter, ConcreteCompilerVariable* var) {
+    void grab(IREmitter& emitter, ConcreteCompilerVariable* var) override {
         // pass
     }
 
-    virtual CompilerType* getattrType(const std::string* attr, bool cls_only) {
+    CompilerType* getattrType(const std::string* attr, bool cls_only) override {
         /*
         static std::vector<AbstractFunctionType::Sig*> sigs;
         if (sigs.size() == 0) {
@@ -784,39 +784,39 @@ public:
         return BOXED_INT->getattrType(attr, cls_only);
     }
 
-    virtual CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                       const std::string* attr, bool clsonly, ArgPassSpec argspec,
-                                       const std::vector<CompilerVariable*>& args,
-                                       const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                               const std::string* attr, bool clsonly, ArgPassSpec argspec,
+                               const std::vector<CompilerVariable*>& args,
+                               const std::vector<const std::string*>* keyword_names) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, BOXED_INT);
         CompilerVariable* rtn = converted->callattr(emitter, info, attr, clsonly, argspec, args, keyword_names);
         converted->decvref(emitter);
         return rtn;
     }
 
-    virtual CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                      const std::string* attr, bool cls_only) {
+    CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                              const std::string* attr, bool cls_only) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, BOXED_INT);
         CompilerVariable* rtn = converted->getattr(emitter, info, attr, cls_only);
         converted->decvref(emitter);
         return rtn;
     }
 
-    virtual void setattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
-                         CompilerVariable* v) {
+    void setattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
+                 CompilerVariable* v) override {
         llvm::CallSite call = emitter.createCall2(info.exc_info, g.funcs.raiseAttributeErrorStr,
                                                   getStringConstantPtr("int\0"), getStringConstantPtr(*attr + '\0'));
         call.setDoesNotReturn();
     }
 
-    virtual void delattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr) {
+    void delattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr) override {
         llvm::CallSite call = emitter.createCall2(info.exc_info, g.funcs.raiseAttributeErrorStr,
                                                   getStringConstantPtr("int\0"), getStringConstantPtr(*attr + '\0'));
         call.setDoesNotReturn();
     }
 
-    virtual ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
-                                                    ConcreteCompilerType* other_type) {
+    ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
+                                            ConcreteCompilerType* other_type) override {
         if (other_type == this) {
             var->incvref();
             return var;
@@ -829,21 +829,21 @@ public:
         }
     }
 
-    virtual CompilerVariable* getitem(IREmitter& emitter, const OpInfo& info, VAR* var, CompilerVariable* slice) {
+    CompilerVariable* getitem(IREmitter& emitter, const OpInfo& info, VAR* var, CompilerVariable* slice) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, BOXED_INT);
         CompilerVariable* rtn = converted->getitem(emitter, info, slice);
         converted->decvref(emitter);
         return rtn;
     }
 
-    virtual ConcreteCompilerVariable* len(IREmitter& emitter, const OpInfo& info, VAR* var) {
+    ConcreteCompilerVariable* len(IREmitter& emitter, const OpInfo& info, VAR* var) override {
         llvm::CallSite call
             = emitter.createCall(info.exc_info, g.funcs.raiseNotIterableError, getStringConstantPtr("int"));
         call.setDoesNotReturn();
         return new ConcreteCompilerVariable(INT, llvm::UndefValue::get(g.i64), true);
     }
 
-    virtual ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) {
+    ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) override {
         llvm::Value* cmp = emitter.getBuilder()->CreateICmpNE(var->getValue(), llvm::ConstantInt::get(g.i64, 0, false));
         return boolFromI1(emitter, cmp);
     }
@@ -941,7 +941,7 @@ public:
         }
     }
 
-    virtual ConcreteCompilerType* getBoxType() { return BOXED_INT; }
+    ConcreteCompilerType* getBoxType() override { return BOXED_INT; }
 
     Box* deserializeFromFrame(const FrameVals& vals) override {
         assert(vals.size() == 1);
@@ -959,18 +959,18 @@ class FloatType : public ConcreteCompilerType {
 public:
     FloatType() {}
 
-    llvm::Type* llvmType() { return g.double_; }
+    llvm::Type* llvmType() override { return g.double_; }
 
-    virtual bool isFitBy(BoxedClass* c) { return false; }
+    bool isFitBy(BoxedClass* c) override { return false; }
 
-    virtual void drop(IREmitter& emitter, ConcreteCompilerVariable* var) {
+    void drop(IREmitter& emitter, ConcreteCompilerVariable* var) override {
         // pass
     }
-    virtual void grab(IREmitter& emitter, ConcreteCompilerVariable* var) {
+    void grab(IREmitter& emitter, ConcreteCompilerVariable* var) override {
         // pass
     }
 
-    virtual CompilerType* getattrType(const std::string* attr, bool cls_only) {
+    CompilerType* getattrType(const std::string* attr, bool cls_only) override {
         static std::vector<AbstractFunctionType::Sig*> sigs;
         if (sigs.size() == 0) {
             AbstractFunctionType::Sig* float_sig = new AbstractFunctionType::Sig();
@@ -1002,39 +1002,39 @@ public:
         return BOXED_FLOAT->getattrType(attr, cls_only);
     }
 
-    virtual CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                      const std::string* attr, bool cls_only) {
+    CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                              const std::string* attr, bool cls_only) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, BOXED_FLOAT);
         CompilerVariable* rtn = converted->getattr(emitter, info, attr, cls_only);
         converted->decvref(emitter);
         return rtn;
     }
 
-    virtual CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                       const std::string* attr, bool clsonly, ArgPassSpec argspec,
-                                       const std::vector<CompilerVariable*>& args,
-                                       const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                               const std::string* attr, bool clsonly, ArgPassSpec argspec,
+                               const std::vector<CompilerVariable*>& args,
+                               const std::vector<const std::string*>* keyword_names) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, BOXED_FLOAT);
         CompilerVariable* rtn = converted->callattr(emitter, info, attr, clsonly, argspec, args, keyword_names);
         converted->decvref(emitter);
         return rtn;
     }
 
-    virtual void setattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
-                         CompilerVariable* v) {
+    void setattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
+                 CompilerVariable* v) override {
         llvm::CallSite call = emitter.createCall2(info.exc_info, g.funcs.raiseAttributeErrorStr,
                                                   getStringConstantPtr("float\0"), getStringConstantPtr(*attr + '\0'));
         call.setDoesNotReturn();
     }
 
-    virtual void delattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr) {
+    void delattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr) override {
         llvm::CallSite call = emitter.createCall2(info.exc_info, g.funcs.raiseAttributeErrorStr,
                                                   getStringConstantPtr("float\0"), getStringConstantPtr(*attr + '\0'));
         call.setDoesNotReturn();
     }
 
-    virtual ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
-                                                    ConcreteCompilerType* other_type) {
+    ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
+                                            ConcreteCompilerType* other_type) override {
         if (other_type == this) {
             var->incvref();
             return var;
@@ -1047,7 +1047,7 @@ public:
         }
     }
 
-    virtual ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) {
+    ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) override {
         llvm::Value* cmp = emitter.getBuilder()->CreateFCmpUNE(var->getValue(), llvm::ConstantFP::get(g.double_, 0));
         return boolFromI1(emitter, cmp);
     }
@@ -1161,7 +1161,7 @@ public:
         return rtn;
     }
 
-    virtual ConcreteCompilerType* getBoxType() { return BOXED_FLOAT; }
+    ConcreteCompilerType* getBoxType() override { return BOXED_FLOAT; }
 
     Box* deserializeFromFrame(const FrameVals& vals) override {
         assert(vals.size() == 1);
@@ -1196,7 +1196,7 @@ private:
     KnownClassobjType(BoxedClass* cls) : cls(cls) { assert(cls); }
 
 public:
-    virtual std::string debugName() { return "class '" + *getNameOfClass(cls) + "'"; }
+    std::string debugName() override { return "class '" + *getNameOfClass(cls) + "'"; }
 
     void assertMatches(BoxedClass* cls) override { assert(cls == this->cls); }
 
@@ -1208,8 +1208,8 @@ public:
         return rtn;
     }
 
-    virtual CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
-                                   const std::vector<const std::string*>* keyword_names) {
+    CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
+                           const std::vector<const std::string*>* keyword_names) override {
         RELEASE_ASSERT(!argspec.has_starargs, "");
         RELEASE_ASSERT(!argspec.has_kwargs, "");
         RELEASE_ASSERT(argspec.num_keywords == 0, "");
@@ -1248,15 +1248,15 @@ private:
     }
 
 public:
-    llvm::Type* llvmType() { return g.llvm_value_type_ptr; }
-    std::string debugName() {
+    llvm::Type* llvmType() override { return g.llvm_value_type_ptr; }
+    std::string debugName() override {
         assert(cls);
         // TODO add getTypeName
 
         return "NormalType(" + *getNameOfClass(cls) + ")";
     }
-    virtual ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
-                                                    ConcreteCompilerType* other_type) {
+    ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
+                                            ConcreteCompilerType* other_type) override {
         if (other_type == this) {
             var->incvref();
             return var;
@@ -1266,12 +1266,12 @@ public:
         // return (new ConcreteCompilerVariable(UNKNOWN, var->getValue(), false))->split(emitter);
     }
 
-    virtual void drop(IREmitter& emitter, VAR* var) { emitter.getGC()->dropPointer(emitter, var->getValue()); }
-    virtual void grab(IREmitter& emitter, VAR* var) { emitter.getGC()->grabPointer(emitter, var->getValue()); }
+    void drop(IREmitter& emitter, VAR* var) override { emitter.getGC()->dropPointer(emitter, var->getValue()); }
+    void grab(IREmitter& emitter, VAR* var) override { emitter.getGC()->grabPointer(emitter, var->getValue()); }
 
-    virtual bool isFitBy(BoxedClass* c) { return c == cls; }
+    bool isFitBy(BoxedClass* c) override { return c == cls; }
 
-    virtual CompilerType* getattrType(const std::string* attr, bool cls_only) {
+    CompilerType* getattrType(const std::string* attr, bool cls_only) override {
         if (cls->is_constant && !cls->instancesHaveAttrs() && cls->hasGenericGetattr()) {
             Box* rtattr = cls->getattr(*attr);
             if (rtattr == NULL)
@@ -1289,13 +1289,13 @@ public:
         return UNKNOWN;
     }
 
-    virtual CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
-                                   const std::vector<const std::string*>* keyword_names) {
+    CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
+                           const std::vector<const std::string*>* keyword_names) override {
         return UNKNOWN;
     }
 
     CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                              const std::string* attr, bool cls_only) {
+                              const std::string* attr, bool cls_only) override {
         // printf("%s.getattr %s\n", debugName().c_str(), attr->c_str());
         if (cls->is_constant && !cls->instancesHaveAttrs() && cls->hasGenericGetattr()) {
             Box* rtattr = cls->getattr(*attr);
@@ -1320,17 +1320,18 @@ public:
     }
 
     void setattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var, const std::string* attr,
-                 CompilerVariable* v) {
+                 CompilerVariable* v) override {
         return UNKNOWN->setattr(emitter, info, var, attr, v);
     }
 
-    void delattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var, const std::string* attr) {
+    void delattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                 const std::string* attr) override {
         return UNKNOWN->delattr(emitter, info, var, attr);
     }
 
-    virtual CompilerVariable* call(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                   ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
-                                   const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* call(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var, ArgPassSpec argspec,
+                           const std::vector<CompilerVariable*>& args,
+                           const std::vector<const std::string*>* keyword_names) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, UNKNOWN);
         CompilerVariable* rtn = converted->call(emitter, info, argspec, args, keyword_names);
         converted->decvref(emitter);
@@ -1456,10 +1457,10 @@ public:
         return rtn;
     }
 
-    virtual CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                       const std::string* attr, bool clsonly, ArgPassSpec argspec,
-                                       const std::vector<CompilerVariable*>& args,
-                                       const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                               const std::string* attr, bool clsonly, ArgPassSpec argspec,
+                               const std::vector<CompilerVariable*>& args,
+                               const std::vector<const std::string*>* keyword_names) override {
         ConcreteCompilerVariable* called_constant
             = tryCallattrConstant(emitter, info, var, attr, clsonly, argspec, args, keyword_names);
         if (called_constant)
@@ -1498,7 +1499,7 @@ public:
         return rtn;
     }
 
-    virtual CompilerVariable* getitem(IREmitter& emitter, const OpInfo& info, VAR* var, CompilerVariable* slice) {
+    CompilerVariable* getitem(IREmitter& emitter, const OpInfo& info, VAR* var, CompilerVariable* slice) override {
         static const std::string attr("__getitem__");
         ConcreteCompilerVariable* called_constant
             = tryCallattrConstant(emitter, info, var, &attr, true, ArgPassSpec(1, 0, 0, 0), { slice }, NULL, false);
@@ -1508,7 +1509,7 @@ public:
         return UNKNOWN->getitem(emitter, info, var, slice);
     }
 
-    virtual ConcreteCompilerVariable* len(IREmitter& emitter, const OpInfo& info, VAR* var) {
+    ConcreteCompilerVariable* len(IREmitter& emitter, const OpInfo& info, VAR* var) override {
         static const std::string attr("__len__");
         ConcreteCompilerVariable* called_constant
             = tryCallattrConstant(emitter, info, var, &attr, true, ArgPassSpec(0, 0, 0, 0), {}, NULL);
@@ -1518,7 +1519,7 @@ public:
         return UNKNOWN->len(emitter, info, var);
     }
 
-    virtual ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) {
+    ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) override {
         static const std::string attr("__nonzero__");
         ConcreteCompilerVariable* called_constant
             = tryCallattrConstant(emitter, info, var, &attr, true, ArgPassSpec(0, 0, 0, 0), {}, NULL);
@@ -1543,9 +1544,9 @@ public:
         return rtn;
     }
 
-    virtual BoxedClass* guaranteedClass() { return cls; }
+    BoxedClass* guaranteedClass() override { return cls; }
 
-    virtual ConcreteCompilerType* getBoxType() { return this; }
+    ConcreteCompilerType* getBoxType() override { return this; }
 
     Box* deserializeFromFrame(const FrameVals& vals) override {
         assert(vals.size() == 1);
@@ -1557,24 +1558,24 @@ ConcreteCompilerType* STR, *BOXED_INT, *BOXED_FLOAT, *BOXED_BOOL, *NONE;
 
 class ClosureType : public ConcreteCompilerType {
 public:
-    llvm::Type* llvmType() { return g.llvm_closure_type_ptr; }
-    std::string debugName() { return "closure"; }
+    llvm::Type* llvmType() override { return g.llvm_closure_type_ptr; }
+    std::string debugName() override { return "closure"; }
 
     CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                              const std::string* attr, bool cls_only) {
+                              const std::string* attr, bool cls_only) override {
         assert(!cls_only);
         llvm::Value* bitcast = emitter.getBuilder()->CreateBitCast(var->getValue(), g.llvm_value_type_ptr);
         return ConcreteCompilerVariable(UNKNOWN, bitcast, true).getattr(emitter, info, attr, cls_only);
     }
 
     void setattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var, const std::string* attr,
-                 CompilerVariable* v) {
+                 CompilerVariable* v) override {
         llvm::Value* bitcast = emitter.getBuilder()->CreateBitCast(var->getValue(), g.llvm_value_type_ptr);
         ConcreteCompilerVariable(UNKNOWN, bitcast, true).setattr(emitter, info, attr, v);
     }
 
-    virtual ConcreteCompilerType* getConcreteType() { return this; }
-    virtual ConcreteCompilerType* getBoxType() { return this; }
+    ConcreteCompilerType* getConcreteType() override { return this; }
+    ConcreteCompilerType* getBoxType() override { return this; }
 
     void drop(IREmitter& emitter, VAR* var) override {}
     void grab(IREmitter& emitter, VAR* var) override {}
@@ -1588,16 +1589,16 @@ ConcreteCompilerType* CLOSURE = &_CLOSURE;
 
 class GeneratorType : public ConcreteCompilerType {
 public:
-    llvm::Type* llvmType() { return g.llvm_generator_type_ptr; }
-    std::string debugName() { return "generator"; }
+    llvm::Type* llvmType() override { return g.llvm_generator_type_ptr; }
+    std::string debugName() override { return "generator"; }
 
-    virtual ConcreteCompilerType* getConcreteType() { return this; }
-    virtual ConcreteCompilerType* getBoxType() { return GENERATOR; }
+    ConcreteCompilerType* getConcreteType() override { return this; }
+    ConcreteCompilerType* getBoxType() override { return GENERATOR; }
 
-    virtual void drop(IREmitter& emitter, VAR* var) {
+    void drop(IREmitter& emitter, VAR* var) override {
         // pass
     }
-    virtual void grab(IREmitter& emitter, VAR* var) {
+    void grab(IREmitter& emitter, VAR* var) override {
         // pass
     }
 
@@ -1610,49 +1611,49 @@ ConcreteCompilerType* GENERATOR = &_GENERATOR;
 
 class StrConstantType : public ValuedCompilerType<const std::string*> {
 public:
-    std::string debugName() { return "str_constant"; }
+    std::string debugName() override { return "str_constant"; }
 
     void assertMatches(const std::string* v) override {}
 
-    virtual ConcreteCompilerType* getConcreteType() { return STR; }
+    ConcreteCompilerType* getConcreteType() override { return STR; }
 
-    virtual ConcreteCompilerType* getBoxType() { return STR; }
+    ConcreteCompilerType* getBoxType() override { return STR; }
 
-    virtual void drop(IREmitter& emitter, VAR* var) {
+    void drop(IREmitter& emitter, VAR* var) override {
         // pass
     }
 
-    virtual void grab(IREmitter& emitter, VAR* var) {
+    void grab(IREmitter& emitter, VAR* var) override {
         // pass
     }
 
-    virtual ConcreteCompilerVariable* makeConverted(IREmitter& emitter, VAR* var, ConcreteCompilerType* other_type) {
+    ConcreteCompilerVariable* makeConverted(IREmitter& emitter, VAR* var, ConcreteCompilerType* other_type) override {
         assert(other_type == STR || other_type == UNKNOWN);
         llvm::Value* boxed = emitter.getBuilder()->CreateCall(g.funcs.boxStringPtr,
                                                               embedConstantPtr(var->getValue(), g.llvm_str_type_ptr));
         return new ConcreteCompilerVariable(other_type, boxed, true);
     }
 
-    virtual bool canConvertTo(ConcreteCompilerType* other) { return (other == STR || other == UNKNOWN); }
+    bool canConvertTo(ConcreteCompilerType* other) override { return (other == STR || other == UNKNOWN); }
 
-    virtual CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
-                                      bool cls_only) {
+    CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
+                              bool cls_only) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, STR);
         CompilerVariable* rtn = converted->getattr(emitter, info, attr, cls_only);
         converted->decvref(emitter);
         return rtn;
     }
 
-    virtual CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
-                                       bool clsonly, ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
-                                       const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr, bool clsonly,
+                               ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
+                               const std::vector<const std::string*>* keyword_names) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, STR);
         CompilerVariable* rtn = converted->callattr(emitter, info, attr, clsonly, argspec, args, keyword_names);
         converted->decvref(emitter);
         return rtn;
     }
 
-    virtual CompilerVariable* getitem(IREmitter& emitter, const OpInfo& info, VAR* var, CompilerVariable* slice) {
+    CompilerVariable* getitem(IREmitter& emitter, const OpInfo& info, VAR* var, CompilerVariable* slice) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, STR);
         CompilerVariable* rtn = converted->getitem(emitter, info, slice);
         converted->decvref(emitter);
@@ -1671,7 +1672,7 @@ public:
         return makeBool(var->getValue()->size() != 0);
     }
 
-    virtual CompilerVariable* dup(VAR* var, DupCache& cache) {
+    CompilerVariable* dup(VAR* var, DupCache& cache) override {
         CompilerVariable*& rtn = cache[var];
 
         if (rtn == NULL) {
@@ -1702,7 +1703,7 @@ CompilerVariable* makeStr(const std::string* s) {
 
 class VoidType : public ConcreteCompilerType {
 public:
-    llvm::Type* llvmType() { return g.void_; }
+    llvm::Type* llvmType() override { return g.void_; }
 
     Box* deserializeFromFrame(const FrameVals& vals) override { abort(); }
 };
@@ -1715,24 +1716,24 @@ ConcreteCompilerType* typeFromClass(BoxedClass* c) {
 
 class BoolType : public ConcreteCompilerType {
 public:
-    std::string debugName() { return "bool"; }
-    llvm::Type* llvmType() {
+    std::string debugName() override { return "bool"; }
+    llvm::Type* llvmType() override {
         if (BOOLS_AS_I64)
             return g.i64;
         else
             return g.i1;
     }
 
-    virtual bool isFitBy(BoxedClass* c) { return false; }
+    bool isFitBy(BoxedClass* c) override { return false; }
 
-    virtual void drop(IREmitter& emitter, VAR* var) {
+    void drop(IREmitter& emitter, VAR* var) override {
         // pass
     }
-    virtual void grab(IREmitter& emitter, VAR* var) {
+    void grab(IREmitter& emitter, VAR* var) override {
         // pass
     }
 
-    virtual ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) {
+    ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) override {
         var->incvref();
         return var;
     }
@@ -1741,8 +1742,8 @@ public:
         return (other_type == UNKNOWN || other_type == BOXED_BOOL || other_type == BOOL);
     }
 
-    virtual ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
-                                                    ConcreteCompilerType* other_type) {
+    ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
+                                            ConcreteCompilerType* other_type) override {
         if (other_type == BOOL) {
             var->incvref();
             return var;
@@ -1753,22 +1754,22 @@ public:
         return new ConcreteCompilerVariable(other_type, boxed, true);
     }
 
-    virtual CompilerType* getattrType(const std::string* attr, bool cls_only) {
+    CompilerType* getattrType(const std::string* attr, bool cls_only) override {
         return BOXED_BOOL->getattrType(attr, cls_only);
     }
 
-    virtual CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
-                                      bool cls_only) {
+    CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
+                              bool cls_only) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, BOXED_BOOL);
         CompilerVariable* rtn = converted->getattr(emitter, info, attr, cls_only);
         converted->decvref(emitter);
         return rtn;
     }
 
-    virtual CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
-                                       const std::string* attr, bool clsonly, ArgPassSpec argspec,
-                                       const std::vector<CompilerVariable*>& args,
-                                       const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var,
+                               const std::string* attr, bool clsonly, ArgPassSpec argspec,
+                               const std::vector<CompilerVariable*>& args,
+                               const std::vector<const std::string*>* keyword_names) override {
         ConcreteCompilerVariable* converted = var->makeConverted(emitter, BOXED_BOOL);
         CompilerVariable* rtn = converted->callattr(emitter, info, attr, clsonly, argspec, args, keyword_names);
         converted->decvref(emitter);
@@ -1783,7 +1784,7 @@ public:
         return rtn;
     }
 
-    virtual ConcreteCompilerType* getBoxType() { return BOXED_BOOL; }
+    ConcreteCompilerType* getBoxType() override { return BOXED_BOOL; }
 
     Box* deserializeFromFrame(const FrameVals& vals) override {
         assert(vals.size() == 1);
@@ -1826,18 +1827,18 @@ public:
         }
     }
 
-    std::string debugName() { return name; }
+    std::string debugName() override { return name; }
 
-    virtual void drop(IREmitter& emitter, VAR* var) {
+    void drop(IREmitter& emitter, VAR* var) override {
         const std::vector<CompilerVariable*>* elts = var->getValue();
         for (int i = 0; i < elts->size(); i++) {
             (*elts)[i]->decvref(emitter);
         }
     }
 
-    virtual void grab(IREmitter& emitter, VAR* var) { RELEASE_ASSERT(0, ""); }
+    void grab(IREmitter& emitter, VAR* var) override { RELEASE_ASSERT(0, ""); }
 
-    virtual CompilerVariable* dup(VAR* var, DupCache& cache) {
+    CompilerVariable* dup(VAR* var, DupCache& cache) override {
         CompilerVariable*& rtn = cache[var];
 
         if (rtn == NULL) {
@@ -1854,11 +1855,11 @@ public:
         return rtn;
     }
 
-    virtual bool canConvertTo(ConcreteCompilerType* other_type) {
+    bool canConvertTo(ConcreteCompilerType* other_type) override {
         return (other_type == UNKNOWN || other_type == BOXED_TUPLE);
     }
 
-    virtual ConcreteCompilerVariable* makeConverted(IREmitter& emitter, VAR* var, ConcreteCompilerType* other_type) {
+    ConcreteCompilerVariable* makeConverted(IREmitter& emitter, VAR* var, ConcreteCompilerType* other_type) override {
         assert(other_type == UNKNOWN || other_type == BOXED_TUPLE);
 
         VEC* v = var->getValue();
@@ -1894,13 +1895,13 @@ public:
         return new ConcreteCompilerVariable(other_type, rtn, true);
     }
 
-    virtual ConcreteCompilerType* getBoxType() { return BOXED_TUPLE; }
+    ConcreteCompilerType* getBoxType() override { return BOXED_TUPLE; }
 
-    virtual ConcreteCompilerType* getConcreteType() { return BOXED_TUPLE; }
+    ConcreteCompilerType* getConcreteType() override { return BOXED_TUPLE; }
 
     static TupleType* make(const std::vector<CompilerType*>& elt_types) { return new TupleType(elt_types); }
 
-    virtual CompilerVariable* getitem(IREmitter& emitter, const OpInfo& info, VAR* var, CompilerVariable* slice) {
+    CompilerVariable* getitem(IREmitter& emitter, const OpInfo& info, VAR* var, CompilerVariable* slice) override {
         if (slice->getType() == INT) {
             llvm::Value* v = static_cast<ConcreteCompilerVariable*>(slice)->getValue();
             assert(v->getType() == g.i64);
@@ -1923,11 +1924,11 @@ public:
         // return getConstantInt(var->getValue()->size(), g.i64);
     }
 
-    virtual ConcreteCompilerVariable* len(IREmitter& emitter, const OpInfo& info, VAR* var) {
+    ConcreteCompilerVariable* len(IREmitter& emitter, const OpInfo& info, VAR* var) override {
         return new ConcreteCompilerVariable(INT, getConstantInt(var->getValue()->size(), g.i64), true);
     }
 
-    virtual CompilerType* getattrType(const std::string* attr, bool cls_only) {
+    CompilerType* getattrType(const std::string* attr, bool cls_only) override {
         return BOXED_TUPLE->getattrType(attr, cls_only);
     }
 
@@ -1939,9 +1940,9 @@ public:
         return rtn;
     }
 
-    virtual CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
-                                       bool clsonly, ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
-                                       const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr, bool clsonly,
+                               ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
+                               const std::vector<const std::string*>* keyword_names) override {
         return makeConverted(emitter, var, getConcreteType())
             ->callattr(emitter, info, attr, clsonly, argspec, args, keyword_names);
     }
@@ -1997,7 +1998,7 @@ CompilerVariable* makeTuple(const std::vector<CompilerVariable*>& elts) {
 
 class UndefType : public ConcreteCompilerType {
 public:
-    std::string debugName() { return "undefType"; }
+    std::string debugName() override { return "undefType"; }
 
     llvm::Type* llvmType() override {
         // Something that no one else uses...
@@ -2005,14 +2006,14 @@ public:
         return llvm::Type::getInt16Ty(g.context);
     }
 
-    virtual CompilerVariable* call(IREmitter& emitter, const OpInfo& info, VAR* var, ArgPassSpec argspec,
-                                   const std::vector<CompilerVariable*>& args,
-                                   const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* call(IREmitter& emitter, const OpInfo& info, VAR* var, ArgPassSpec argspec,
+                           const std::vector<CompilerVariable*>& args,
+                           const std::vector<const std::string*>* keyword_names) override {
         return undefVariable();
     }
-    virtual void drop(IREmitter& emitter, VAR* var) {}
-    virtual void grab(IREmitter& emitter, VAR* var) {}
-    virtual CompilerVariable* dup(VAR* v, DupCache& cache) {
+    void drop(IREmitter& emitter, VAR* var) override {}
+    void grab(IREmitter& emitter, VAR* var) override {}
+    CompilerVariable* dup(VAR* v, DupCache& cache) override {
         // TODO copied from UnknownType
         auto& rtn = cache[v];
         if (rtn == NULL) {
@@ -2022,27 +2023,27 @@ public:
         }
         return rtn;
     }
-    virtual ConcreteCompilerVariable* makeConverted(IREmitter& emitter, VAR* var, ConcreteCompilerType* other_type) {
+    ConcreteCompilerVariable* makeConverted(IREmitter& emitter, VAR* var, ConcreteCompilerType* other_type) override {
         llvm::Value* v = llvm::UndefValue::get(other_type->llvmType());
         return new ConcreteCompilerVariable(other_type, v, true);
     }
-    virtual CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
-                                      bool cls_only) {
+    CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
+                              bool cls_only) override {
         return undefVariable();
     }
 
-    virtual CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr,
-                                       bool clsonly, ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
-                                       const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, VAR* var, const std::string* attr, bool clsonly,
+                               ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
+                               const std::vector<const std::string*>* keyword_names) override {
         return undefVariable();
     }
 
-    virtual CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
-                                   const std::vector<const std::string*>* keyword_names) {
+    CompilerType* callType(ArgPassSpec argspec, const std::vector<CompilerType*>& arg_types,
+                           const std::vector<const std::string*>* keyword_names) override {
         return UNDEF;
     }
 
-    virtual ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, VAR* var) {
+    ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, VAR* var) override {
         return new ConcreteCompilerVariable(BOOL, llvm::UndefValue::get(BOOL->llvmType()), true);
     }
 
@@ -2051,15 +2052,15 @@ public:
         return undefVariable();
     }
 
-    virtual ConcreteCompilerType* getBoxType() { return UNKNOWN; }
+    ConcreteCompilerType* getBoxType() override { return UNKNOWN; }
 
-    virtual ConcreteCompilerType* getConcreteType() { return this; }
+    ConcreteCompilerType* getConcreteType() override { return this; }
 
-    virtual CompilerType* getattrType(const std::string* attr, bool cls_only) { return UNDEF; }
+    CompilerType* getattrType(const std::string* attr, bool cls_only) override { return UNDEF; }
 
-    virtual bool canConvertTo(ConcreteCompilerType* other_type) { return true; }
+    bool canConvertTo(ConcreteCompilerType* other_type) override { return true; }
 
-    virtual BoxedClass* guaranteedClass() { return NULL; }
+    BoxedClass* guaranteedClass() override { return NULL; }
 
     Box* deserializeFromFrame(const FrameVals& vals) override {
         assert(vals.size() == 1);

src/codegen/compvars.h

@@ -165,9 +165,9 @@ template <class V> class ValuedCompilerType : public _ValuedCompilerType<V> { pu
 template <> class ValuedCompilerType<llvm::Value*> : public _ValuedCompilerType<llvm::Value*> {
 public:
     virtual llvm::Type* llvmType() = 0;
-    virtual std::string debugName();
+    std::string debugName() override;
 
-    void assertMatches(llvm::Value* v) override final {
+    void assertMatches(llvm::Value* v) override {
         if (v->getType() != llvmType()) {
             v->getType()->dump();
             llvmType()->dump();
@@ -181,13 +181,13 @@ public:
         abort();
     }
 
-    virtual CompilerVariable* dup(ConcreteCompilerVariable* v, DupCache& cache);
-    virtual ConcreteCompilerType* getConcreteType() { return this; }
-    virtual bool canConvertTo(ConcreteCompilerType* other_type) { return other_type == this || other_type == UNKNOWN; }
-    virtual ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
-                                                    ConcreteCompilerType* other_type);
-    void serializeToFrame(VAR* var, std::vector<llvm::Value*>& stackmap_args) override final;
-    int numFrameArgs() override final { return 1; }
+    CompilerVariable* dup(ConcreteCompilerVariable* v, DupCache& cache) override;
+    ConcreteCompilerType* getConcreteType() override { return this; }
+    bool canConvertTo(ConcreteCompilerType* other_type) override { return other_type == this || other_type == UNKNOWN; }
+    ConcreteCompilerVariable* makeConverted(IREmitter& emitter, ConcreteCompilerVariable* var,
+                                            ConcreteCompilerType* other_type) override;
+    void serializeToFrame(VAR* var, std::vector<llvm::Value*>& stackmap_args) override;
+    int numFrameArgs() override { return 1; }
 };
 
 class CompilerVariable {
@@ -273,8 +273,8 @@ private:
     V value;
 
 protected:
-    virtual void drop(IREmitter& emitter) { type->drop(emitter, this); }
-    virtual void grab(IREmitter& emmitter) { type->grab(emmitter, this); }
+    void drop(IREmitter& emitter) override { type->drop(emitter, this); }
+    void grab(IREmitter& emmitter) override { type->grab(emmitter, this); }
 
 public:
     ValuedCompilerVariable(T* type, V value, bool grabbed) : CompilerVariable(grabbed), type(type), value(value) {
@@ -282,8 +282,8 @@ public:
         type->assertMatches(value);
 #endif
     }
-    virtual T* getType() { return type; }
-    virtual V getValue() { return value; }
+    T* getType() override { return type; }
+    V getValue() { return value; }
 
     ConcreteCompilerType* getConcreteType() override { return type->getConcreteType(); }
     ConcreteCompilerType* getBoxType() override { return type->getBoxType(); }
@@ -315,20 +315,20 @@ public:
     ConcreteCompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info) override {
         return type->nonzero(emitter, info, this);
     }
-    virtual CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, const std::string* attr, bool cls_only) {
+    CompilerVariable* getattr(IREmitter& emitter, const OpInfo& info, const std::string* attr, bool cls_only) override {
         return type->getattr(emitter, info, this, attr, cls_only);
     }
-    virtual void setattr(IREmitter& emitter, const OpInfo& info, const std::string* attr, CompilerVariable* v) {
+    void setattr(IREmitter& emitter, const OpInfo& info, const std::string* attr, CompilerVariable* v) override {
         type->setattr(emitter, info, this, attr, v);
     }
 
-    virtual void delattr(IREmitter& emitter, const OpInfo& info, const std::string* attr) {
+    void delattr(IREmitter& emitter, const OpInfo& info, const std::string* attr) override {
         type->delattr(emitter, info, this, attr);
     }
 
-    virtual CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, const std::string* attr, bool clsonly,
-                                       struct ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
-                                       const std::vector<const std::string*>* keyword_names) {
+    CompilerVariable* callattr(IREmitter& emitter, const OpInfo& info, const std::string* attr, bool clsonly,
+                               struct ArgPassSpec argspec, const std::vector<CompilerVariable*>& args,
+                               const std::vector<const std::string*>* keyword_names) override {
         return type->callattr(emitter, info, this, attr, clsonly, argspec, args, keyword_names);
     }
     CompilerVariable* call(IREmitter& emitter, const OpInfo& info, struct ArgPassSpec argspec,

src/codegen/irgen/irgenerator.cpp

@@ -2244,7 +2244,7 @@ private:
     }
 
 public:
-    void addFrameStackmapArgs(PatchpointInfo* pp, std::vector<llvm::Value*>& stackmap_args) {
+    void addFrameStackmapArgs(PatchpointInfo* pp, std::vector<llvm::Value*>& stackmap_args) override {
         int initial_args = stackmap_args.size();
         if (ENABLE_FRAME_INTROSPECTION) {
             // TODO: don't need to use a sorted symbol table if we're explicitly recording the names!

src/codegen/opt/aa.cpp

@@ -221,7 +221,7 @@ public:
         return MayAlias;
     }
 
-    virtual AliasResult alias(const Location& LocA, const Location& LocB) {
+    AliasResult alias(const Location& LocA, const Location& LocB) override {
         if (VERBOSITY("opt.aa") >= 2 && depth == 0) {
             cast<Instruction>(LocA.Ptr)->getParent()->dump();
         }
@@ -245,7 +245,7 @@ public:
     // There are multiple (overloaded) "getModRefInfo" functions in AliasAnalysis, and apparently
     // this means you need to add this line:
     using AliasAnalysis::getModRefInfo;
-    virtual ModRefResult getModRefInfo(ImmutableCallSite CS, const Location& Loc) {
+    ModRefResult getModRefInfo(ImmutableCallSite CS, const Location& Loc) override {
         ModRefResult base = AliasAnalysis::getModRefInfo(CS, Loc);
         if (!CS.getCalledFunction())
             return base;
@@ -308,7 +308,7 @@ public:
         return ModRefResult(mask & base);
     }
 
-    virtual void* getAdjustedAnalysisPointer(const void* ID) {
+    void* getAdjustedAnalysisPointer(const void* ID) override {
         if (ID == &AliasAnalysis::ID)
             return (AliasAnalysis*)this;
         return this;

src/core/cfg.cpp

@@ -1088,7 +1088,7 @@ public:
         curblock = normal_dest;
     }
 
-    virtual bool visit_classdef(AST_ClassDef* node) {
+    bool visit_classdef(AST_ClassDef* node) override {
         // Remap in place: see note in visit_functiondef for why.
 
         // Decorators are evaluated before the defaults:
@@ -1104,7 +1104,7 @@ public:
         return true;
     }
 
-    virtual bool visit_functiondef(AST_FunctionDef* node) {
+    bool visit_functiondef(AST_FunctionDef* node) override {
         // As much as I don't like it, for now we're remapping these in place.
         // This is because we do certain analyses pre-remapping, and associate the
         // results with the node.  We can either do some refactoring and have a way
@@ -1128,7 +1128,7 @@ public:
         return true;
     }
 
-    virtual bool visit_global(AST_Global* node) {
+    bool visit_global(AST_Global* node) override {
         push_back(node);
         return true;
     }
@@ -1142,7 +1142,7 @@ public:
         }
     }
 
-    virtual bool visit_import(AST_Import* node) {
+    bool visit_import(AST_Import* node) override {
         for (AST_alias* a : node->names) {
             AST_LangPrimitive* import = new AST_LangPrimitive(AST_LangPrimitive::IMPORT_NAME);
             import->args.push_back(new AST_Num());
@@ -1182,7 +1182,7 @@ public:
         return true;
     }
 
-    virtual bool visit_importfrom(AST_ImportFrom* node) {
+    bool visit_importfrom(AST_ImportFrom* node) override {
         RELEASE_ASSERT(node->level == 0, "");
 
         AST_LangPrimitive* import = new AST_LangPrimitive(AST_LangPrimitive::IMPORT_NAME);
@@ -1227,7 +1227,7 @@ public:
         return true;
     }
 
-    virtual bool visit_pass(AST_Pass* node) { return true; }
+    bool visit_pass(AST_Pass* node) override { return true; }
 
     bool visit_assert(AST_Assert* node) override {
         AST_Branch* br = new AST_Branch();
@@ -1280,7 +1280,7 @@ public:
         return true;
     }
 
-    virtual bool visit_assign(AST_Assign* node) {
+    bool visit_assign(AST_Assign* node) override {
         AST_expr* remapped_value = remapExpr(node->value);
 
         for (AST_expr* target : node->targets) {
@@ -1289,7 +1289,7 @@ public:
         return true;
     }
 
-    virtual bool visit_augassign(AST_AugAssign* node) {
+    bool visit_augassign(AST_AugAssign* node) override {
         // augassign is pretty tricky; "x" += "y" mostly textually maps to
         // "x" = "x" =+ "y" (using "=+" to represent an augbinop)
         // except that "x" only gets evaluated once.  So it's something like
@@ -1382,7 +1382,7 @@ public:
         return true;
     }
 
-    virtual bool visit_delete(AST_Delete* node) {
+    bool visit_delete(AST_Delete* node) override {
         for (auto t : node->targets) {
             AST_Delete* astdel = new AST_Delete();
             astdel->lineno = node->lineno;
@@ -1418,7 +1418,7 @@ public:
         return true;
     }
 
-    virtual bool visit_expr(AST_Expr* node) {
+    bool visit_expr(AST_Expr* node) override {
         AST_Expr* remapped = new AST_Expr();
         remapped->lineno = node->lineno;
         remapped->col_offset = node->col_offset;
@@ -1427,7 +1427,7 @@ public:
         return true;
     }
 
-    virtual bool visit_print(AST_Print* node) {
+    bool visit_print(AST_Print* node) override {
         AST_expr* dest = remapExpr(node->dest);
 
         int i = 0;
@@ -1464,7 +1464,7 @@ public:
         return true;
     }
 
-    virtual bool visit_return(AST_Return* node) {
+    bool visit_return(AST_Return* node) override {
         if (root_type != AST_TYPE::FunctionDef && root_type != AST_TYPE::Lambda) {
             raiseExcHelper(SyntaxError, "'return' outside function");
         }
@@ -1476,7 +1476,7 @@ public:
         return true;
     }
 
-    virtual bool visit_if(AST_If* node) {
+    bool visit_if(AST_If* node) override {
         if (!curblock)
             return true;
 
@@ -1531,7 +1531,7 @@ public:
         return true;
     }
 
-    virtual bool visit_break(AST_Break* node) {
+    bool visit_break(AST_Break* node) override {
         if (!curblock)
             return true;
 
@@ -1549,7 +1549,7 @@ public:
         return true;
     }
 
-    virtual bool visit_continue(AST_Continue* node) {
+    bool visit_continue(AST_Continue* node) override {
         if (!curblock)
             return true;
 
@@ -1568,7 +1568,7 @@ public:
         return true;
     }
 
-    virtual bool visit_while(AST_While* node) {
+    bool visit_while(AST_While* node) override {
         if (!curblock)
             return true;
 
@@ -1629,7 +1629,7 @@ public:
         return true;
     }
 
-    virtual bool visit_for(AST_For* node) {
+    bool visit_for(AST_For* node) override {
         if (!curblock)
             return true;
 
@@ -1867,7 +1867,7 @@ public:
         return true;
     }
 
-    virtual bool visit_with(AST_With* node) {
+    bool visit_with(AST_With* node) override {
         char ctxmgrname_buf[80];
         snprintf(ctxmgrname_buf, 80, "#ctxmgr_%p", node);
         char exitname_buf[80];