Changeset 23a08aa0 for src

Timestamp:

Sep 19, 2022, 8:11:02 PM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

aa9f215

Parents:

ebf8ca5 (diff), ae1d151 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

fix merge conflict

Location:

src

Files:

• AST/Decl.hpp (modified) (1 diff)
• AST/DeclReplacer.cpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Pass.proto.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (4 diffs)
• AST/StorageClasses.hpp (modified) (3 diffs)
• AST/Type.cpp (modified) (3 diffs)
• AST/Type.hpp (modified) (4 diffs)
• CodeGen/CodeGenerator.cc (modified) (1 diff)
• Common/utility.h (modified) (1 diff)
• CompilationState.cc (modified) (1 diff)
• Concurrency/Keywords.cc (modified) (9 diffs)
• Concurrency/Waitfor.cc (modified) (1 diff)
• Concurrency/WaitforNew.cpp (modified) (1 diff)
• ControlStruct/ExceptTranslateNew.cpp (modified) (2 diffs)
• ControlStruct/LabelFixer.cc (modified) (1 diff)
• ControlStruct/LabelFixer.h (modified) (1 diff)
• ControlStruct/MLEMutator.cc (modified) (1 diff)
• ControlStruct/MLEMutator.h (modified) (1 diff)
• GenPoly/GenPoly.cc (modified) (7 diffs)
• GenPoly/GenPoly.h (modified) (4 diffs)
• GenPoly/InstantiateGeneric.h (modified) (1 diff)
• GenPoly/InstantiateGenericNew.cpp (added)
• GenPoly/Lvalue2.cc (modified) (1 diff)
• GenPoly/ScrubTyVars.cc (modified) (2 diffs)
• GenPoly/ScrubTyVars.h (modified) (3 diffs)
• GenPoly/SpecializeNew.cpp (modified) (1 diff)
• GenPoly/module.mk (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (2 diffs)
• Makefile.am (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/lex.ll (modified) (2 diffs)
• Parser/parser.yy (modified) (5 diffs)
• ResolvExpr/CandidateFinder.cpp (modified) (29 diffs)
• SynTree/Statement.cc (modified) (4 diffs)
• SynTree/Statement.h (modified) (2 diffs)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/Type.h (modified) (3 diffs)
• Tuples/TupleExpansionNew.cpp (modified) (2 diffs)
• Virtual/ExpandCasts.cc (modified) (2 diffs)
• config.h.in (modified) (1 diff)
• main.cc (modified) (11 diffs)

src/AST/Decl.hpp

@@ -217 +217 @@
 
         /// convenience accessor to match Type::isComplete()
-        bool isComplete() { return sized; }
+        bool isComplete() const { return sized; }
 
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/DeclReplacer.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May 8 13:00:00 2019
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Wed May 8 13:00:00 2019
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Sep 15 11:55:00 2022
+// Update Count     : 2
 //
 
 #include "DeclReplacer.hpp"
+
 #include "Expr.hpp"
+#include "Pass.hpp"
 #include "Type.hpp"
-
-#include "Pass.hpp"
 
 namespace ast {
 
 namespace DeclReplacer {
-        namespace {
-                struct DeclReplacer {
-                private:
-                        const DeclMap & declMap;
-                        const TypeMap & typeMap;
-                        bool debug;
 
-                public:
-                        DeclReplacer(const DeclMap & declMap, const TypeMap & typeMap, bool debug)
-                                : declMap( declMap ), typeMap( typeMap ), debug( debug )
-                        {}
+namespace {
+        struct DeclReplacer {
+        private:
+                const DeclMap & declMap;
+                const TypeMap & typeMap;
+                bool debug;
 
-                        const ast::VariableExpr * previsit( const ast::VariableExpr * );
-                        const ast::TypeInstType * previsit( const ast::TypeInstType * );
-                };
+        public:
+                DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug )
+                        : declMap( declMap ), typeMap( typeMap ), debug( debug )
+                {}
 
-                struct VarExprReplacer {
-                private:
-                        const ExprMap & exprMap;
-                        
-                public:
-                        VarExprReplacer(const ExprMap & exprMap): exprMap (exprMap) {}
+                const ast::VariableExpr * previsit( const ast::VariableExpr * );
+                const ast::TypeInstType * previsit( const ast::TypeInstType * );
+        };
 
-                        const Expr * postvisit (const VariableExpr *);
-                };
+        struct VarExprReplacer {
+        private:
+                const ExprMap & exprMap;
+
+        public:
+                VarExprReplacer( const ExprMap & exprMap ) : exprMap( exprMap ) {}
+
+                const Expr * postvisit( const VariableExpr * );
+        };
+} // namespace
+
+const ast::Node * replace( const ast::Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
+        if(!node) return nullptr;
+        Pass<DeclReplacer> replacer = { declMap, typeMap, debug };
+        return node->accept( replacer );
+}
+
+const ast::Node * replace( const ast::Node * node, const DeclMap & declMap, bool debug ) {
+        TypeMap typeMap;
+        return replace( node, declMap, typeMap, debug );
+}
+
+const ast::Node * replace( const ast::Node * node, const TypeMap & typeMap, bool debug ) {
+        DeclMap declMap;
+        return replace( node, declMap, typeMap, debug );
+}
+
+const ast::Node * replace( const ast::Node * node, const ExprMap & exprMap ) {
+        Pass<VarExprReplacer> replacer = {exprMap};
+        return node->accept( replacer );
+}
+
+namespace {
+        // replace variable with new node from decl map
+        const ast::VariableExpr * DeclReplacer::previsit( const VariableExpr * varExpr ) {
+                // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
+                if ( !declMap.count( varExpr->var ) ) return varExpr;
+
+                auto replacement = declMap.at( varExpr->var );
+                if ( debug ) {
+                        std::cerr << "replacing variable reference: "
+                                << (void*)varExpr->var.get() << " " << varExpr->var
+                                << " with " << (void*)replacement << " " << replacement
+                                << std::endl;
+                }
+                auto nexpr = mutate(varExpr);
+                nexpr->var = replacement;
+                return nexpr;
         }
 
-        const ast::Node * replace( const ast::Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
-                if(!node) return nullptr;
-                Pass<DeclReplacer> replacer = { declMap, typeMap, debug };
-                return node->accept( replacer );
+        const TypeInstType * DeclReplacer::previsit( const TypeInstType * inst ) {
+                if ( !typeMap.count( inst->base ) ) return inst;
+
+                auto replacement = typeMap.at( inst->base );
+                if ( debug ) {
+                        std::cerr << "replacing type reference: "
+                                << (void*)inst->base.get() << " " << inst->base
+                                << " with " << (void*)replacement << " " << replacement
+                                << std::endl;
+                }
+                auto ninst = mutate(inst);
+                ninst->base = replacement;
+                return ninst;
         }
 
-        const ast::Node * replace( const ast::Node * node, const DeclMap & declMap, bool debug ) {
-                TypeMap typeMap;
-                return replace( node, declMap, typeMap, debug );
+        const Expr * VarExprReplacer::postvisit( const VariableExpr * expr ) {
+                if ( !exprMap.count( expr->var ) ) return expr;
+                return exprMap.at( expr->var );
         }
+} // namespace
 
-        const ast::Node * replace( const ast::Node * node, const TypeMap & typeMap, bool debug ) {
-                DeclMap declMap;
-                return replace( node, declMap, typeMap, debug );
-        }
+} // namespace DeclReplacer
 
-        const ast::Node * replace( const ast::Node * node, const ExprMap & exprMap) {
-                Pass<VarExprReplacer> replacer = {exprMap};
-                return node->accept( replacer );
-        }
-
-        namespace {
-                // replace variable with new node from decl map
-                const ast::VariableExpr * DeclReplacer::previsit( const VariableExpr * varExpr ) {
-                        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
-                        if ( !declMap.count( varExpr->var ) ) return varExpr;
-
-                        auto replacement = declMap.at( varExpr->var );
-                        if ( debug ) {
-                                std::cerr << "replacing variable reference: "
-                                        << (void*)varExpr->var.get() << " " << varExpr->var
-                                        << " with " << (void*)replacement << " " << replacement
-                                        << std::endl;
-                        }
-                        auto nexpr = mutate(varExpr);
-                        nexpr->var = replacement;
-                        return nexpr;
-                }
-
-                const TypeInstType * DeclReplacer::previsit( const TypeInstType * inst ) {
-                        if ( !typeMap.count( inst->base ) ) return inst;
-
-                        auto replacement = typeMap.at( inst->base );
-                        if ( debug ) {
-                                std::cerr << "replacing type reference: "
-                                        << (void*)inst->base.get() << " " << inst->base
-                                        << " with " << (void*)replacement << " " << replacement
-                                        << std::endl;
-                        }
-                        auto ninst = mutate(inst);
-                        ninst->base = replacement;
-                        return ninst;
-                }
-
-                const Expr * VarExprReplacer::postvisit( const VariableExpr * expr ) {
-                        if (!exprMap.count(expr->var)) return expr;
-
-                        return exprMap.at(expr->var);
-                }
-
-        }
-}
-
-}
+} // namespace ast
 
 // Local Variables: //

src/AST/Pass.hpp

@@ -327 +327 @@
 struct PureVisitor {};
 
+struct WithCodeLocation {
+        const CodeLocation * location = nullptr;
+};
+
 /// Keep track of the polymorphic const TypeSubstitution * typeSubs for the current expression.
 struct WithConstTypeSubstitution {

src/AST/Pass.impl.hpp

@@ -25 +25 @@
 #define VISIT_START( node ) \
         using namespace ast; \
+        /* back-up the last known code location */ \
+        __attribute__((unused)) auto loc_guard = ast::__pass::make_location_guard( core, node, 0 ); \
         /* back-up the visit children */ \
         __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \

src/AST/Pass.proto.hpp

@@ -326 +326 @@
         }
 
+        template< typename core_t, typename node_t >
+        static auto make_location_guard( core_t & core, node_t * node, int )
+                        -> decltype( node->location, ValueGuardPtr<const CodeLocation *>( &core.location ) ) {
+                ValueGuardPtr<const CodeLocation *> guard( &core.location );
+                core.location = &node->location;
+                return guard;
+        }
+
+        template< typename core_t, typename node_t >
+        static auto make_location_guard( core_t &, node_t *, long ) -> int {
+                return 0;
+        }
+
         // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
         // All passes which have such functions are assumed desire this behaviour

src/AST/Print.cpp

@@ -33 +33 @@
 {
         return array<C,sizeof...(T)>{
-                forward<T>(values)...
+                std::forward<T>(values)...
         };
 }
@@ -86 +86 @@
 
                 static constexpr auto StorageClasses = make_array<const char*>(
-                        "extern", "static", "auto", "register", "_Thread_local"
+                        "extern", "static", "auto", "register", "__thread", "_Thread_local"
                 );
 
@@ -215 +215 @@
                         ++indent;
                         ptrToEnum->base->accept( *this );
-                        --indent;  
+                        --indent;
                 }
 
@@ -1623 +1623 @@
 // if the wrong size is specified
 constexpr array<const char*, 3> Printer::Names::FuncSpecifiers;
-constexpr array<const char*, 5> Printer::Names::StorageClasses;
+constexpr array<const char*, 6> Printer::Names::StorageClasses;
 constexpr array<const char*, 6> Printer::Names::Qualifiers;
 }

src/AST/StorageClasses.hpp

@@ -24 +24 @@
         /// Bitflags for storage classes
         enum {
-                Extern      = 1 << 0,
-                Static      = 1 << 1,
-                Auto        = 1 << 2,
-                Register    = 1 << 3,
-                ThreadLocal = 1 << 4,
-                NumClasses       = 5
+                Extern         = 1 << 0,
+                Static         = 1 << 1,
+                Auto           = 1 << 2,
+                Register       = 1 << 3,
+                ThreadLocalGcc = 1 << 4,
+                ThreadLocalC11 = 1 << 5,
+                NumClasses          = 6
         };
 
@@ -37 +38 @@
                         unsigned int val;
                         struct {
-                                bool is_extern      : 1;
-                                bool is_static      : 1;
-                                bool is_auto        : 1;
-                                bool is_register    : 1;
-                                bool is_threadlocal : 1;
+                                bool is_extern         : 1;
+                                bool is_static         : 1;
+                                bool is_auto           : 1;
+                                bool is_register       : 1;
+                                bool is_threadlocalGcc : 1;
+                                bool is_threadlocalC11 : 1;
                         };
 
@@ -48 +50 @@
 
                 constexpr class_flags( unsigned int val = 0 ) : val(val) {}
+
+                bool is_threadlocal_any() { return this->is_threadlocalC11 || this->is_threadlocalGcc; }
         };
 

src/AST/Type.cpp

@@ -143 +143 @@
 TraitInstType::TraitInstType(
         const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: BaseInstType( b->name, q, move(as) ), base( b ) {}
+: BaseInstType( b->name, q, std::move(as) ), base( b ) {}
 
 // --- TypeInstType
@@ -149 +149 @@
 TypeInstType::TypeInstType( const TypeDecl * b,
         CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
-: BaseInstType( b->name, q, move(as) ), base( b ), kind( b->kind ) {}
+: BaseInstType( b->name, q, std::move(as) ), base( b ), kind( b->kind ) {}
 
 void TypeInstType::set_base( const TypeDecl * b ) {
@@ -161 +161 @@
 
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
-: Type( q ), types( move(ts) ), members() {
+: Type( q ), types( std::move(ts) ), members() {
         // This constructor is awkward. `TupleType` needs to contain objects so that members can be
         // named, but members without initializer nodes end up getting constructors, which breaks

src/AST/Type.hpp

@@ -83 +83 @@
 template< enum Node::ref_type ref_t >
 void reset_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q = {} ) {
-        if ( p->qualifiers.val != q.val ) p.get_and_mutate()->qualifiers = q;
+        if ( p->qualifiers != q ) p.get_and_mutate()->qualifiers = q;
 }
 
@@ -89 +89 @@
 template< enum Node::ref_type ref_t >
 void add_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q ) {
-        if ( ( p->qualifiers.val & q.val ) != q.val ) p.get_and_mutate()->qualifiers |= q;
+        if ( ( p->qualifiers & q ) != q ) p.get_and_mutate()->qualifiers |= q;
 }
 
@@ -95 +95 @@
 template< enum Node::ref_type ref_t >
 void remove_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q ) {
-        if ( ( p->qualifiers.val & q.val ) != 0 ) p.get_and_mutate()->qualifiers -= q;
+        if ( ( p->qualifiers & q ) != 0 ) p.get_and_mutate()->qualifiers -= q;
 }
 
@@ -412 +412 @@
                 std::string typeString() const { return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + base->name; }
                 bool operator==(const TypeEnvKey & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
-
         };
 

src/CodeGen/CodeGenerator.cc

@@ -493 +493 @@
                                         assert( false );
                                 } // switch
+                        } else if( varExpr->get_var()->get_linkage() == LinkageSpec::BuiltinCFA && varExpr->get_var()->get_name() == "intptr" ) {
+                                // THIS is a hack to make it a constant until a proper constexpr solution is created
+                                output << "((void*)";
+                                std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
+                                (*arg++)->accept( *visitor );
+                                output << ")";
                         } else {
                                 varExpr->accept( *visitor );

src/Common/utility.h

@@ -322 +322 @@
 
         ValueGuardPtr(T * inRef) : old( inRef ? *inRef : T() ), ref(inRef) {}
+        ValueGuardPtr(const ValueGuardPtr& other) = delete;
+        ValueGuardPtr(ValueGuardPtr&& other) : old(other.old), ref(other.ref) { other.ref = nullptr; }
         ~ValueGuardPtr() { if( ref ) *ref = old; }
 };

src/CompilationState.cc

@@ -31 +31 @@
         genproto = false,
         deterministic_output = false,
-        useNewAST = CFA_USE_NEW_AST,
+        useNewAST = true,
         nomainp = false,
         parsep = false,

src/Concurrency/Keywords.cc

@@ -508 +508 @@
                 ObjectDecl * vtable_object = Virtual::makeVtableForward(
                         "_default_vtable_object_declaration",
-                        vtable_decl->makeInst( move( poly_args ) ) );
+                        vtable_decl->makeInst( std::move( poly_args ) ) );
                 declsToAddBefore.push_back( vtable_object );
                 declsToAddBefore.push_back(
@@ -681 +681 @@
                         void lock (monitor_t & this) {
                                 lock(get_monitor(this));
-                        }       
+                        }
                 */
                 FunctionDecl * lock_decl = new FunctionDecl(
@@ -700 +700 @@
                 CompoundStmt * lock_statement = new CompoundStmt();
                 lock_statement->push_back(
-                        new ExprStmt( 
+                        new ExprStmt(
                                 new UntypedExpr (
                                         new NameExpr( "lock" ),
@@ -716 +716 @@
                         void unlock (monitor_t & this) {
                                 unlock(get_monitor(this));
-                        }       
+                        }
                 */
                 FunctionDecl * unlock_decl = new FunctionDecl(
@@ -736 +736 @@
 
                 unlock_statement->push_back(
-                        new ExprStmt( 
+                        new ExprStmt(
                                 new UntypedExpr(
                                         new NameExpr( "unlock" ),
@@ -746 +746 @@
                 );
                 unlock_decl->set_statements( unlock_statement );
-                
+
                 // pushes routines to declsToAddAfter to add at a later time
                 declsToAddAfter.push_back( lock_decl );
@@ -1054 +1054 @@
                         assert( !thread_guard_decl );
                         thread_guard_decl = decl;
-                } 
+                }
                 else if ( decl->name == "__mutex_stmt_lock_guard" && decl->body ) {
                         assert( !lock_guard_decl );
@@ -1206 +1206 @@
                                                         new NameExpr( "__get_mutexstmt_lock_type" ),
                                                         { args.front()->clone() }
-                                                ) 
+                                                )
                                         )
                                 ),
@@ -1225 +1225 @@
 
                 StructInstType * lock_guard_struct = new StructInstType( noQualifiers, lock_guard_decl );
-                TypeExpr * lock_type_expr = new TypeExpr( 
+                TypeExpr * lock_type_expr = new TypeExpr(
                         new TypeofType( noQualifiers, new UntypedExpr(
                                 new NameExpr( "__get_mutexstmt_lock_type" ),
                                 { args.front()->clone() }
-                                ) 
-                        ) 
+                                )
+                        )
                 );
 

src/Concurrency/Waitfor.cc

@@ -402 +402 @@
 
                 clause.target.function = nullptr;
-                clause.target.arguments.empty();
+                clause.target.arguments.clear();
                 clause.condition = nullptr;
         }

src/Concurrency/WaitforNew.cpp

@@ -101 +101 @@
 namespace {
 
-class GenerateWaitForCore :
+class GenerateWaitForCore final :
                 public ast::WithSymbolTable, public ast::WithConstTranslationUnit {
         const ast::FunctionDecl * decl_waitfor    = nullptr;

src/ControlStruct/ExceptTranslateNew.cpp

@@ -32 +32 @@
         }
 
-class TranslateThrowsCore : public ast::WithGuards {
+class TranslateThrowsCore final : public ast::WithGuards {
         const ast::ObjectDecl * terminateHandlerExcept;
         enum Context { NoHandler, TerHandler, ResHandler } currentContext;
@@ -136 +136 @@
 
 
-class TryMutatorCore {
+class TryMutatorCore final {
         // The built in types used in translation.
         const ast::StructDecl * except_decl;

src/ControlStruct/LabelFixer.cc

@@ -119 +119 @@
 
 // Builds a table that maps a label to its defining statement.
-std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
+std::map<Label, Statement * > * LabelFixer::resolveJumps() {
         std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
         for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {

src/ControlStruct/LabelFixer.h

@@ -33 +33 @@
         LabelFixer( LabelGenerator *gen = 0 );
 
-        std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
+        std::map < Label, Statement * > *resolveJumps();
 
         // Declarations

src/ControlStruct/MLEMutator.cc

@@ -141 +141 @@
 
 
-        Statement *MultiLevelExitMutator::postmutate( BranchStmt *branchStmt )
-                        throw ( SemanticErrorException ) {
+        Statement *MultiLevelExitMutator::postmutate( BranchStmt *branchStmt ) {
                 std::string originalTarget = branchStmt->originalTarget;
 

src/ControlStruct/MLEMutator.h

@@ -41 +41 @@
 
                 void premutate( CompoundStmt *cmpndStmt );
-                Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException );
+                Statement * postmutate( BranchStmt *branchStmt );
                 void premutate( WhileDoStmt *whileDoStmt );
                 Statement * postmutate( WhileDoStmt *whileDoStmt );

src/GenPoly/GenPoly.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 29 21:45:53 2016
-// Update Count     : 14
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Sep 14  9:24:00 2022
+// Update Count     : 15
 //
 
@@ -83 +83 @@
                 }
 
+                bool hasDynParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap &tyVars, const ast::TypeSubstitution *typeSubs ) {
+                        for ( ast::ptr<ast::Expr> const & param : params ) {
+                                auto paramType = param.as<ast::TypeExpr>();
+                                assertf( paramType, "Aggregate parameters should be type expressions." );
+                                if ( isDynType( paramType->type, tyVars, typeSubs ) ) {
+                                        return true;
+                                }
+                        }
+                        return false;
+                }
+
                 /// Checks a parameter list for inclusion of polymorphic parameters; will substitute according to env if present
                 bool includesPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
@@ -198 +209 @@
                 }
                 return 0;
+        }
+
+        const ast::BaseInstType *isDynType( const ast::Type *type, const TyVarMap &tyVars, const ast::TypeSubstitution *typeSubs ) {
+                type = replaceTypeInst( type, typeSubs );
+
+                if ( auto inst = dynamic_cast<ast::TypeInstType const *>( type ) ) {
+                        auto var = tyVars.find( inst->name );
+                        if ( var != tyVars.end() && var->second.isComplete ) {
+                                return inst;
+                        }
+                } else if ( auto inst = dynamic_cast<ast::StructInstType const *>( type ) ) {
+                        if ( hasDynParams( inst->params, tyVars, typeSubs ) ) {
+                                return inst;
+                        }
+                } else if ( auto inst = dynamic_cast<ast::UnionInstType const *>( type ) ) {
+                        if ( hasDynParams( inst->params, tyVars, typeSubs ) ) {
+                                return inst;
+                        }
+                }
+                return nullptr;
         }
 
@@ -378 +409 @@
                 inline D* as( B* p ) { return reinterpret_cast<D*>(p); }
 
+                template<typename D, typename B>
+                inline D const * as( B const * p ) {
+                        return reinterpret_cast<D const *>( p );
+                }
+
                 /// Flattens a declaration list
                 template<typename Output>
@@ -391 +427 @@
                         for ( Type* ty : src ) {
                                 ResolvExpr::flatten( ty, out );
+                        }
+                }
+
+                void flattenList( vector<ast::ptr<ast::Type>> const & src,
+                                vector<ast::ptr<ast::Type>> & out ) {
+                        for ( auto const & type : src ) {
+                                ResolvExpr::flatten( type, out );
                         }
                 }
@@ -409 +452 @@
                                 // if ( is<VoidType>( aparam->get_type() ) || is<VoidType>( bparam->get_type() ) ) continue;
                                 if ( ! typesPolyCompatible( aparam->get_type(), bparam->get_type() ) ) return false;
+                        }
+
+                        return true;
+                }
+
+                bool paramListsPolyCompatible(
+                                std::vector<ast::ptr<ast::Expr>> const & lparams,
+                                std::vector<ast::ptr<ast::Expr>> const & rparams ) {
+                        if ( lparams.size() != rparams.size() ) {
+                                return false;
+                        }
+
+                        for ( auto lparam = lparams.begin(), rparam = rparams.begin() ;
+                                        lparam != lparams.end() ; ++lparam, ++rparam ) {
+                                ast::TypeExpr const * lexpr = lparam->as<ast::TypeExpr>();
+                                assertf( lexpr, "Aggregate parameters should be type expressions" );
+                                ast::TypeExpr const * rexpr = rparam->as<ast::TypeExpr>();
+                                assertf( rexpr, "Aggregate parameters should be type expressions" );
+
+                                // xxx - might need to let VoidType be a wildcard here too; could have some voids
+                                // stuffed in for dtype-statics.
+                                // if ( is<VoidType>( lexpr->type() ) || is<VoidType>( bparam->get_type() ) ) continue;
+                                if ( !typesPolyCompatible( lexpr->type, rexpr->type ) ) {
+                                        return false;
+                                }
                         }
 
@@ -505 +573 @@
         }
 
+bool typesPolyCompatible( ast::Type const * lhs, ast::Type const * rhs ) {
+        type_index const lid = typeid(*lhs);
+
+        // Polymorphic types always match:
+        if ( type_index(typeid(ast::TypeInstType)) == lid ) return true;
+
+        type_index const rid = typeid(*rhs);
+        if ( type_index(typeid(ast::TypeInstType)) == rid ) return true;
+
+        // All other types only match if they are the same type:
+        if ( lid != rid ) return false;
+
+        // So remaining types can be examined case by case.
+        // Recurse through type structure (conditions borrowed from Unify.cc).
+
+        if ( type_index(typeid(ast::BasicType)) == lid ) {
+                return as<ast::BasicType>(lhs)->kind == as<ast::BasicType>(rhs)->kind;
+        } else if ( type_index(typeid(ast::PointerType)) == lid ) {
+                ast::PointerType const * l = as<ast::PointerType>(lhs);
+                ast::PointerType const * r = as<ast::PointerType>(rhs);
+
+                // void pointers should match any other pointer type.
+                return is<ast::VoidType>( l->base.get() )
+                        || is<ast::VoidType>( r->base.get() )
+                        || typesPolyCompatible( l->base.get(), r->base.get() );
+        } else if ( type_index(typeid(ast::ReferenceType)) == lid ) {
+                ast::ReferenceType const * l = as<ast::ReferenceType>(lhs);
+                ast::ReferenceType const * r = as<ast::ReferenceType>(rhs);
+
+                // void references should match any other reference type.
+                return is<ast::VoidType>( l->base.get() )
+                        || is<ast::VoidType>( r->base.get() )
+                        || typesPolyCompatible( l->base.get(), r->base.get() );
+        } else if ( type_index(typeid(ast::ArrayType)) == lid ) {
+                ast::ArrayType const * l = as<ast::ArrayType>(lhs);
+                ast::ArrayType const * r = as<ast::ArrayType>(rhs);
+
+                if ( l->isVarLen ) {
+                        if ( !r->isVarLen ) return false;
+                } else {
+                        if ( r->isVarLen ) return false;
+
+                        auto lc = l->dimension.as<ast::ConstantExpr>();
+                        auto rc = r->dimension.as<ast::ConstantExpr>();
+                        if ( lc && rc && lc->intValue() != rc->intValue() ) {
+                                return false;
+                        }
+                }
+
+                return typesPolyCompatible( l->base.get(), r->base.get() );
+        } else if ( type_index(typeid(ast::FunctionType)) == lid ) {
+                ast::FunctionType const * l = as<ast::FunctionType>(lhs);
+                ast::FunctionType const * r = as<ast::FunctionType>(rhs);
+
+                std::vector<ast::ptr<ast::Type>> lparams, rparams;
+                flattenList( l->params, lparams );
+                flattenList( r->params, rparams );
+                if ( lparams.size() != rparams.size() ) return false;
+                for ( unsigned i = 0; i < lparams.size(); ++i ) {
+                        if ( !typesPolyCompatible( lparams[i], rparams[i] ) ) return false;
+                }
+
+                std::vector<ast::ptr<ast::Type>> lrets, rrets;
+                flattenList( l->returns, lrets );
+                flattenList( r->returns, rrets );
+                if ( lrets.size() != rrets.size() ) return false;
+                for ( unsigned i = 0; i < lrets.size(); ++i ) {
+                        if ( !typesPolyCompatible( lrets[i], rrets[i] ) ) return false;
+                }
+                return true;
+        } else if ( type_index(typeid(ast::StructInstType)) == lid ) {
+                ast::StructInstType const * l = as<ast::StructInstType>(lhs);
+                ast::StructInstType const * r = as<ast::StructInstType>(rhs);
+
+                if ( l->name != r->name ) return false;
+                return paramListsPolyCompatible( l->params, r->params );
+        } else if ( type_index(typeid(ast::UnionInstType)) == lid ) {
+                ast::UnionInstType const * l = as<ast::UnionInstType>(lhs);
+                ast::UnionInstType const * r = as<ast::UnionInstType>(rhs);
+
+                if ( l->name != r->name ) return false;
+                return paramListsPolyCompatible( l->params, r->params );
+        } else if ( type_index(typeid(ast::EnumInstType)) == lid ) {
+                ast::EnumInstType const * l = as<ast::EnumInstType>(lhs);
+                ast::EnumInstType const * r = as<ast::EnumInstType>(rhs);
+
+                return l->name == r->name;
+        } else if ( type_index(typeid(ast::TraitInstType)) == lid ) {
+                ast::TraitInstType const * l = as<ast::TraitInstType>(lhs);
+                ast::TraitInstType const * r = as<ast::TraitInstType>(rhs);
+
+                return l->name == r->name;
+        } else if ( type_index(typeid(ast::TupleType)) == lid ) {
+                ast::TupleType const * l = as<ast::TupleType>(lhs);
+                ast::TupleType const * r = as<ast::TupleType>(rhs);
+
+                std::vector<ast::ptr<ast::Type>> ltypes, rtypes;
+                flattenList( l->types, ( ltypes ) );
+                flattenList( r->types, ( rtypes ) );
+                if ( ltypes.size() != rtypes.size() ) return false;
+
+                for ( unsigned i = 0 ; i < ltypes.size() ; ++i ) {
+                        if ( !typesPolyCompatible( ltypes[i], rtypes[i] ) ) return false;
+                }
+                return true;
+        // The remaining types (VoidType, VarArgsType, ZeroType & OneType)
+        // have no variation so will always be equal.
+        } else {
+                return true;
+        }
+}
+
         namespace {
                 // temporary hack to avoid re-implementing anything related to TyVarMap

src/GenPoly/GenPoly.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:22:57 2017
-// Update Count     : 7
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Aug 19 16:03:00 2022
+// Update Count     : 8
 //
 
@@ -27 +27 @@
 namespace GenPoly {
 
+        // TODO Via some tricks this works for ast::TypeDecl::Data as well.
         typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
+
         /// Replaces a TypeInstType by its referrent in the environment, if applicable
         Type* replaceTypeInst( Type* type, const TypeSubstitution* env );
@@ -41 +43 @@
         /// returns dynamic-layout type if is dynamic-layout type in tyVars, NULL otherwise; will look up substitution in env if provided
         ReferenceToType *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
+        const ast::BaseInstType *isDynType( const ast::Type *type, const TyVarMap &tyVars, const ast::TypeSubstitution *typeSubs = 0 );
 
         /// true iff function has dynamic-layout return type under the given type variable map
@@ -83 +86 @@
         /// true iff types are structurally identical, where TypeInstType's match any type.
         bool typesPolyCompatible( Type *aty, Type *bty );
+        bool typesPolyCompatible( ast::Type const * lhs, ast::Type const * rhs );
 
         /// true if arg requires boxing given exprTyVars

src/GenPoly/InstantiateGeneric.h

@@ -19 +19 @@
 
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 
 namespace GenPoly {
-        /// Replaces all generic types that have static layout with concrete instantiations.
-        /// Types with concrete values for otype parameters will be template-expanded, while
-        /// dtype and ftype parameters will be replaced by the appropriate void type.
-        void instantiateGeneric( std::list< Declaration* > &translationUnit );
+/// Replaces all generic types that have static layout with concrete
+/// instantiations. Types with concrete values for otype parameters will be
+/// template-expanded, while dtype and ftype parameters will be replaced by
+/// the appropriate void type.
+void instantiateGeneric( std::list< Declaration* > &translationUnit );
+void instantiateGeneric( ast::TranslationUnit & translationUnit );
 } // namespace GenPoly
 

src/GenPoly/Lvalue2.cc

@@ -23 +23 @@
 }
 
-
 }

src/GenPoly/ScrubTyVars.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 15:44:27 2017
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Aug 19 16:10:00 2022
+// Update Count     : 4
 //
 
 #include <utility>                      // for pair
 
+#include "AST/Pass.hpp"
 #include "GenPoly.h"                    // for mangleType, TyVarMap, alignof...
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::const_it...
 #include "ScrubTyVars.h"
+#include "SymTab/Mangler.h"             // for mangle, typeMode
 #include "SynTree/Declaration.h"        // for TypeDecl, TypeDecl::Data, Typ...
 #include "SynTree/Expression.h"         // for Expression (ptr only), NameExpr
@@ -112 +114 @@
                 return pointer;
         }
+
+namespace {
+
+enum class ScrubMode {
+        FromMap,
+        DynamicFromMap,
+        All,
+};
+
+struct ScrubTypeVars :
+        public ast::WithGuards,
+        public ast::WithShortCircuiting,
+        public ast::WithVisitorRef<ScrubTypeVars> {
+
+        ScrubTypeVars( ScrubMode m, TyVarMap const * tv ) :
+                        mode ( m ), typeVars( tv ) {}
+
+        void previsit( ast::TypeInstType const * ) { visit_children = false; }
+        void previsit( ast::StructInstType const * ) { visit_children = false; }
+        void previsit( ast::UnionInstType const * ) { visit_children = false; }
+        void previsit( ast::SizeofExpr const * expr ) { primeBaseScrub( expr->type ); }
+        void previsit( ast::AlignofExpr const * expr ) { primeBaseScrub( expr->type ); }
+        void previsit( ast::PointerType const * type ) { primeBaseScrub( type->base ); }
+
+        ast::Type const * postvisit( ast::TypeInstType const * type );
+        ast::Type const * postvisit( ast::StructInstType const * type );
+        ast::Type const * postvisit( ast::UnionInstType const * type );
+        ast::Expr const * postvisit( ast::SizeofExpr const * expr );
+        ast::Expr const * postvisit( ast::AlignofExpr const * expr );
+        ast::Type const * postvisit( ast::PointerType const * type );
+
+private:
+        ScrubMode const mode;
+        /// Type varriables to scrub.
+        TyVarMap const * const typeVars;
+        /// Value cached by primeBaseScrub.
+        ast::Type const * dynType = nullptr;
+
+        /// Returns the type if it should be scrubbed, nullptr otherwise.
+        ast::Type const * shouldScrub( ast::Type const * type ) {
+                switch ( mode ) {
+                case ScrubMode::FromMap:
+                        return isPolyType( type, *typeVars );
+                case ScrubMode::DynamicFromMap:
+                        return isDynType( type, *typeVars );
+                case ScrubMode::All:
+                        return isPolyType( type );
+                default:
+                        assertf( false, "Invalid ScrubMode in shouldScrub." );
+                        throw;
+                }
+        }
+
+        void primeBaseScrub( ast::Type const * type ) {
+                // Need to determine whether type needs to be scrubbed to
+                // determine whether automatic recursion is necessary.
+                if ( ast::Type const * t = shouldScrub( type ) ) {
+                        visit_children = false;
+                        GuardValue( dynType ) = t;
+                }
+        }
+
+        ast::Type const * postvisitAggregateType(
+                        ast::BaseInstType const * type ) {
+                if ( !shouldScrub( type ) ) return type;
+                return new ast::PointerType( new ast::VoidType( type->qualifiers ) );
+        }
+};
+
+ast::Type const * ScrubTypeVars::postvisit( ast::TypeInstType const * type ) {
+        // This implies that mode == ScrubMode::All.
+        if ( !typeVars ) {
+                if ( ast::TypeDecl::Ftype == type->kind ) {
+                        return new ast::PointerType(
+                                new ast::FunctionType( ast::FixedArgs ) );
+                } else {
+                        return new ast::PointerType(
+                                new ast::VoidType( type->qualifiers ) );
+                }
+        }
+
+        auto typeVar = typeVars->find( type->name );
+        if ( typeVar == typeVars->end() ) {
+                return type;
+        }
+
+        switch ( typeVar->second.kind ) {
+        case ast::TypeDecl::Dtype:
+        case ast::TypeDecl::Ttype:
+                return new ast::PointerType(
+                        new ast::VoidType( type->qualifiers ) );
+        case ast::TypeDecl::Ftype:
+                return new ast::PointerType(
+                        new ast::FunctionType( ast::VariableArgs ) );
+        default:
+                assertf( false,
+                        "Unhandled type variable kind: %d", typeVar->second.kind );
+                throw; // Just in case the assert is removed, stop here.
+        }
+}
+
+ast::Type const * ScrubTypeVars::postvisit( ast::StructInstType const * type ) {
+        return postvisitAggregateType( type );
+}
+
+ast::Type const * ScrubTypeVars::postvisit( ast::UnionInstType const * type ) {
+        return postvisitAggregateType( type );
+}
+
+ast::Expr const * ScrubTypeVars::postvisit( ast::SizeofExpr const * expr ) {
+        // sizeof( T ) becomes the _sizeof_T parameter.
+        if ( dynType ) {
+                return new ast::NameExpr( expr->location,
+                        sizeofName( Mangle::mangle( dynType, Mangle::typeMode() ) ) );
+        } else {
+                return expr;
+        }
+}
+
+ast::Expr const * ScrubTypeVars::postvisit( ast::AlignofExpr const * expr ) {
+        // alignof( T ) becomes the _alignof_T parameter.
+        if ( dynType ) {
+                return new ast::NameExpr( expr->location,
+                        alignofName( Mangle::mangle( dynType, Mangle::typeMode() ) ) );
+        } else {
+                return expr;
+        }
+}
+
+ast::Type const * ScrubTypeVars::postvisit( ast::PointerType const * type ) {
+        if ( dynType ) {
+                ast::Type * ret = ast::mutate( dynType->accept( *visitor ) );
+                ret->qualifiers |= type->qualifiers;
+                return ret;
+        } else {
+                return type;
+        }
+}
+
+const ast::Node * scrubTypeVarsBase(
+                const ast::Node * target,
+                ScrubMode mode, const TyVarMap * typeVars ) {
+        if ( ScrubMode::All == mode ) {
+                assert( nullptr == typeVars );
+        } else {
+                assert( nullptr != typeVars );
+        }
+        ast::Pass<ScrubTypeVars> visitor( mode, typeVars );
+        return target->accept( visitor );
+}
+
+} // namespace
+
+template<>
+ast::Node const * scrubAllTypeVars<ast::Node>( const ast::Node * target ) {
+        return scrubTypeVarsBase( target, ScrubMode::All, nullptr );
+}
+
 } // namespace GenPoly
 

src/GenPoly/ScrubTyVars.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:21:47 2017
-// Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Aug 19 14:14:00 2022
+// Update Count     : 3
 //
 
@@ -18 +18 @@
 #include <cassert>            // for assert
 
+#include "AST/Fwd.hpp"        // for Node
 #include "Common/PassVisitor.h"
 #include "GenPoly.h"          // for TyVarMap, isPolyType, isDynType
@@ -108 +109 @@
         }
 
+/// For all polymorphic types, replaces generic types, with the appropriate
+/// void type, and sizeof/alignof expressions with the proper variable.
+template<typename node_t>
+node_t const * scrubAllTypeVars( node_t const * target ) {
+        return strict_dynamic_cast<node_t const *>( scrubAllTypeVars<ast::Node>( target ) );
+}
+
+template<>
+ast::Node const * scrubAllTypeVars<ast::Node>( const ast::Node * target );
+
 } // namespace GenPoly
 

src/GenPoly/SpecializeNew.cpp

@@ -240 +240 @@
 }
 
-namespace {
-        struct TypeInstFixer : public ast::WithShortCircuiting {
-                std::map<const ast::TypeDecl *, std::pair<int, int>> typeMap;
-
-                void previsit(const ast::TypeDecl *) { visit_children = false; }
-                const ast::TypeInstType * postvisit(const ast::TypeInstType * typeInst) {
-                        if (typeMap.count(typeInst->base)) {
-                                ast::TypeInstType * newInst = mutate(typeInst);
-                                auto const & pair = typeMap[typeInst->base];
-                                newInst->expr_id = pair.first;
-                                newInst->formal_usage = pair.second;
-                                return newInst;
-                        }
-                        return typeInst;
-                }
-        };
-}
+struct TypeInstFixer final : public ast::WithShortCircuiting {
+        std::map<const ast::TypeDecl *, std::pair<int, int>> typeMap;
+
+        void previsit(const ast::TypeDecl *) { visit_children = false; }
+        const ast::TypeInstType * postvisit(const ast::TypeInstType * typeInst) {
+                if (typeMap.count(typeInst->base)) {
+                        ast::TypeInstType * newInst = mutate(typeInst);
+                        auto const & pair = typeMap[typeInst->base];
+                        newInst->expr_id = pair.first;
+                        newInst->formal_usage = pair.second;
+                        return newInst;
+                }
+                return typeInst;
+        }
+};
 
 const ast::Expr * SpecializeCore::createThunkFunction(

src/GenPoly/module.mk

@@ -27 +27 @@
         GenPoly/FindFunction.cc \
         GenPoly/FindFunction.h \
+        GenPoly/InstantiateGenericNew.cpp \
         GenPoly/InstantiateGeneric.cc \
         GenPoly/InstantiateGeneric.h \

src/InitTweak/InitTweak.cc

@@ -1241 +1241 @@
         static const char * const tlsd_section = ".tdata" ASM_COMMENT;
         void addDataSectionAttribute( ObjectDecl * objDecl ) {
-                const bool is_tls = objDecl->get_storageClasses().is_threadlocal;
+                const bool is_tls = objDecl->get_storageClasses().is_threadlocal_any();
                 const char * section = is_tls ? tlsd_section : data_section;
                 objDecl->attributes.push_back(new Attribute("section", {
@@ -1249 +1249 @@
 
         void addDataSectionAttribute( ast::ObjectDecl * objDecl ) {
-                const bool is_tls = objDecl->storage.is_threadlocal;
+                const bool is_tls = objDecl->storage.is_threadlocal_any();
                 const char * section = is_tls ? tlsd_section : data_section;
                 objDecl->attributes.push_back(new ast::Attribute("section", {

src/Makefile.am

@@ -71 +71 @@
 EXTRA_DIST = include/cassert include/optional BasicTypes-gen.cc
 
-AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -Werror=return-type -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O3 -g -std=c++14 $(TCMALLOCFLAG)
+AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -Werror=return-type -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O3 -g -std=c++17 $(TCMALLOCFLAG)
 AM_LDFLAGS  = @HOST_FLAGS@ -Xlinker -export-dynamic
 ARFLAGS     = cr

src/Parser/DeclarationNode.cc

@@ -262 +262 @@
         newnode->type->enumeration.anon = name == nullptr;
         if ( base && base->type)  {
-                newnode->type->base = base->type;       
+                newnode->type->base = base->type;
         } // if
 
@@ -505 +505 @@
                         } // for
                         // src is the new item being added and has a single bit
-                } else if ( ! src->storageClasses.is_threadlocal ) { // conflict ?
+                } else if ( ! src->storageClasses.is_threadlocal_any() ) { // conflict ?
                         appendError( error, string( "conflicting " ) + Type::StorageClassesNames[storageClasses.ffs()] +
                                                  " & " + Type::StorageClassesNames[src->storageClasses.ffs()] );

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Sun Jun 20 18:41:09 2021
- * Update Count     : 759
+ * Last Modified On : Tue Aug 30 18:39:54 2022
+ * Update Count     : 760
  */
 
@@ -314 +314 @@
 switch                  { KEYWORD_RETURN(SWITCH); }
 thread                  { KEYWORD_RETURN(THREAD); }                             // C11
-_Thread_local   { KEYWORD_RETURN(THREADLOCAL); }                // C11
+__thread                { KEYWORD_RETURN(THREADLOCALGCC); }             // GCC
+_Thread_local   { KEYWORD_RETURN(THREADLOCALC11); }             // C11
 throw                   { KEYWORD_RETURN(THROW); }                              // CFA
 throwResume             { KEYWORD_RETURN(THROWRESUME); }                // CFA

src/Parser/parser.yy

@@ -58 +58 @@
 
 // lex uses __null in a boolean context, it's fine.
-//#pragma GCC diagnostic ignored "-Wparentheses-equality"
+#pragma GCC diagnostic ignored "-Wpragmas"
+#pragma GCC diagnostic ignored "-Wparentheses-equality"
+#pragma GCC diagnostic warning "-Wpragmas"
 
 extern DeclarationNode * parseTree;
@@ -293 +295 @@
 %token TYPEDEF
 %token EXTERN STATIC AUTO REGISTER
-%token THREADLOCAL                                                                              // C11
+%token THREADLOCALGCC THREADLOCALC11                                            // GCC, C11
 %token INLINE FORTRAN                                                                   // C99, extension ISO/IEC 9899:1999 Section J.5.9(1)
 %token NORETURN                                                                                 // C11
@@ -1345 +1347 @@
                 {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-                        else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 
+                        else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                 }
         | comma_expression updowneq comma_expression '~' comma_expression // CFA, anonymous loop-index
@@ -1357 +1359 @@
                 {
                         if ( $2 == OperKinds::LThan || $2 == OperKinds::LEThan ) { SemanticError( yylloc, MISSING_ANON_FIELD ); $$ = nullptr; }
-                        else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; } 
+                        else { SemanticError( yylloc, MISSING_HIGH ); $$ = nullptr; }
                 }
         | comma_expression updowneq comma_expression '~' '@' // CFA, error
@@ -2082 +2084 @@
         | REGISTER
                 { $$ = DeclarationNode::newStorageClass( Type::Register ); }
-        | THREADLOCAL                                                                           // C11
-                { $$ = DeclarationNode::newStorageClass( Type::Threadlocal ); }
+        | THREADLOCALGCC                                                                                // GCC
+                { $$ = DeclarationNode::newStorageClass( Type::ThreadlocalGcc ); }
+        | THREADLOCALC11                                                                                // C11
+                { $$ = DeclarationNode::newStorageClass( Type::ThreadlocalC11 ); }
                 // Put function specifiers here to simplify parsing rules, but separate them semantically.
         | INLINE                                                                                        // C99

src/ResolvExpr/CandidateFinder.cpp

@@ -269 +269 @@
                         unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero,
                         unsigned nextExpl = 0, unsigned explAlt = 0 )
-                : parent(parent), expr( expr ), cost( cost ), env( move( env ) ), need( move( need ) ),
-                  have( move( have ) ), open( move( open ) ), nextArg( nextArg ), tupleStart( tupleStart ),
+                : parent(parent), expr( expr ), cost( cost ), env( std::move( env ) ), need( std::move( need ) ),
+                  have( std::move( have ) ), open( std::move( open ) ), nextArg( nextArg ), tupleStart( tupleStart ),
                   nextExpl( nextExpl ), explAlt( explAlt ) {}
 
@@ -276 +276 @@
                         const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need,
                         ast::AssertionSet && have, ast::OpenVarSet && open, unsigned nextArg, Cost added )
-                : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( move( env ) ),
-                  need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ),
+                : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( std::move( env ) ),
+                  need( std::move( need ) ), have( std::move( have ) ), open( std::move( open ) ), nextArg( nextArg ),
                   tupleStart( o.tupleStart ), nextExpl( 0 ), explAlt( 0 ) {}
 
@@ -301 +301 @@
                         // reset pack to appropriate tuple
                         std::vector< ast::ptr< ast::Expr > > exprv( exprs.begin(), exprs.end() );
-                        expr = new ast::TupleExpr{ expr->location, move( exprv ) };
+                        expr = new ast::TupleExpr{ expr->location, std::move( exprv ) };
                         tupleStart = pack->tupleStart - 1;
                         parent = pack->parent;
@@ -404 +404 @@
                                                                 newResult.open, symtab )
                                                 ) {
-                                                        finalResults.emplace_back( move( newResult ) );
+                                                        finalResults.emplace_back( std::move( newResult ) );
                                                 }
 
@@ -423 +423 @@
                                                 if ( expl.exprs.empty() ) {
                                                         results.emplace_back(
-                                                                results[i], move( env ), copy( results[i].need ),
-                                                                copy( results[i].have ), move( open ), nextArg + 1, expl.cost );
+                                                                results[i], std::move( env ), copy( results[i].need ),
+                                                                copy( results[i].have ), std::move( open ), nextArg + 1, expl.cost );
 
                                                         continue;
@@ -431 +431 @@
                                                 // add new result
                                                 results.emplace_back(
-                                                        i, expl.exprs.front(), move( env ), copy( results[i].need ),
-                                                        copy( results[i].have ), move( open ), nextArg + 1, nTuples,
+                                                        i, expl.exprs.front(), std::move( env ), copy( results[i].need ),
+                                                        copy( results[i].have ), std::move( open ), nextArg + 1, nTuples,
                                                         expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
                                         }
@@ -444 +444 @@
                         // splice final results onto results
                         for ( std::size_t i = 0; i < finalResults.size(); ++i ) {
-                                results.emplace_back( move( finalResults[i] ) );
+                                results.emplace_back( std::move( finalResults[i] ) );
                         }
                         return ! finalResults.empty();
@@ -478 +478 @@
 
                                         results.emplace_back(
-                                                i, expr, move( env ), move( need ), move( have ), move( open ), nextArg,
+                                                i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ), nextArg,
                                                 nTuples, Cost::zero, nextExpl, results[i].explAlt );
                                 }
@@ -494 +494 @@
                                         if ( unify( paramType, cnst->result, env, need, have, open, symtab ) ) {
                                                 results.emplace_back(
-                                                        i, new ast::DefaultArgExpr{ cnst->location, cnst }, move( env ),
-                                                        move( need ), move( have ), move( open ), nextArg, nTuples );
+                                                        i, new ast::DefaultArgExpr{ cnst->location, cnst }, std::move( env ),
+                                                        std::move( need ), std::move( have ), std::move( open ), nextArg, nTuples );
                                         }
                                 }
@@ -516 +516 @@
                                 if ( expl.exprs.empty() ) {
                                         results.emplace_back(
-                                                results[i], move( env ), move( need ), move( have ), move( open ),
+                                                results[i], std::move( env ), std::move( need ), std::move( have ), std::move( open ),
                                                 nextArg + 1, expl.cost );
 
@@ -538 +538 @@
                                         // add new result
                                         results.emplace_back(
-                                                i, expr, move( env ), move( need ), move( have ), move( open ),
+                                                i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ),
                                                 nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
                                 }
@@ -576 +576 @@
                                         restructureCast( idx, toType->getComponent( i ), isGenerated ) );
                         }
-                        return new ast::TupleExpr{ arg->location, move( components ) };
+                        return new ast::TupleExpr{ arg->location, std::move( components ) };
                 } else {
                         // handle normally
@@ -672 +672 @@
                         }
                         std::vector< ast::ptr< ast::Expr > > vargs( args.begin(), args.end() );
-                        appExpr->args = move( vargs );
+                        appExpr->args = std::move( vargs );
                         // build and validate new candidate
                         auto newCand =
@@ -783 +783 @@
                                                         if ( expl.exprs.empty() ) {
                                                                 results.emplace_back(
-                                                                        results[i], move( env ), copy( results[i].need ),
-                                                                        copy( results[i].have ), move( open ), nextArg + 1,
+                                                                        results[i], std::move( env ), copy( results[i].need ),
+                                                                        copy( results[i].have ), std::move( open ), nextArg + 1,
                                                                         expl.cost );
 
@@ -792 +792 @@
                                                         // add new result
                                                         results.emplace_back(
-                                                                i, expl.exprs.front(), move( env ), copy( results[i].need ),
-                                                                copy( results[i].have ), move( open ), nextArg + 1, 0, expl.cost,
+                                                                i, expl.exprs.front(), std::move( env ), copy( results[i].need ),
+                                                                copy( results[i].have ), std::move( open ), nextArg + 1, 0, expl.cost,
                                                                 expl.exprs.size() == 1 ? 0 : 1, j );
                                                 }
@@ -843 +843 @@
                                 // as a member expression
                                 addAnonConversions( newCand );
-                                candidates.emplace_back( move( newCand ) );
+                                candidates.emplace_back( std::move( newCand ) );
                         }
                 }
@@ -901 +901 @@
                                                         const ast::EnumDecl * enumDecl = enumInst->base;
                                                         if ( const ast::Type* enumType = enumDecl->base ) {
-                                                                // instance of enum (T) is a instance of type (T) 
+                                                                // instance of enum (T) is a instance of type (T)
                                                                 funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type));
                                                         } else {
@@ -907 +907 @@
                                                                 funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type));
                                                         }
-                                                } 
+                                                }
                                                 else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
                                         }
@@ -986 +986 @@
                                         funcE.emplace_back( *func, symtab );
                                 }
-                                argExpansions.emplace_front( move( funcE ) );
+                                argExpansions.emplace_front( std::move( funcE ) );
 
                                 for ( const CandidateRef & op : opFinder ) {
@@ -1030 +1030 @@
                                 if ( cvtCost != Cost::infinity ) {
                                         withFunc->cvtCost = cvtCost;
-                                        candidates.emplace_back( move( withFunc ) );
-                                }
-                        }
-                        found = move( candidates );
+                                        candidates.emplace_back( std::move( withFunc ) );
+                                }
+                        }
+                        found = std::move( candidates );
 
                         // use a new list so that candidates are not examined by addAnonConversions twice
@@ -1131 +1131 @@
                                         CandidateRef newCand = std::make_shared<Candidate>(
                                                 restructureCast( cand->expr, toType, castExpr->isGenerated ),
-                                                copy( cand->env ), move( open ), move( need ), cand->cost,
+                                                copy( cand->env ), std::move( open ), std::move( need ), cand->cost,
                                                 cand->cost + thisCost );
                                         inferParameters( newCand, matches );
@@ -1285 +1285 @@
                                 // as a name expression
                                 addAnonConversions( newCand );
-                                candidates.emplace_back( move( newCand ) );
+                                candidates.emplace_back( std::move( newCand ) );
                         }
                 }
@@ -1394 +1394 @@
                                                 new ast::LogicalExpr{
                                                         logicalExpr->location, r1->expr, r2->expr, logicalExpr->isAnd },
-                                                move( env ), move( open ), move( need ), r1->cost + r2->cost );
+                                                std::move( env ), std::move( open ), std::move( need ), r1->cost + r2->cost );
                                 }
                         }
@@ -1452 +1452 @@
                                                         // output candidate
                                                         CandidateRef newCand = std::make_shared<Candidate>(
-                                                                newExpr, move( env ), move( open ), move( need ), cost );
+                                                                newExpr, std::move( env ), std::move( open ), std::move( need ), cost );
                                                         inferParameters( newCand, candidates );
                                                 }
@@ -1519 +1519 @@
                                                 // add candidate
                                                 CandidateRef newCand = std::make_shared<Candidate>(
-                                                        newExpr, move( env ), move( open ), move( need ),
+                                                        newExpr, std::move( env ), std::move( open ), std::move( need ),
                                                         r1->cost + r2->cost );
                                                 inferParameters( newCand, candidates );
@@ -1548 +1548 @@
 
                                 addCandidate(
-                                        new ast::TupleExpr{ tupleExpr->location, move( exprs ) },
-                                        move( env ), move( open ), move( need ), sumCost( subs ) );
+                                        new ast::TupleExpr{ tupleExpr->location, std::move( exprs ) },
+                                        std::move( env ), std::move( open ), std::move( need ), sumCost( subs ) );
                         }
                 }
@@ -1635 +1635 @@
                                                                 initExpr->location, restructureCast( cand->expr, toType ),
                                                                 initAlt.designation },
-                                                        move(env), move( open ), move( need ), cand->cost, thisCost );
+                                                        std::move(env), std::move( open ), std::move( need ), cand->cost, thisCost );
                                                 inferParameters( newCand, matches );
                                         }
@@ -1768 +1768 @@
                 cand->env.applyFree( newResult );
                 cand->expr = ast::mutate_field(
-                        cand->expr.get(), &ast::Expr::result, move( newResult ) );
+                        cand->expr.get(), &ast::Expr::result, std::move( newResult ) );
 
                 out.emplace_back( cand );
@@ -1854 +1854 @@
 
                 auto oldsize = candidates.size();
-                candidates = move( pruned );
+                candidates = std::move( pruned );
 
                 PRINT(

src/SynTree/Statement.cc

@@ -105 +105 @@
 };
 
-BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticErrorException ) :
+BranchStmt::BranchStmt( Label target, Type type ) :
         Statement(), originalTarget( target ), target( target ), computedTarget( nullptr ), type( type ) {
         //actually this is a syntactic error signaled by the parser
@@ -113 +113 @@
 }
 
-BranchStmt::BranchStmt( Expression * computedTarget, Type type ) throw ( SemanticErrorException ) :
+BranchStmt::BranchStmt( Expression * computedTarget, Type type ) :
         Statement(), computedTarget( computedTarget ), type( type ) {
         if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
@@ -211 +211 @@
 }
 
-CaseStmt::CaseStmt( Expression * condition, const list<Statement *> & statements, bool deflt ) throw ( SemanticErrorException ) :
+CaseStmt::CaseStmt( Expression * condition, const list<Statement *> & statements, bool deflt ) :
                 Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
         if ( isDefault() && condition != nullptr ) SemanticError( condition, "default case with condition: " );
@@ -575 +575 @@
 }
 
-MutexStmt::MutexStmt( Statement * stmt, const list<Expression *> mutexObjs ) 
+MutexStmt::MutexStmt( Statement * stmt, const list<Expression *> mutexObjs )
         : Statement(), stmt( stmt ), mutexObjs( mutexObjs ) { }
 

src/SynTree/Statement.h

@@ -200 +200 @@
         std::list<Statement *> stmts;
 
-        CaseStmt( Expression * conditions, const std::list<Statement *> & stmts, bool isdef = false ) throw (SemanticErrorException);
+        CaseStmt( Expression * conditions, const std::list<Statement *> & stmts, bool isdef = false );
         CaseStmt( const CaseStmt & other );
         virtual ~CaseStmt();
@@ -289 +289 @@
         Type type;
 
-        BranchStmt( Label target, Type ) throw (SemanticErrorException);
-        BranchStmt( Expression * computedTarget, Type ) throw (SemanticErrorException);
+        BranchStmt( Label target, Type );
+        BranchStmt( Expression * computedTarget, Type );
 
         Label get_originalTarget() { return originalTarget; }

src/SynTree/Type.cc

@@ -80 +80 @@
 // These must remain in the same order as the corresponding bit fields.
 const char * Type::FuncSpecifiersNames[] = { "inline", "_Noreturn", "fortran" };
-const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "_Thread_local" };
+const char * Type::StorageClassesNames[] = { "extern", "static", "auto", "register", "__thread", "_Thread_local" };
 const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "mutex", "_Atomic" };
 

src/SynTree/Type.h

@@ -84 +84 @@
         }; // FuncSpecifiers
 
-        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
+        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, ThreadlocalGcc = 1 << 4, ThreadlocalC11 = 1 << 5, NumStorageClass = 6 };
         static const char * StorageClassesNames[];
         union StorageClasses {
@@ -93 +93 @@
                         bool is_auto : 1;
                         bool is_register : 1;
-                        bool is_threadlocal : 1;
+                        bool is_threadlocalGcc : 1;
+                        bool is_threadlocalC11 : 1;
                 };
 
@@ -100 +101 @@
                 // equality (==, !=) works implicitly on first field "val", relational operations are undefined.
                 BFCommon( StorageClasses, NumStorageClass )
+
+                bool is_threadlocal_any() { return this->is_threadlocalC11 || this->is_threadlocalGcc; }
         }; // StorageClasses
 

src/Tuples/TupleExpansionNew.cpp

@@ -101 +101 @@
 
 /// Replaces Tuple Assign & Index Expressions, and Tuple Types.
-struct TupleMainExpander :
+struct TupleMainExpander final :
                 public ast::WithGuards,
                 public ast::WithVisitorRef<TupleMainExpander>,
@@ -254 +254 @@
 }
 
-struct TupleExprExpander {
+struct TupleExprExpander final {
         ast::Expr const * postvisit( ast::TupleExpr const * expr ) {
                 return replaceTupleExpr( expr->location,

src/Virtual/ExpandCasts.cc

@@ -317 +317 @@
 };
 
-struct ExpandCastsCore {
+struct ExpandCastsCore final {
         void previsit( ast::FunctionDecl const * decl );
         void previsit( ast::StructDecl const * decl );
@@ -362 +362 @@
 }
 
+/// Copy newType, but give the copy the params of the oldType.
 ast::StructInstType * polyCopy(
                 ast::StructInstType const * oldType,

src/config.h.in

@@ -27 +27 @@
 /* Location of cfa install. */
 #undef CFA_PREFIX
-
-/* Sets whether or not to use the new-ast, this is adefault value and can be
-   overrided by --old-ast and --new-ast */
-#undef CFA_USE_NEW_AST
 
 /* Major.Minor */

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu 11 12:18:00 2022
-// Update Count     : 677
+// Last Modified On : Thu Sep 15 13:58:00 2022
+// Update Count     : 678
 //
 
@@ -38 +38 @@
 #include "CodeGen/Generate.h"               // for generate
 #include "CodeGen/LinkOnce.h"               // for translateLinkOnce
-#include "CodeTools/DeclStats.h"            // for printDeclStats
-#include "CodeTools/ResolvProtoDump.h"      // for dumpAsResolvProto
 #include "CodeTools/TrackLoc.h"             // for fillLocations
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
@@ -45 +43 @@
 #include "Common/DeclStats.hpp"             // for printDeclStats
 #include "Common/ResolvProtoDump.hpp"       // for dumpAsResolverProto
-#include "Common/Stats.h"
-#include "Common/PassVisitor.h"
-#include "Common/SemanticError.h"           // for SemanticError
+#include "Common/Stats.h"                   // for Stats
 #include "Common/UnimplementedError.h"      // for UnimplementedError
 #include "Common/utility.h"                 // for deleteAll, filter, printAll
@@ -53 +49 @@
 #include "Concurrency/Waitfor.h"            // for generateWaitfor
 #include "ControlStruct/ExceptDecl.h"       // for translateExcept
-#include "ControlStruct/ExceptTranslate.h"  // for translateEHM
+#include "ControlStruct/ExceptTranslate.h"  // for translateThrows, translat...
 #include "ControlStruct/FixLabels.hpp"      // for fixLabels
 #include "ControlStruct/HoistControlDecls.hpp" //  hoistControlDecls
-#include "ControlStruct/Mutate.h"           // for mutate
 #include "GenPoly/Box.h"                    // for box
 #include "GenPoly/InstantiateGeneric.h"     // for instantiateGeneric
@@ -66 +61 @@
 #include "Parser/ParseNode.h"               // for DeclarationNode, buildList
 #include "Parser/TypedefTable.h"            // for TypedefTable
-#include "ResolvExpr/AlternativePrinter.h"  // for AlternativePrinter
 #include "ResolvExpr/CandidatePrinter.hpp"  // for printCandidates
 #include "ResolvExpr/Resolver.h"            // for resolve
-#include "SymTab/Validate.h"                // for validate
-#include "SymTab/ValidateType.h"            // for linkReferenceToTypes
 #include "SynTree/LinkageSpec.h"            // for Spec, Cforall, Intrinsic
 #include "SynTree/Declaration.h"            // for Declaration
-#include "SynTree/Visitor.h"                // for acceptAll
 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
 #include "Validate/Autogen.hpp"             // for autogenerateRoutines
@@ -330 +321 @@
                 Stats::Time::StopBlock();
 
-                if( useNewAST ) {
-                        if (Stats::Counters::enabled) {
-                                ast::pass_visitor_stats.avg = Stats::Counters::build<Stats::Counters::AverageCounter<double>>("Average Depth - New");
-                                ast::pass_visitor_stats.max = Stats::Counters::build<Stats::Counters::MaxCounter<double>>("Max depth - New");
-                        }
-                        auto transUnit = convert( move( translationUnit ) );
-
-                        forceFillCodeLocations( transUnit );
-
-                        PASS( "Translate Exception Declarations", ControlStruct::translateExcept( transUnit ) );
-                        if ( exdeclp ) {
-                                dump( move( transUnit ) );
-                                return EXIT_SUCCESS;
-                        }
-
-                        PASS( "Verify Ctor, Dtor & Assign", Validate::verifyCtorDtorAssign( transUnit ) );
-                        PASS( "Hoist Type Decls", Validate::hoistTypeDecls( transUnit ) );
-                        // Hoist Type Decls pulls some declarations out of contexts where
-                        // locations are not tracked. Perhaps they should be, but for now
-                        // the full fill solves it.
-                        forceFillCodeLocations( transUnit );
-
-                        PASS( "Replace Typedefs", Validate::replaceTypedef( transUnit ) );
-                        PASS( "Fix Return Types", Validate::fixReturnTypes( transUnit ) );
-                        PASS( "Enum and Pointer Decay", Validate::decayEnumsAndPointers( transUnit ) );
-
-                        PASS( "Link Reference To Types", Validate::linkReferenceToTypes( transUnit ) );
-
-                        PASS( "Fix Qualified Types", Validate::fixQualifiedTypes( transUnit ) );
-                        PASS( "Hoist Struct", Validate::hoistStruct( transUnit ) );
-                        PASS( "Eliminate Typedef", Validate::eliminateTypedef( transUnit ) );
-                        PASS( "Validate Generic Parameters", Validate::fillGenericParameters( transUnit ) );
-                        PASS( "Translate Dimensions", Validate::translateDimensionParameters( transUnit ) );
-                        PASS( "Check Function Returns", Validate::checkReturnStatements( transUnit ) );
-                        PASS( "Fix Return Statements", InitTweak::fixReturnStatements( transUnit ) );
-                        PASS( "Implement Concurrent Keywords", Concurrency::implementKeywords( transUnit ) );
-                        PASS( "Forall Pointer Decay", Validate::decayForallPointers( transUnit ) );
-                        PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls( transUnit ) );
-
-                        PASS( "Generate Autogen Routines", Validate::autogenerateRoutines( transUnit ) );
-
-                        PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
-                        PASS( "Implement Thread Start", Concurrency::implementThreadStarter( transUnit ) );
-                        PASS( "Compound Literal", Validate::handleCompoundLiterals( transUnit ) );
-                        PASS( "Set Length From Initializer", Validate::setLengthFromInitializer( transUnit ) );
-                        PASS( "Find Global Decls", Validate::findGlobalDecls( transUnit ) );
-                        PASS( "Fix Label Address", Validate::fixLabelAddresses( transUnit ) );
-
-                        if ( symtabp ) {
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        if ( expraltp ) {
-                                ResolvExpr::printCandidates( transUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        if ( validp ) {
-                                dump( move( transUnit ) );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        PASS( "Translate Throws", ControlStruct::translateThrows( transUnit ) );
-                        PASS( "Fix Labels", ControlStruct::fixLabels( transUnit ) );
-                        PASS( "Fix Names", CodeGen::fixNames( transUnit ) );
-                        PASS( "Gen Init", InitTweak::genInit( transUnit ) );
-                        PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
-
-                        if ( libcfap ) {
-                                // Generate the bodies of cfa library functions.
-                                LibCfa::makeLibCfa( transUnit );
-                        } // if
-
-                        if ( declstatsp ) {
-                                printDeclStats( transUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        if ( bresolvep ) {
-                                dump( move( transUnit ) );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        if ( resolvprotop ) {
-                                dumpAsResolverProto( transUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
-                        if ( exprp ) {
-                                dump( move( transUnit ) );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        forceFillCodeLocations( transUnit );
-
-                        PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
-
-                        // fix ObjectDecl - replaces ConstructorInit nodes
-                        if ( ctorinitp ) {
-                                dump( move( transUnit ) );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        // Currently not working due to unresolved issues with UniqueExpr
-                        PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( transUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
-
-                        PASS( "Translate Tries", ControlStruct::translateTries( transUnit ) );
-                        PASS( "Gen Waitfor", Concurrency::generateWaitFor( transUnit ) );
-
-                        // Needs to happen before tuple types are expanded.
-                        PASS( "Convert Specializations",  GenPoly::convertSpecializations( transUnit ) );
-
-                        PASS( "Expand Tuples", Tuples::expandTuples( transUnit ) );
-
-                        if ( tuplep ) {
-                                dump( move( transUnit ) );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        // Must come after Translate Tries.
-                        PASS( "Virtual Expand Casts", Virtual::expandCasts( transUnit ) );
-
-                        translationUnit = convert( move( transUnit ) );
-                } else {
-                        PASS( "Translate Exception Declarations", ControlStruct::translateExcept( translationUnit ) );
-                        if ( exdeclp ) {
-                                dump( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        // add the assignment statement after the initialization of a type parameter
-                        PASS( "Validate", SymTab::validate( translationUnit ) );
-
-                        if ( symtabp ) {
-                                deleteAll( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        if ( expraltp ) {
-                                PassVisitor<ResolvExpr::AlternativePrinter> printer( cout );
-                                acceptAll( translationUnit, printer );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        if ( validp ) {
-                                dump( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
-                        PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
-                        PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
-                        PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
-                        PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
-
-                        if ( libcfap ) {
-                                // Generate the bodies of cfa library functions.
-                                LibCfa::makeLibCfa( translationUnit );
-                        } // if
-
-                        if ( declstatsp ) {
-                                CodeTools::printDeclStats( translationUnit );
-                                deleteAll( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        if ( bresolvep ) {
-                                dump( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        CodeTools::fillLocations( translationUnit );
-
-                        if ( resolvprotop ) {
-                                CodeTools::dumpAsResolvProto( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
-                        if ( exprp ) {
-                                dump( translationUnit );
-                                return EXIT_SUCCESS;
-                        }
-
-                        PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
-
-                        // fix ObjectDecl - replaces ConstructorInit nodes
-                        if ( ctorinitp ) {
-                                dump ( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
-                        PASS( "Translate Tries", ControlStruct::translateTries( translationUnit ) );
-                        PASS( "Gen Waitfor", Concurrency::generateWaitFor( translationUnit ) );
-                        PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
-                        PASS( "Expand Tuples", Tuples::expandTuples( translationUnit ) ); // xxx - is this the right place for this?
-
-                        if ( tuplep ) {
-                                dump( translationUnit );
-                                return EXIT_SUCCESS;
-                        } // if
-
-                        PASS( "Virtual Expand Casts", Virtual::expandCasts( translationUnit ) ); // Must come after translateEHM
+                if (Stats::Counters::enabled) {
+                        ast::pass_visitor_stats.avg = Stats::Counters::build<Stats::Counters::AverageCounter<double>>("Average Depth - New");
+                        ast::pass_visitor_stats.max = Stats::Counters::build<Stats::Counters::MaxCounter<double>>("Max depth - New");
                 }
-
-                PASS( "Instantiate Generics", GenPoly::instantiateGeneric( translationUnit ) );
+                auto transUnit = convert( std::move( translationUnit ) );
+
+                forceFillCodeLocations( transUnit );
+
+                PASS( "Translate Exception Declarations", ControlStruct::translateExcept( transUnit ) );
+                if ( exdeclp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                }
+
+                PASS( "Verify Ctor, Dtor & Assign", Validate::verifyCtorDtorAssign( transUnit ) );
+                PASS( "Hoist Type Decls", Validate::hoistTypeDecls( transUnit ) );
+                // Hoist Type Decls pulls some declarations out of contexts where
+                // locations are not tracked. Perhaps they should be, but for now
+                // the full fill solves it.
+                forceFillCodeLocations( transUnit );
+
+                PASS( "Replace Typedefs", Validate::replaceTypedef( transUnit ) );
+                PASS( "Fix Return Types", Validate::fixReturnTypes( transUnit ) );
+                PASS( "Enum and Pointer Decay", Validate::decayEnumsAndPointers( transUnit ) );
+
+                PASS( "Link Reference To Types", Validate::linkReferenceToTypes( transUnit ) );
+
+                PASS( "Fix Qualified Types", Validate::fixQualifiedTypes( transUnit ) );
+                PASS( "Hoist Struct", Validate::hoistStruct( transUnit ) );
+                PASS( "Eliminate Typedef", Validate::eliminateTypedef( transUnit ) );
+                PASS( "Validate Generic Parameters", Validate::fillGenericParameters( transUnit ) );
+                PASS( "Translate Dimensions", Validate::translateDimensionParameters( transUnit ) );
+                PASS( "Check Function Returns", Validate::checkReturnStatements( transUnit ) );
+                PASS( "Fix Return Statements", InitTweak::fixReturnStatements( transUnit ) );
+                PASS( "Implement Concurrent Keywords", Concurrency::implementKeywords( transUnit ) );
+                PASS( "Forall Pointer Decay", Validate::decayForallPointers( transUnit ) );
+                PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls( transUnit ) );
+
+                PASS( "Generate Autogen Routines", Validate::autogenerateRoutines( transUnit ) );
+
+                PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
+                PASS( "Implement Thread Start", Concurrency::implementThreadStarter( transUnit ) );
+                PASS( "Compound Literal", Validate::handleCompoundLiterals( transUnit ) );
+                PASS( "Set Length From Initializer", Validate::setLengthFromInitializer( transUnit ) );
+                PASS( "Find Global Decls", Validate::findGlobalDecls( transUnit ) );
+                PASS( "Fix Label Address", Validate::fixLabelAddresses( transUnit ) );
+
+                if ( symtabp ) {
+                        return EXIT_SUCCESS;
+                } // if
+
+                if ( expraltp ) {
+                        ResolvExpr::printCandidates( transUnit );
+                        return EXIT_SUCCESS;
+                } // if
+
+                if ( validp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+
+                PASS( "Translate Throws", ControlStruct::translateThrows( transUnit ) );
+                PASS( "Fix Labels", ControlStruct::fixLabels( transUnit ) );
+                PASS( "Fix Names", CodeGen::fixNames( transUnit ) );
+                PASS( "Gen Init", InitTweak::genInit( transUnit ) );
+                PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
+
+                if ( libcfap ) {
+                        // Generate the bodies of cfa library functions.
+                        LibCfa::makeLibCfa( transUnit );
+                } // if
+
+                if ( declstatsp ) {
+                        printDeclStats( transUnit );
+                        return EXIT_SUCCESS;
+                } // if
+
+                if ( bresolvep ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+
+                if ( resolvprotop ) {
+                        dumpAsResolverProto( transUnit );
+                        return EXIT_SUCCESS;
+                } // if
+
+                PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
+                if ( exprp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+
+                forceFillCodeLocations( transUnit );
+
+                PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
+
+                // fix ObjectDecl - replaces ConstructorInit nodes
+                if ( ctorinitp ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+
+                // Currently not working due to unresolved issues with UniqueExpr
+                PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( transUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
+
+                PASS( "Translate Tries", ControlStruct::translateTries( transUnit ) );
+                PASS( "Gen Waitfor", Concurrency::generateWaitFor( transUnit ) );
+
+                // Needs to happen before tuple types are expanded.
+                PASS( "Convert Specializations",  GenPoly::convertSpecializations( transUnit ) );
+
+                PASS( "Expand Tuples", Tuples::expandTuples( transUnit ) );
+
+                if ( tuplep ) {
+                        dump( std::move( transUnit ) );
+                        return EXIT_SUCCESS;
+                } // if
+
+                // Must come after Translate Tries.
+                PASS( "Virtual Expand Casts", Virtual::expandCasts( transUnit ) );
+
+                PASS( "Instantiate Generics", GenPoly::instantiateGeneric( transUnit ) );
+
+                translationUnit = convert( std::move( transUnit ) );
+
                 if ( genericsp ) {
                         dump( translationUnit );
@@ -620 +529 @@
 
 
-static const char optstring[] = ":c:ghlLmNnpdOAP:S:twW:D:";
+static const char optstring[] = ":c:ghlLmNnpdP:S:twW:D:";
 
 enum { PreludeDir = 128 };
@@ -634 +543 @@
         { "prototypes", no_argument, nullptr, 'p' },
         { "deterministic-out", no_argument, nullptr, 'd' },
-        { "old-ast", no_argument, nullptr, 'O'},
-        { "new-ast", no_argument, nullptr, 'A'},
         { "print", required_argument, nullptr, 'P' },
         { "prelude-dir", required_argument, nullptr, PreludeDir },
@@ -657 +564 @@
         "do not generate prelude prototypes => prelude not printed", // -p
         "only print deterministic output",                  // -d
-        "Use the old-ast",                                                                      // -O
-        "Use the new-ast",                                                                      // -A
         "print",                                                                                        // -P
         "<directory> prelude directory for debug/nodebug",      // no flag
@@ -767 +672 @@
                         deterministic_output = true;
                         break;
-                  case 'O':                                     // don't print non-deterministic output
-                        useNewAST = false;
-                        break;
-                  case 'A':                                     // don't print non-deterministic output
-                        useNewAST = true;
-                        break;
                   case 'P':                                                                             // print options
                         for ( int i = 0;; i += 1 ) {
@@ -889 +788 @@
 
 static void dump( ast::TranslationUnit && transUnit, ostream & out ) {
-        std::list< Declaration * > translationUnit = convert( move( transUnit ) );
+        std::list< Declaration * > translationUnit = convert( std::move( transUnit ) );
         dump( translationUnit, out );
 }