Changeset fc12f05 for src

src/AST/Decl.hpp

-              r0030b508
+              rfc12f05
 /// Object declaration `int foo()`
 class FunctionDecl : public DeclWithType {
+class FunctionDecl final : public DeclWithType {
 public:
         std::vector<ptr<TypeDecl>> type_params;
 …
 class EnumDecl final : public AggregateDecl {
 public:
         bool isTyped; // isTyped indicated if the enum has a declaration like:
+        // isTyped indicated if the enum has a declaration like:
         // enum (type_optional) Name {...}
+        ptr<Type> base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum
+        bool isTyped;
+        // if isTyped == true && base.get() == nullptr, it is a "void" type enum
+        ptr<Type> base;
         enum class EnumHiding { Visible, Hide } hide;
 …
 /// Assembly declaration: `asm ... ( "..." : ... )`
 class AsmDecl : public Decl {
+class AsmDecl final : public Decl {
 public:
         ptr<AsmStmt> stmt;
         AsmDecl( const CodeLocation & loc, AsmStmt * stmt )
         : Decl( loc, "", {}, {} ), stmt(stmt) {}
+        : Decl( loc, "", {}, Linkage::C ), stmt(stmt) {}
         const AsmDecl * accept( Visitor & v ) const override { return v.visit( this ); }
 …
 /// C-preprocessor directive `#...`
 class DirectiveDecl : public Decl {
+class DirectiveDecl final : public Decl {
 public:
         ptr<DirectiveStmt> stmt;
         DirectiveDecl( const CodeLocation & loc, DirectiveStmt * stmt )
         : Decl( loc, "", {}, {} ), stmt(stmt) {}
+        : Decl( loc, "", {}, Linkage::C ), stmt(stmt) {}
         const DirectiveDecl * accept( Visitor & v ) const override { return v.visit( this ); }
 …
 /// Static Assertion `_Static_assert( ... , ... );`
 class StaticAssertDecl : public Decl {
+class StaticAssertDecl final : public Decl {
 public:
         ptr<Expr> cond;
 …
         StaticAssertDecl( const CodeLocation & loc, const Expr * condition, const ConstantExpr * msg )
         : Decl( loc, "", {}, {} ), cond( condition ), msg( msg ) {}
+        : Decl( loc, "", {}, Linkage::C ), cond( condition ), msg( msg ) {}
         const StaticAssertDecl * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Fwd.hpp

r0030b508	rfc12f05
68	68	class MutexStmt;
69	69	class CorunStmt;
	70	class CoforStmt;
70	71
71	72	class Expr;

src/AST/Node.cpp

r0030b508	rfc12f05
194	194	template class ast::ptr_base< ast::CorunStmt, ast::Node::ref_type::weak >;
195	195	template class ast::ptr_base< ast::CorunStmt, ast::Node::ref_type::strong >;
	196	template class ast::ptr_base< ast::CoforStmt, ast::Node::ref_type::weak >;
	197	template class ast::ptr_base< ast::CoforStmt, ast::Node::ref_type::strong >;
196	198	template class ast::ptr_base< ast::Expr, ast::Node::ref_type::weak >;
197	199	template class ast::ptr_base< ast::Expr, ast::Node::ref_type::strong >;

src/AST/Pass.cpp

r0030b508	rfc12f05
19	19
20	20	PassVisitorStats pass_visitor_stats;
	21	// TODO: There was a counter for every syntax node created.
	22	// This has not been translated to the new ast.
21	23	// Stats::Counters::SimpleCounter * BaseSyntaxNode::new_nodes = nullptr;
22	24

src/AST/Pass.hpp

r0030b508	rfc12f05
172	172	const ast::Stmt * visit( const ast::MutexStmt * ) override final;
173	173	const ast::Stmt * visit( const ast::CorunStmt * ) override final;
	174	const ast::Stmt * visit( const ast::CoforStmt * ) override final;
174	175	const ast::Expr * visit( const ast::ApplicationExpr * ) override final;
175	176	const ast::Expr * visit( const ast::UntypedExpr * ) override final;

src/AST/Pass.impl.hpp

-              r0030b508
+              rfc12f05
 //--------------------------------------------------------------------------
+// CoforStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::CoforStmt * node ) {
+        VISIT_START( node );
+        if ( __visit_children() ) {
+                // for statements introduce a level of scope (for the initialization)
+                guard_symtab guard { *this };
+                maybe_accept( node, &CoforStmt::inits );
+                maybe_accept_top( node, &CoforStmt::cond  );
+                maybe_accept_top( node, &CoforStmt::inc   );
+                maybe_accept_as_compound( node, &CoforStmt::body  );
+        }
+        VISIT_END( Stmt, node );
+}
+//--------------------------------------------------------------------------
 // ApplicationExpr
 template< typename core_t >

src/AST/Print.cpp

-              r0030b508
+              rfc12f05
+        }
+        virtual const ast::Stmt * visit( const ast::CoforStmt * node ) override final {
+                os << "Cofor Statement" << endl;
+                if ( ! node->inits.empty() ) {
+                        os << indent << "... initialization:" << endl;
+                        ++indent;
+                        for ( const ast::Stmt * stmt : node->inits ) {
+                                os << indent+1;
+                                safe_print( stmt );
+                        }
+                        --indent;
+                }
+                if ( node->cond ) {
+                        os << indent << "... condition:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->cond->accept( *this );
+                        --indent;
+                }
+                if ( node->inc ) {
+                        os << indent << "... increment:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->inc->accept( *this );
+                        --indent;
+                }
+                if ( node->body ) {
+                        os << indent << "... with body:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->body->accept( *this );
+                        --indent;
+                }
+                os << endl;
+                print( node->labels );
+                return node;
+        }
         virtual const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
                 ++indent;

src/AST/Stmt.hpp

-              r0030b508
+              rfc12f05
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
 #define MUTATE_FRIEND                                                                                                   \
     template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * mutate(const node_t * node); \
         template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 …
         CatchClause( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
                            const Stmt * body )
+                        const Stmt * body )
                 : StmtClause(loc), decl(decl), cond(cond), body(body), kind(kind) {}
 …
 // Base class of WaitFor/WaitUntil statements
 // form: KEYWORD(...) ... timeout(...) ... else ...
 class WaitStmt : public Stmt {
   public:
     ptr<Expr> timeout_time;
+class WaitStmt : public Stmt {
+  public:
+        ptr<Expr> timeout_time;
         ptr<Stmt> timeout_stmt;
         ptr<Expr> timeout_cond;
 …
         ptr<Expr> else_cond;
     WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
+        WaitStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)) {}
   private:
     WaitStmt * clone() const override = 0;
+        WaitStmt * clone() const override = 0;
         MUTATE_FRIEND
 };
 …
 class WaitUntilStmt final : public WaitStmt {
   public:
     // Non-ast node used during compilation to store data needed to generate predicates
     //    and set initial status values for clauses
     // Used to create a tree corresponding to the structure of the clauses in a WaitUntil
+    struct ClauseNode {
         enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
         // LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
         ClauseNode * left;
         ClauseNode * right;
         WhenClause * leaf;  // only set if this node is a leaf (points into vector of clauses)
         bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
         bool whenState;     // used to track if when_cond is toggled on or off for generating init values
         bool childOfAnd;      // true on leaf nodes that are children of AND, false otherwise
         ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
+            : op(op), left(left), right(right), leaf(nullptr),
             ambiguousWhen(false), whenState(true), childOfAnd(false) {}
         ClauseNode( Op op, WhenClause * leaf )
             : op(op), left(nullptr), right(nullptr), leaf(leaf),
             ambiguousWhen(false), whenState(true), childOfAnd(false) {}
         ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
         ~ClauseNode() {
             if ( left ) delete left;
             if ( right ) delete right;
+        }
     };
+        // Non-ast node used during compilation to store data needed to generate predicates
+        //    and set initial status values for clauses
+        // Used to create a tree corresponding to the structure of the clauses in a WaitUntil
+        struct ClauseNode {
+                enum Op { AND, OR, LEFT_OR, LEAF, ELSE, TIMEOUT } op; // operation/type tag
+                // LEFT_OR used with TIMEOUT/ELSE to indicate that we ignore right hand side after parsing
+                ClauseNode * left;
+                ClauseNode * right;
+                WhenClause * leaf;  // only set if this node is a leaf (points into vector of clauses)
+                bool ambiguousWhen; // used to paint nodes of predicate tree based on when() clauses
+                bool whenState;     // used to track if when_cond is toggled on or off for generating init values
+                bool childOfAnd;      // true on leaf nodes that are children of AND, false otherwise
+                ClauseNode( Op op, ClauseNode * left, ClauseNode * right )
+                        : op(op), left(left), right(right), leaf(nullptr),
+                        ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+                ClauseNode( Op op, WhenClause * leaf )
+                        : op(op), left(nullptr), right(nullptr), leaf(leaf),
+                        ambiguousWhen(false), whenState(true), childOfAnd(false) {}
+                ClauseNode( WhenClause * leaf ) : ClauseNode(LEAF, leaf) {}
+                ~ClauseNode() {
+                        if ( left ) delete left;
+                        if ( right ) delete right;
+                }
+        };
         std::vector<ptr<WhenClause>> clauses;
     ClauseNode * predicateTree;
+        ClauseNode * predicateTree;
         WaitUntilStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
                 : WaitStmt(loc, std::move(labels)) {}
     ~WaitUntilStmt() { delete predicateTree; }
+        ~WaitUntilStmt() { delete predicateTree; }
         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
 …
         std::vector<ptr<Expr>> mutexObjs;
         MutexStmt( const CodeLocation & loc, const Stmt * stmt,
+        MutexStmt( const CodeLocation & loc, const Stmt * stmt,
                            const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
 …
   private:
         CorunStmt * clone() const override { return new CorunStmt{ *this }; }
+        MUTATE_FRIEND
+};
+// Corun Statement
+class CoforStmt final : public Stmt {
+  public:
+        std::vector<ptr<Stmt>> inits;
+        ptr<Expr> cond;
+        ptr<Expr> inc;
+        ptr<Stmt> body;
+        CoforStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
+                         const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
+                : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body) {}
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+  private:
+        CoforStmt * clone() const override { return new CoforStmt{ *this }; }
         MUTATE_FRIEND
 };

src/AST/Type.hpp

r0030b508	rfc12f05
34	34
35	35	namespace ast {
36
37		~~template< typename T > class Pass;~~
38	36
39	37	class Type : public Node {

src/AST/Visitor.hpp

r0030b508	rfc12f05
60	60	virtual const ast::Stmt * visit( const ast::MutexStmt * ) = 0;
61	61	virtual const ast::Stmt * visit( const ast::CorunStmt * ) = 0;
	62	virtual const ast::Stmt * visit( const ast::CoforStmt * ) = 0;
62	63	virtual const ast::Expr * visit( const ast::ApplicationExpr * ) = 0;
63	64	virtual const ast::Expr * visit( const ast::UntypedExpr * ) = 0;

src/AST/module.mk

r0030b508	rfc12f05
20	20	AST/Bitfield.hpp \
21	21	AST/Chain.hpp \
22		~~AST/Convert.cpp \~~
23		~~AST/Convert.hpp \~~
24	22	AST/Copy.cpp \
25	23	AST/Copy.hpp \

src/BasicTypes-gen.cc

-              r0030b508
+              rfc12f05
         // { LongDoubleImaginary, "LongDoubleImaginary", "LDI", "long double _Imaginary", "Ie", false, LongDoubleComplex, -1, -1, 17 },
         { uFloat128x, "uFloat128x", "_FBX", "_Float128x", "DF128x_", Floating, uFloat128xComplex, -1, -1, 18 },
+        { uFloat128x, "uFloat128x", "_FBX", "_Float128x", "DF128x_", Floating, uFloat128xComplex, -1, -1, 18 },
         { uFloat128xComplex, "uFloat128xComplex", "_FLDXC", "_Float128x _Complex", "CDF128x_", Floating, -1, -1, -1, 18 }
 }; // graph
 …
 void generateCosts( int row ) {
         bool seen[NUMBER_OF_BASIC_TYPES] = { false /*, ... */ };
         struct el_cost {
                 int i;
                 int path;
                 int sign;
                 el_cost( int i = 0, int p = 0, int s = 0 ) : i(i), path(p), sign(s) {}
                 // reverse the sense for use in largest-on-top priority queue
                 bool operator< (const el_cost& o) const {
 …
                         return;
                 } // if
                 i = graph[col].middle;
                 if ( i == -1 ) assert("invalid ancestor assumption");
 …
         size_t start, end;
+        #define TypeH TOP_SRCDIR "src/SynTree/Type.h"
+        resetInput( file, TypeH, buffer, code, str );
+        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeH );
+        #define TypeH_AST TOP_SRCDIR "src/AST/Type.hpp"
+        resetInput( file, TypeH_AST, buffer, code, str );
+        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeH_AST );
         start += sizeof( STARTMK );                                                     // includes newline
         code << str.substr( 0, start );
 …
         for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
                 code << "\t\t" << graph[r].name << "," << endl;
         } // for
+        } // for
         code << "\t\tNUMBER_OF_BASIC_TYPES" << endl;
         code << "\t} kind;" << endl;
         code << "\t";                                                                           // indentation for end marker
         if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeH );
+        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeH_AST );
         code << str.substr( start );
         output( file, TypeH, code );
+        output( file, TypeH_AST, code );
         // cout << code.str();
         #define TypeC TOP_SRCDIR "src/SynTree/Type.cc"
         resetInput( file, TypeC, buffer, code, str );
         if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeC );
+        #define TypeC_AST TOP_SRCDIR "src/AST/Type.cpp"
+        resetInput( file, TypeC_AST, buffer, code, str );
+        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeC_AST );
         start += sizeof( STARTMK );                                                     // includes newline
         code << str.substr( 0, start );
 …
         for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
                 code << "\t\"" << graph[r].type << "\"," << endl;
+        } // for
+        code << "};" << endl;
+        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeC );
+        code << str.substr( start );
+        output( file, TypeC, code );
+        // cout << code.str();
+        // TEMPORARY DURING CHANGE OVER
+        #define TypeH_AST TOP_SRCDIR "src/AST/Type.hpp"
+        resetInput( file, TypeH_AST, buffer, code, str );
+        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeH_AST );
+        start += sizeof( STARTMK );                                                     // includes newline
+        code << str.substr( 0, start );
+        code << "\t" << BYMK << endl;
+        code << "\tenum Kind {" << endl;
+        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
+                code << "\t\t" << graph[r].name << "," << endl;
+        } // for
+        code << "\t\tNUMBER_OF_BASIC_TYPES" << endl;
+        code << "\t} kind;" << endl;
+        code << "\t";                                                                           // indentation for end marker
+        if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", TypeH_AST );
+        code << str.substr( start );
+        output( file, TypeH_AST, code );
+        // cout << code.str();
+        #define TypeC_AST TOP_SRCDIR "src/AST/Type.cpp"
+        resetInput( file, TypeC_AST, buffer, code, str );
+        if ( (start = str.find( STARTMK )) == string::npos ) Abort( "start", TypeC_AST );
+        start += sizeof( STARTMK );                                                     // includes newline
+        code << str.substr( 0, start );
+        code << BYMK << endl;
+        code << "const char * BasicType::typeNames[] = {" << endl;
+        for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
+                code << "\t\"" << graph[r].type << "\"," << endl;
+        } // for
+        } // for
         code << "};" << endl;
 …
         end += sizeof( STARTMK );
         code << str.substr( start, end - start );
         code << "\t" << BYMK << endl;
         code << "\tstatic const int costMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node" << endl
+        code << "\tstatic const int costMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node" << endl
                  << "\t\t/*           ";
         for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // titles
 …
         code << "\tstatic const int maxIntCost = " << *max_element(costMatrix[SignedInt], costMatrix[SignedInt] + NUMBER_OF_BASIC_TYPES) << ";" << endl;
         code << "\t";                                                                           // indentation for end marker
         if ( (start = str.find( ENDMK, start + 1 )) == string::npos ) Abort( "end", ConversionCost );
         if ( (end = str.find( STARTMK, start + 1 )) == string::npos ) Abort( "start", ConversionCost );
 …
         code << "\t" << BYMK << endl;
         code << "\tstatic const int signMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion" << endl
+        code << "\tstatic const int signMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion" << endl
                  << "\t\t/*           ";
         for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // titles
 …
         enum { PER_ROW = 6 };
         code << "\t" << BYMK << endl;
         code << "\t#define BT BasicType::" << endl;
         code << "\tstatic const BasicType::Kind commonTypes[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor" << endl
+        code << "\t#define BT ast::BasicType::" << endl;
+        code << "\tstatic const BT Kind commonTypes[BT NUMBER_OF_BASIC_TYPES][BT NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor" << endl
              << "\t\t/*\t\t ";
         for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) { // titles
 …
                 "\t\t\t//   - \"Di\" char32_t\n"
                 "\t\t\t//   - \"Ds\" char16_t\n";
         code << "\t\t\tconst std::string basicTypes[BasicType::NUMBER_OF_BASIC_TYPES] = {" << endl;
+        code << "\t\t\tconst std::string basicTypes[ast::BasicType::NUMBER_OF_BASIC_TYPES] = {" << endl;
         for ( int r = 0; r < NUMBER_OF_BASIC_TYPES; r += 1 ) {
                 code << "\t\t\t\t\"" << graph[r].mangled << "\"," << setw(9 - strlen(graph[r].mangled)) << ' ' << "// " << graph[r].type << endl;
         } // for
+        } // for
         code << "\t\t\t}; // basicTypes" << endl;
         code << "\t\t\t";                                                                       // indentation for end marker

src/CodeGen/FixMain.cc

-              r0030b508
+              rfc12f05
 // file "LICENCE" distributed with Cforall.
 //
 // FixMain.cc --
+// FixMain.cc -- Tools to change a Cforall main into a C main.
 //
 // Author           : Thierry Delisle
 …
 // Update Count     : 0
 //
 #include "FixMain.h"
 …
 #include "AST/Decl.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
+#include "AST/Vector.hpp"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "CodeGen/GenType.h"       // for GenType
-#include "SynTree/Declaration.h"   // for FunctionDecl, operator<<
-#include "SynTree/Type.h"          // for FunctionType
 #include "SymTab/Mangler.h"
 …
 namespace {
 struct FindMainCore {
         FunctionDecl * main_signature = nullptr;
+struct FindMainCore final {
+        ast::FunctionDecl const * main_declaration = nullptr;
         void previsit( FunctionDecl * decl ) {
                 if ( FixMain::isMain( decl ) ) {
                         if ( main_signature ) {
+        void previsit( ast::FunctionDecl const * decl ) {
+                if ( isMain( decl ) ) {
+                        if ( main_declaration ) {
                                 SemanticError( decl, "Multiple definition of main routine\n" );
+                        }
                         main_signature = decl;
+                        main_declaration = decl;
+                }
+        }
 };
+std::string genTypeAt( const ast::vector<ast::Type> & types, size_t at ) {
+        return genType( types[at], "", Options( false, false, false, false ) );
+}
+        template<typename container>
+        std::string genTypeAt(const container& p, size_t idx) {
+                return genType((*std::next(p.begin(), idx))->get_type(), "");
+        }
+        void FixMain::fix( std::list< Declaration * > & translationUnit,
+                        std::ostream &os, const char* bootloader_filename ) {
+                PassVisitor< FindMainCore > main_finder;
+                acceptAll( translationUnit, main_finder );
+                FunctionDecl * main_signature = main_finder.pass.main_signature;
+                if( main_signature ) {
+                        os << "static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return ";
+                        main_signature->mangleName = SymTab::Mangler::mangle(main_signature);
+                        os << main_signature->get_scopedMangleName() << "(";
+                        const auto& params = main_signature->get_functionType()->get_parameters();
+                        switch(params.size()) {
+                                case 3: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv, (" << genTypeAt(params, 2) << ")envp"; break;
+                                case 2: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv"; break;
+                                case 0: break;
+                                default : assert(false);
+                        }
+                        os << "); }\n";
+                        std::ifstream bootloader(bootloader_filename, std::ios::in);
+                        assertf( bootloader.is_open(), "cannot open bootloader.c\n" );
+                        os << bootloader.rdbuf();
+                }
+        }
+namespace {
+ObjectDecl * signedIntObj() {
+        return new ObjectDecl(
+                "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
+                new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr );
+ast::ObjectDecl * makeIntObj(){
+        return new ast::ObjectDecl( CodeLocation(), "",
+                new ast::BasicType( ast::BasicType::SignedInt ) );
+}
+ObjectDecl * makeArgvObj() {
+        return new ObjectDecl(
+                "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
+                new PointerType( Type::Qualifiers(),
+                        new PointerType( Type::Qualifiers(),
+                                new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),
+                nullptr );
+ast::ObjectDecl * makeCharStarStarObj() {
+        return new ast::ObjectDecl( CodeLocation(), "",
+                new ast::PointerType(
+                        new ast::PointerType(
+                                new ast::BasicType( ast::BasicType::Char ) ) ) );
+}
+std::string create_mangled_main_function_name( FunctionType * function_type ) {
+        std::unique_ptr<FunctionDecl> decl( new FunctionDecl(
+                "main", Type::StorageClasses(), LinkageSpec::Cforall,
+                function_type, nullptr ) );
+        return SymTab::Mangler::mangle( decl.get() );
+std::string getMangledNameOfMain(
+                ast::vector<ast::DeclWithType> && params, ast::ArgumentFlag isVarArgs ) {
+        ast::ptr<ast::FunctionDecl> decl = new ast::FunctionDecl(
+                CodeLocation(),
+                "main",
+                ast::vector<ast::TypeDecl>(),
+                ast::vector<ast::DeclWithType>(),
+                std::move( params ),
+                { makeIntObj() },
+                nullptr,
+                ast::Storage::Classes(),
+                ast::Linkage::Spec(),
+                ast::vector<ast::Attribute>(),
+                ast::Function::Specs(),
+                isVarArgs
+        );
+        return Mangle::mangle( decl.get() );
+}
+std::string mangled_0_argument_main() {
+        FunctionType* main_type = new FunctionType( Type::Qualifiers(), true );
+        main_type->get_returnVals().push_back( signedIntObj() );
+        return create_mangled_main_function_name( main_type );
+std::string getMangledNameOf0ParameterMain() {
+        return getMangledNameOfMain( {}, ast::VariableArgs );
+}
+std::string mangled_2_argument_main() {
+        FunctionType* main_type = new FunctionType( Type::Qualifiers(), false );
+        main_type->get_returnVals().push_back( signedIntObj() );
+        main_type->get_parameters().push_back( signedIntObj() );
+        main_type->get_parameters().push_back( makeArgvObj() );
+        return create_mangled_main_function_name( main_type );
+std::string getMangledNameOf2ParameterMain() {
+        return getMangledNameOfMain( {
+                makeIntObj(),
+                makeCharStarStarObj(),
+        }, ast::FixedArgs );
+}
 …
         // This breaks if you move it out of the function.
         static const std::string mangled_mains[] = {
                 mangled_0_argument_main(),
                 mangled_2_argument_main(),
                 //mangled_3_argument_main(),
+                getMangledNameOf0ParameterMain(),
+                getMangledNameOf2ParameterMain(),
+                //getMangledNameOf3ParameterMain(),
         };
 …
+}
+struct FixLinkageCore final {
+        ast::Linkage::Spec const spec;
+        FixLinkageCore( ast::Linkage::Spec spec ) : spec( spec ) {}
+        ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl ) {
+                if ( decl->name != "main" ) return decl;
+                return ast::mutate_field( decl, &ast::FunctionDecl::linkage, spec );
+        }
+};
 } // namespace
+bool FixMain::isMain( FunctionDecl * decl ) {
+        if ( std::string("main") != decl->name ) {
+                return false;
+        }
+        return is_main( SymTab::Mangler::mangle( decl, true, true ) );
+}
+bool FixMain::isMain( const ast::FunctionDecl * decl ) {
+bool isMain( const ast::FunctionDecl * decl ) {
         if ( std::string("main") != decl->name ) {
                 return false;
 …
+}
+};
+void fixMainLinkage( ast::TranslationUnit & translationUnit,
+                bool replace_main ) {
+        ast::Linkage::Spec const spec =
+                ( replace_main ) ? ast::Linkage::Cforall : ast::Linkage::C;
+        ast::Pass<FixLinkageCore>::run( translationUnit, spec );
+}
+void fixMainInvoke( ast::TranslationUnit & translationUnit,
+                std::ostream &os, const char * bootloader_filename ) {
+        ast::Pass<FindMainCore> main_finder;
+        ast::accept_all( translationUnit, main_finder );
+        if ( nullptr == main_finder.core.main_declaration ) return;
+        ast::FunctionDecl * main_declaration =
+                ast::mutate( main_finder.core.main_declaration );
+        main_declaration->mangleName = Mangle::mangle( main_declaration );
+        os << "static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return ";
+        os << main_declaration->scopedMangleName() << "(";
+        const auto& params = main_declaration->type->params;
+        switch ( params.size() ) {
+                case 3: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv, (" << genTypeAt(params, 2) << ")envp"; break;
+                case 2: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv"; break;
+                case 0: break;
+                default : assert(false);
+        }
+        os << "); }\n";
+        std::ifstream bootloader( bootloader_filename, std::ios::in );
+        assertf( bootloader.is_open(), "cannot open bootloader.c\n" );
+        os << bootloader.rdbuf();
+}
+} // namespace CodeGen

src/CodeGen/FixMain.h

-              r0030b508
+              rfc12f05
 // file "LICENCE" distributed with Cforall.
 //
 // FixMain.h --
+// FixMain.h -- Tools to change a Cforall main into a C main.
 //
 // Author           : Thierry Delisle
 …
 #include <iosfwd>
-#include <memory>
-#include <list>
-#include "SynTree/LinkageSpec.h"
-class Declaration;
-class FunctionDecl;
 namespace ast {
         class FunctionDecl;
+        class TranslationUnit;
+}
 namespace CodeGen {
+class FixMain {
+public :
+        static inline LinkageSpec::Spec mainLinkage() {
+                return replace_main ? LinkageSpec::Cforall : LinkageSpec::C;
+        }
+/// Is this function a program main function?
+bool isMain( const ast::FunctionDecl * decl );
+        static inline void setReplaceMain(bool val) {
+                replace_main = val;
+        }
+/// Adjust the linkage of main functions.
+void fixMainLinkage( ast::TranslationUnit & transUnit, bool replaceMain );
+        static bool isMain(FunctionDecl* decl);
+        static bool isMain(const ast::FunctionDecl * decl);
+        static void fix( std::list< Declaration * > & decls,
+                        std::ostream &os, const char* bootloader_filename );
+private:
+        static bool replace_main;
+};
+/// Add a wrapper around to run the Cforall main.
+void fixMainInvoke( ast::TranslationUnit & transUnit,
+                std::ostream & os, const char * bootloaderFilename );
 } // namespace CodeGen

src/CodeGen/FixNames.cc

-              r0030b508
+              rfc12f05
 #include "AST/Expr.hpp"
 #include "AST/Pass.hpp"
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "FixMain.h"               // for FixMain
 #include "SymTab/Mangler.h"        // for Mangler
-#include "SynTree/LinkageSpec.h"   // for Cforall, isMangled
-#include "SynTree/Constant.h"      // for Constant
-#include "SynTree/Declaration.h"   // for FunctionDecl, ObjectDecl, Declarat...
-#include "SynTree/Expression.h"    // for ConstantExpr
-#include "SynTree/Label.h"         // for Label, noLabels
-#include "SynTree/Statement.h"     // for ReturnStmt, CompoundStmt
-#include "SynTree/Type.h"          // for Type, BasicType, Type::Qualifiers
-#include "SynTree/Visitor.h"       // for Visitor, acceptAll
 #include "CompilationState.h"
 namespace CodeGen {
-        class FixNames : public WithGuards {
-          public:
-                void postvisit( ObjectDecl *objectDecl );
-                void postvisit( FunctionDecl *functionDecl );
+                void previsit( CompoundStmt *compoundStmt );
+          private:
+                int scopeLevel = 1;
+                void fixDWT( DeclarationWithType *dwt );
+        };
+        void fixNames( std::list< Declaration* > & translationUnit ) {
+                PassVisitor<FixNames> fixer;
+                acceptAll( translationUnit, fixer );
+        }
+        void FixNames::fixDWT( DeclarationWithType * dwt ) {
+                if ( dwt->get_name() != "" ) {
+                        if ( LinkageSpec::isMangled( dwt->get_linkage() ) ) {
+                                if (!useNewAST) {
+                                        dwt->set_mangleName( SymTab::Mangler::mangle( dwt ) );
+                                }
+                                dwt->set_scopeLevel( scopeLevel );
+                        } // if
+                } // if
+        }
+        void FixNames::postvisit( ObjectDecl * objectDecl ) {
+                fixDWT( objectDecl );
+        }
+        void FixNames::postvisit( FunctionDecl * functionDecl ) {
+                fixDWT( functionDecl );
+                if ( FixMain::isMain( functionDecl ) ) {
+                        int nargs = functionDecl->get_functionType()->get_parameters().size();
+                        if( !(nargs == 0 || nargs == 2 || nargs == 3) ) {
+                                SemanticError(functionDecl, "Main expected to have 0, 2 or 3 arguments\n");
+                        }
+                        functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( new ConstantExpr( Constant::from_int( 0 ) ) ) );
+                }
+        }
+        void FixNames::previsit( CompoundStmt * ) {
+                scopeLevel++;
+                GuardAction( [this](){ scopeLevel--; } );
+        }
+namespace {
 /// Does work with the main function and scopeLevels.
 class FixNames_new final {
+class FixNames final {
         int scopeLevel = 1;
 …
         const ast::FunctionDecl *postvisit( const ast::FunctionDecl *functionDecl ) {
                 if ( FixMain::isMain( functionDecl ) ) {
+                if ( isMain( functionDecl ) ) {
                         auto mutDecl = ast::mutate( functionDecl );
 …
 };
+} // namespace
 void fixNames( ast::TranslationUnit & translationUnit ) {
         ast::Pass<FixNames_new>::run( translationUnit );
+        ast::Pass<FixNames>::run( translationUnit );
+}

src/CodeGen/FixNames.h

-              r0030b508
+              rfc12f05
 #pragma once
-#include <list>  // for list
-class Declaration;
 namespace ast {
         class TranslationUnit;
 …
 namespace CodeGen {
+        /// mangles object and function names
+        void fixNames( std::list< Declaration* > & translationUnit );
 /// Sets scope levels and fills in main's default return.
 void fixNames( ast::TranslationUnit & translationUnit );
 } // namespace CodeGen

src/CodeGen/GenType.cc

-              r0030b508
+              rfc12f05
 #include <sstream>                // for operator<<, ostringstream, basic_os...
+#include "CodeGenerator.h"        // for CodeGenerator
+#include "SynTree/Declaration.h"  // for DeclarationWithType
+#include "SynTree/Expression.h"   // for Expression
+#include "SynTree/Type.h"         // for PointerType, Type, FunctionType
+#include "SynTree/Visitor.h"      // for Visitor
+#include "AST/Print.hpp"          // for print
+#include "AST/Vector.hpp"         // for vector
+#include "CodeGeneratorNew.hpp"   // for CodeGenerator_new
+#include "Common/UniqueName.h"    // for UniqueName
 namespace CodeGen {
+        struct GenType : public WithVisitorRef<GenType>, public WithShortCircuiting {
+                std::string typeString;
+                GenType( const std::string &typeString, const Options &options );
+                void previsit( BaseSyntaxNode * );
+                void postvisit( BaseSyntaxNode * );
+                void postvisit( FunctionType * funcType );
+                void postvisit( VoidType * voidType );
+                void postvisit( BasicType * basicType );
+                void postvisit( PointerType * pointerType );
+                void postvisit( ArrayType * arrayType );
+                void postvisit( ReferenceType * refType );
+                void postvisit( StructInstType * structInst );
+                void postvisit( UnionInstType * unionInst );
+                void postvisit( EnumInstType * enumInst );
+                void postvisit( TypeInstType * typeInst );
+                void postvisit( TupleType  * tupleType );
+                void postvisit( VarArgsType * varArgsType );
+                void postvisit( ZeroType * zeroType );
+                void postvisit( OneType * oneType );
+                void postvisit( GlobalScopeType * globalType );
+                void postvisit( TraitInstType * inst );
+                void postvisit( TypeofType * typeof );
+                void postvisit( VTableType * vtable );
+                void postvisit( QualifiedType * qualType );
+          private:
+                void handleQualifiers( Type *type );
+                std::string handleGeneric( ReferenceToType * refType );
+                void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
+                Options options;
+        };
+        std::string genType( Type *type, const std::string &baseString, const Options &options ) {
+                PassVisitor<GenType> gt( baseString, options );
+namespace {
+#warning Remove the _new when old version is removed.
+struct GenType_new :
+                public ast::WithShortCircuiting,
+                public ast::WithVisitorRef<GenType_new> {
+        std::string result;
+        GenType_new( const std::string &typeString, const Options &options );
+        void previsit( ast::Node const * );
+        void postvisit( ast::Node const * );
+        void postvisit( ast::FunctionType const * type );
+        void postvisit( ast::VoidType const * type );
+        void postvisit( ast::BasicType const * type );
+        void postvisit( ast::PointerType const * type );
+        void postvisit( ast::ArrayType const * type );
+        void postvisit( ast::ReferenceType const * type );
+        void postvisit( ast::StructInstType const * type );
+        void postvisit( ast::UnionInstType const * type );
+        void postvisit( ast::EnumInstType const * type );
+        void postvisit( ast::TypeInstType const * type );
+        void postvisit( ast::TupleType const * type );
+        void postvisit( ast::VarArgsType const * type );
+        void postvisit( ast::ZeroType const * type );
+        void postvisit( ast::OneType const * type );
+        void postvisit( ast::GlobalScopeType const * type );
+        void postvisit( ast::TraitInstType const * type );
+        void postvisit( ast::TypeofType const * type );
+        void postvisit( ast::VTableType const * type );
+        void postvisit( ast::QualifiedType const * type );
+private:
+        void handleQualifiers( ast::Type const *type );
+        std::string handleGeneric( ast::BaseInstType const * type );
+        void genArray( const ast::CV::Qualifiers &qualifiers, ast::Type const *base, ast::Expr const *dimension, bool isVarLen, bool isStatic );
+        std::string genParamList( const ast::vector<ast::Type> & );
+        Options options;
+};
+GenType_new::GenType_new( const std::string &typeString, const Options &options ) : result( typeString ), options( options ) {}
+void GenType_new::previsit( ast::Node const * ) {
+        // Turn off automatic recursion for all nodes, to allow each visitor to
+        // precisely control the order in which its children are visited.
+        visit_children = false;
+}
+void GenType_new::postvisit( ast::Node const * node ) {
+        std::stringstream ss;
+        ast::print( ss, node );
+        assertf( false, "Unhandled node reached in GenType: %s", ss.str().c_str() );
+}
+void GenType_new::postvisit( ast::VoidType const * type ) {
+        result = "void " + result;
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::BasicType const * type ) {
+        ast::BasicType::Kind kind = type->kind;
+        assert( 0 <= kind && kind < ast::BasicType::NUMBER_OF_BASIC_TYPES );
+        result = std::string( ast::BasicType::typeNames[kind] ) + " " + result;
+        handleQualifiers( type );
+}
+void GenType_new::genArray( const ast::CV::Qualifiers & qualifiers, ast::Type const * base, ast::Expr const *dimension, bool isVarLen, bool isStatic ) {
+        std::ostringstream os;
+        if ( result != "" ) {
+                if ( result[ 0 ] == '*' ) {
+                        os << "(" << result << ")";
+                } else {
+                        os << result;
+                }
+        }
+        os << "[";
+        if ( isStatic ) {
+                os << "static ";
+        }
+        if ( qualifiers.is_const ) {
+                os << "const ";
+        }
+        if ( qualifiers.is_volatile ) {
+                os << "volatile ";
+        }
+        if ( qualifiers.is_restrict ) {
+                os << "__restrict ";
+        }
+        if ( qualifiers.is_atomic ) {
+                os << "_Atomic ";
+        }
+        if ( dimension != 0 ) {
+                ast::Pass<CodeGenerator_new>::read( dimension, os, options );
+        } else if ( isVarLen ) {
+                // no dimension expression on a VLA means it came in with the * token
+                os << "*";
+        }
+        os << "]";
+        result = os.str();
+        base->accept( *visitor );
+}
+void GenType_new::postvisit( ast::PointerType const * type ) {
+        if ( type->isStatic || type->isVarLen || type->dimension ) {
+                genArray( type->qualifiers, type->base, type->dimension, type->isVarLen, type->isStatic );
+        } else {
+                handleQualifiers( type );
+                if ( result[ 0 ] == '?' ) {
+                        result = "* " + result;
+                } else {
+                        result = "*" + result;
+                }
+                type->base->accept( *visitor );
+        }
+}
+void GenType_new::postvisit( ast::ArrayType const * type ) {
+        genArray( type->qualifiers, type->base, type->dimension, type->isVarLen, type->isStatic );
+}
+void GenType_new::postvisit( ast::ReferenceType const * type ) {
+        assertf( !options.genC, "Reference types should not reach code generation." );
+        handleQualifiers( type );
+        result = "&" + result;
+        type->base->accept( *visitor );
+}
+void GenType_new::postvisit( ast::FunctionType const * type ) {
+        std::ostringstream os;
+        if ( result != "" ) {
+                if ( result[ 0 ] == '*' ) {
+                        os << "(" << result << ")";
+                } else {
+                        os << result;
+                }
+        }
+        if ( type->params.empty() ) {
+                if ( type->isVarArgs ) {
+                        os << "()";
+                } else {
+                        os << "(void)";
+                }
+        } else {
+                os << "(" ;
+                os << genParamList( type->params );
+                if ( type->isVarArgs ) {
+                        os << ", ...";
+                }
+                os << ")";
+        }
+        result = os.str();
+        if ( type->returns.size() == 0 ) {
+                result = "void " + result;
+        } else {
+                type->returns.front()->accept( *visitor );
+        }
+        // Add forall clause.
+        if( !type->forall.empty() && !options.genC ) {
+                //assertf( !options.genC, "FunctionDecl type parameters should not reach code generation." );
                 std::ostringstream os;
+                if ( ! type->get_attributes().empty() ) {
+                        PassVisitor<CodeGenerator> cg( os, options );
+                        cg.pass.genAttributes( type->get_attributes() );
+                } // if
+                type->accept( gt );
+                return os.str() + gt.pass.typeString;
+        }
+        std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
+                return genType( type, baseString, Options(pretty, genC, lineMarks, false ) );
+        }
+        std::string genPrettyType( Type * type, const std::string & baseString ) {
+                return genType( type, baseString, true, false );
+        }
+        GenType::GenType( const std::string &typeString, const Options &options ) : typeString( typeString ), options( options ) {}
+        // *** BaseSyntaxNode
+        void GenType::previsit( BaseSyntaxNode * ) {
+                // turn off automatic recursion for all nodes, to allow each visitor to
+                // precisely control the order in which its children are visited.
+                visit_children = false;
+        }
+        void GenType::postvisit( BaseSyntaxNode * node ) {
+                std::stringstream ss;
+                node->print( ss );
+                assertf( false, "Unhandled node reached in GenType: %s", ss.str().c_str() );
+        }
+        void GenType::postvisit( VoidType * voidType ) {
+                typeString = "void " + typeString;
+                handleQualifiers( voidType );
+        }
+        void GenType::postvisit( BasicType * basicType ) {
+                BasicType::Kind kind = basicType->kind;
+                assert( 0 <= kind && kind < BasicType::NUMBER_OF_BASIC_TYPES );
+                typeString = std::string( BasicType::typeNames[kind] ) + " " + typeString;
+                handleQualifiers( basicType );
+        }
+        void GenType::genArray( const Type::Qualifiers & qualifiers, Type * base, Expression *dimension, bool isVarLen, bool isStatic ) {
+                ast::Pass<CodeGenerator_new> cg( os, options );
+                os << "forall(";
+                cg.core.genCommaList( type->forall );
+                os << ")" << std::endl;
+                result = os.str() + result;
+        }
+}
+std::string GenType_new::handleGeneric( ast::BaseInstType const * type ) {
+        if ( !type->params.empty() ) {
                 std::ostringstream os;
+                if ( typeString != "" ) {
+                        if ( typeString[ 0 ] == '*' ) {
+                                os << "(" << typeString << ")";
+                        } else {
+                                os << typeString;
+                        } // if
+                } // if
+                os << "[";
+                if ( isStatic ) {
+                        os << "static ";
+                } // if
+                if ( qualifiers.is_const ) {
+                        os << "const ";
+                } // if
+                if ( qualifiers.is_volatile ) {
+                        os << "volatile ";
+                } // if
+                if ( qualifiers.is_restrict ) {
+                        os << "__restrict ";
+                } // if
+                if ( qualifiers.is_atomic ) {
+                        os << "_Atomic ";
+                } // if
+                if ( dimension != 0 ) {
+                        PassVisitor<CodeGenerator> cg( os, options );
+                        dimension->accept( cg );
+                } else if ( isVarLen ) {
+                        // no dimension expression on a VLA means it came in with the * token
+                        os << "*";
+                } // if
+                os << "]";
+                typeString = os.str();
+                base->accept( *visitor );
+        }
+        void GenType::postvisit( PointerType * pointerType ) {
+                assert( pointerType->base != 0);
+                if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->dimension ) {
+                        genArray( pointerType->get_qualifiers(), pointerType->base, pointerType->dimension, pointerType->get_isVarLen(), pointerType->get_isStatic() );
+                } else {
+                        handleQualifiers( pointerType );
+                        if ( typeString[ 0 ] == '?' ) {
+                                typeString = "* " + typeString;
+                        } else {
+                                typeString = "*" + typeString;
+                        } // if
+                        pointerType->base->accept( *visitor );
+                } // if
+        }
+        void GenType::postvisit( ArrayType * arrayType ) {
+                genArray( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->get_isVarLen(), arrayType->get_isStatic() );
+        }
+        void GenType::postvisit( ReferenceType * refType ) {
+                assert( 0 != refType->base );
+                assertf( ! options.genC, "Reference types should not reach code generation." );
+                handleQualifiers( refType );
+                typeString = "&" + typeString;
+                refType->base->accept( *visitor );
+        }
+        void GenType::postvisit( FunctionType * funcType ) {
+                std::ostringstream os;
+                if ( typeString != "" ) {
+                        if ( typeString[ 0 ] == '*' ) {
+                                os << "(" << typeString << ")";
+                        } else {
+                                os << typeString;
+                        } // if
+                } // if
+                /************* parameters ***************/
+                const std::list<DeclarationWithType *> &pars = funcType->parameters;
+                if ( pars.empty() ) {
+                        if ( funcType->get_isVarArgs() ) {
+                                os << "()";
+                        } else {
+                                os << "(void)";
+                        } // if
+                } else {
+                        PassVisitor<CodeGenerator> cg( os, options );
+                        os << "(" ;
+                        cg.pass.genCommaList( pars.begin(), pars.end() );
+                        if ( funcType->get_isVarArgs() ) {
+                                os << ", ...";
+                        } // if
+                        os << ")";
+                } // if
+                typeString = os.str();
+                if ( funcType->returnVals.size() == 0 ) {
+                        typeString = "void " + typeString;
+                } else {
+                        funcType->returnVals.front()->get_type()->accept( *visitor );
+                } // if
+                // add forall
+                if( ! funcType->forall.empty() && ! options.genC ) {
+                        // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
+                        std::ostringstream os;
+                        PassVisitor<CodeGenerator> cg( os, options );
+                        os << "forall(";
+                        cg.pass.genCommaList( funcType->forall.begin(), funcType->forall.end() );
+                        os << ")" << std::endl;
+                        typeString = os.str() + typeString;
+                }
+        }
+        std::string GenType::handleGeneric( ReferenceToType * refType ) {
+                if ( ! refType->parameters.empty() ) {
+                        std::ostringstream os;
+                        PassVisitor<CodeGenerator> cg( os, options );
+                        os << "(";
+                        cg.pass.genCommaList( refType->parameters.begin(), refType->parameters.end() );
+                        os << ") ";
+                        return os.str();
+                }
+                return "";
+        }
+        void GenType::postvisit( StructInstType * structInst )  {
+                typeString = structInst->name + handleGeneric( structInst ) + " " + typeString;
+                if ( options.genC ) typeString = "struct " + typeString;
+                handleQualifiers( structInst );
+        }
+        void GenType::postvisit( UnionInstType * unionInst ) {
+                typeString = unionInst->name + handleGeneric( unionInst ) + " " + typeString;
+                if ( options.genC ) typeString = "union " + typeString;
+                handleQualifiers( unionInst );
+        }
+        void GenType::postvisit( EnumInstType * enumInst ) {
+                if ( enumInst->baseEnum && enumInst->baseEnum->base ) {
+                        typeString = genType(enumInst->baseEnum->base, typeString, options);
+                } else {
+                        typeString = enumInst->name + " " + typeString;
+                        if ( options.genC ) {
+                                typeString = "enum " + typeString;
+                        }
+                }
+                handleQualifiers( enumInst );
+        }
+        void GenType::postvisit( TypeInstType * typeInst ) {
+                assertf( ! options.genC, "Type instance types should not reach code generation." );
+                typeString = typeInst->name + " " + typeString;
+                handleQualifiers( typeInst );
+        }
+        void GenType::postvisit( TupleType * tupleType ) {
+                assertf( ! options.genC, "Tuple types should not reach code generation." );
+                unsigned int i = 0;
+                std::ostringstream os;
+                os << "[";
+                for ( Type * t : *tupleType ) {
+                        i++;
+                        os << genType( t, "", options ) << (i == tupleType->size() ? "" : ", ");
+                }
+                os << "] ";
+                typeString = os.str() + typeString;
+        }
+        void GenType::postvisit( VarArgsType * varArgsType ) {
+                typeString = "__builtin_va_list " + typeString;
+                handleQualifiers( varArgsType );
+        }
+        void GenType::postvisit( ZeroType * zeroType ) {
+                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
+                typeString = (options.pretty ? "zero_t " : "long int ") + typeString;
+                handleQualifiers( zeroType );
+        }
+        void GenType::postvisit( OneType * oneType ) {
+                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
+                typeString = (options.pretty ? "one_t " : "long int ") + typeString;
+                handleQualifiers( oneType );
+        }
+        void GenType::postvisit( GlobalScopeType * globalType ) {
+                assertf( ! options.genC, "Global scope type should not reach code generation." );
+                handleQualifiers( globalType );
+        }
+        void GenType::postvisit( TraitInstType * inst ) {
+                assertf( ! options.genC, "Trait types should not reach code generation." );
+                typeString = inst->name + " " + typeString;
+                handleQualifiers( inst );
+        }
+        void GenType::postvisit( TypeofType * typeof ) {
+                std::ostringstream os;
+                PassVisitor<CodeGenerator> cg( os, options );
+                os << "typeof(";
+                typeof->expr->accept( cg );
+                os << ") " << typeString;
+                typeString = os.str();
+                handleQualifiers( typeof );
+        }
+        void GenType::postvisit( VTableType * vtable ) {
+                assertf( ! options.genC, "Virtual table types should not reach code generation." );
+                std::ostringstream os;
+                os << "vtable(" << genType( vtable->base, "", options ) << ") " << typeString;
+                typeString = os.str();
+                handleQualifiers( vtable );
+        }
+        void GenType::postvisit( QualifiedType * qualType ) {
+                assertf( ! options.genC, "Qualified types should not reach code generation." );
+                std::ostringstream os;
+                os << genType( qualType->parent, "", options ) << "." << genType( qualType->child, "", options ) << typeString;
+                typeString = os.str();
+                handleQualifiers( qualType );
+        }
+        void GenType::handleQualifiers( Type * type ) {
+                if ( type->get_const() ) {
+                        typeString = "const " + typeString;
+                } // if
+                if ( type->get_volatile() ) {
+                        typeString = "volatile " + typeString;
+                } // if
+                if ( type->get_restrict() ) {
+                        typeString = "__restrict " + typeString;
+                } // if
+                if ( type->get_atomic() ) {
+                        typeString = "_Atomic " + typeString;
+                } // if
+        }
+                ast::Pass<CodeGenerator_new> cg( os, options );
+                os << "(";
+                cg.core.genCommaList( type->params );
+                os << ") ";
+                return os.str();
+        }
+        return "";
+}
+void GenType_new::postvisit( ast::StructInstType const * type )  {
+        result = type->name + handleGeneric( type ) + " " + result;
+        if ( options.genC ) result = "struct " + result;
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::UnionInstType const * type ) {
+        result = type->name + handleGeneric( type ) + " " + result;
+        if ( options.genC ) result = "union " + result;
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::EnumInstType const * type ) {
+        if ( type->base && type->base->base ) {
+                result = genType( type->base->base, result, options );
+        } else {
+                result = type->name + " " + result;
+                if ( options.genC ) {
+                        result = "enum " + result;
+                }
+        }
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::TypeInstType const * type ) {
+        assertf( !options.genC, "TypeInstType should not reach code generation." );
+        result = type->name + " " + result;
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::TupleType const * type ) {
+        assertf( !options.genC, "TupleType should not reach code generation." );
+        unsigned int i = 0;
+        std::ostringstream os;
+        os << "[";
+        for ( ast::ptr<ast::Type> const & t : type->types ) {
+                i++;
+                os << genType( t, "", options ) << (i == type->size() ? "" : ", ");
+        }
+        os << "] ";
+        result = os.str() + result;
+}
+void GenType_new::postvisit( ast::VarArgsType const * type ) {
+        result = "__builtin_va_list " + result;
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::ZeroType const * type ) {
+        // Ideally these wouldn't hit codegen at all, but should be safe to make them ints.
+        result = (options.pretty ? "zero_t " : "long int ") + result;
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::OneType const * type ) {
+        // Ideally these wouldn't hit codegen at all, but should be safe to make them ints.
+        result = (options.pretty ? "one_t " : "long int ") + result;
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::GlobalScopeType const * type ) {
+        assertf( !options.genC, "GlobalScopeType should not reach code generation." );
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::TraitInstType const * type ) {
+        assertf( !options.genC, "TraitInstType should not reach code generation." );
+        result = type->name + " " + result;
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::TypeofType const * type ) {
+        std::ostringstream os;
+        os << "typeof(";
+        ast::Pass<CodeGenerator_new>::read( type, os, options );
+        os << ") " << result;
+        result = os.str();
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::VTableType const * type ) {
+        assertf( !options.genC, "Virtual table types should not reach code generation." );
+        std::ostringstream os;
+        os << "vtable(" << genType( type->base, "", options ) << ") " << result;
+        result = os.str();
+        handleQualifiers( type );
+}
+void GenType_new::postvisit( ast::QualifiedType const * type ) {
+        assertf( !options.genC, "QualifiedType should not reach code generation." );
+        std::ostringstream os;
+        os << genType( type->parent, "", options ) << "." << genType( type->child, "", options ) << result;
+        result = os.str();
+        handleQualifiers( type );
+}
+void GenType_new::handleQualifiers( ast::Type const * type ) {
+        if ( type->is_const() ) {
+                result = "const " + result;
+        }
+        if ( type->is_volatile() ) {
+                result = "volatile " + result;
+        }
+        if ( type->is_restrict() ) {
+                result = "__restrict " + result;
+        }
+        if ( type->is_atomic() ) {
+                result = "_Atomic " + result;
+        }
+}
+std::string GenType_new::genParamList( const ast::vector<ast::Type> & range ) {
+        auto cur = range.begin();
+        auto end = range.end();
+        if ( cur == end ) return "";
+        std::ostringstream oss;
+        UniqueName param( "__param_" );
+        while ( true ) {
+                oss << genType( *cur++, options.genC ? param.newName() : "", options );
+                if ( cur == end ) break;
+                oss << ", ";
+        }
+        return oss.str();
+}
+} // namespace
+std::string genType( ast::Type const * type, const std::string & base, const Options & options ) {
+        std::ostringstream os;
+        if ( !type->attributes.empty() ) {
+                ast::Pass<CodeGenerator_new> cg( os, options );
+                cg.core.genAttributes( type->attributes );
+        }
+        return os.str() + ast::Pass<GenType_new>::read( type, base, options );
+}
+std::string genTypeNoAttr( ast::Type const * type, const std::string & base, const Options & options ) {
+        return ast::Pass<GenType_new>::read( type, base, options );
+}
 } // namespace CodeGen

src/CodeGen/GenType.h

-              r0030b508
+              rfc12f05
 class Type;
+namespace ast {
+        class Type;
+}
 namespace CodeGen {
 …
         std::string genType( Type *type, const std::string &baseString, bool pretty = false, bool genC = false, bool lineMarks = false );
         std::string genPrettyType( Type * type, const std::string & baseString );
+std::string genType( ast::Type const * type, const std::string & base, const Options & options );
+std::string genTypeNoAttr( ast::Type const * type, const std::string & base, const Options & options );
 } // namespace CodeGen

src/CodeGen/Generate.cc

-              r0030b508
+              rfc12f05
 #include <string>                    // for operator<<
 #include "CodeGenerator.h"           // for CodeGenerator, doSemicolon, oper...
+#include "CodeGeneratorNew.hpp"      // for CodeGenerator_new, doSemicolon, ...
 #include "GenType.h"                 // for genPrettyType
-#include "Common/PassVisitor.h"      // for PassVisitor
-#include "SynTree/LinkageSpec.h"     // for isBuiltin, isGeneratable
-#include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode
-#include "SynTree/Declaration.h"     // for Declaration
-#include "SynTree/Type.h"            // for Type
 using namespace std;
 namespace CodeGen {
-        namespace {
-                /// Removes misc. nodes that should not exist in CodeGen
-                struct TreeCleaner {
-                        void premutate( CompoundStmt * stmt );
-                        Statement * postmutate( ImplicitCtorDtorStmt * stmt );
+                        static bool shouldClean( Declaration * );
+                };
+                void cleanTree( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor<TreeCleaner> cleaner;
+                        filter( translationUnit, [](Declaration * decl) { return TreeCleaner::shouldClean(decl); }, false );
+                        mutateAll( translationUnit, cleaner );
+                } // cleanTree
+        } // namespace
+        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC, bool lineMarks, bool printExprTypes ) {
+                cleanTree( translationUnit );
+                PassVisitor<CodeGenerator> cgv( os, pretty, generateC, lineMarks, printExprTypes );
+                for ( auto & dcl : translationUnit ) {
+                        if ( LinkageSpec::isGeneratable( dcl->get_linkage() ) && (doIntrinsics || ! LinkageSpec::isBuiltin( dcl->get_linkage() ) ) ) {
+                                cgv.pass.updateLocation( dcl );
+                                dcl->accept(cgv);
+                                if ( doSemicolon( dcl ) ) {
+                                        os << ";";
+                                } // if
+                                os << cgv.pass.endl;
+                        } // if
+                } // for
+namespace {
+        bool shouldClean( ast::Decl const * decl ) {
+                return dynamic_cast<ast::TraitDecl const *>( decl );
+        }
+        void generate( BaseSyntaxNode * node, std::ostream & os ) {
+                if ( Type * type = dynamic_cast< Type * >( node ) ) {
+                        os << genPrettyType( type, "" );
+                } else {
+                        PassVisitor<CodeGenerator> cgv( os, true, false, false, false );
+                        node->accept( cgv );
+                }
+                os << std::endl;
+        }
+        namespace {
+                void TreeCleaner::premutate( CompoundStmt * cstmt ) {
+                        filter( cstmt->kids, [](Statement * stmt) {
+                                if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
+                                        return shouldClean( declStmt->decl );
+                                }
+                                return false;
+                        }, false );
+        /// Removes various nodes that should not exist in CodeGen.
+        struct TreeCleaner_new {
+                ast::CompoundStmt const * previsit( ast::CompoundStmt const * stmt ) {
+                        auto mutStmt = ast::mutate( stmt );
+                        erase_if( mutStmt->kids, []( ast::Stmt const * stmt ){
+                                auto declStmt = dynamic_cast<ast::DeclStmt const *>( stmt );
+                                return ( declStmt ) ? shouldClean( declStmt->decl ) : false;
+                        } );
+                        return mutStmt;
+                }
+                Statement * TreeCleaner::postmutate( ImplicitCtorDtorStmt * stmt ) {
+                        Statement * callStmt = nullptr;
+                        std::swap( stmt->callStmt, callStmt );
+                        delete stmt;
+                        return callStmt;
+                ast::Stmt const * postvisit( ast::ImplicitCtorDtorStmt const * stmt ) {
+                        return stmt->callStmt;
+                }
+        };
+} // namespace
+                bool TreeCleaner::shouldClean( Declaration * decl ) {
+                        return dynamic_cast< TraitDecl * >( decl );
+void generate( ast::TranslationUnit & translationUnit, std::ostream & os, bool doIntrinsics,
+                bool pretty, bool generateC, bool lineMarks, bool printExprTypes ) {
+        erase_if( translationUnit.decls, shouldClean );
+        ast::Pass<TreeCleaner_new>::run( translationUnit );
+        ast::Pass<CodeGenerator_new> cgv( os,
+                        Options( pretty, generateC, lineMarks, printExprTypes ) );
+        for ( auto & decl : translationUnit.decls ) {
+                if ( decl->linkage.is_generatable && (doIntrinsics || !decl->linkage.is_builtin ) ) {
+                        cgv.core.updateLocation( decl );
+                        decl->accept( cgv );
+                        if ( doSemicolon( decl ) ) {
+                                os << ";";
+                        }
+                        os << cgv.core.endl;
+                }
+        } // namespace
+        }
+}
 } // namespace CodeGen

src/CodeGen/Generate.h

-              r0030b508
+              rfc12f05
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 namespace CodeGen {
-        /// Generates code. doIntrinsics determines if intrinsic functions are printed, pretty formats output nicely (e.g., uses unmangled names, etc.), generateC is true when the output must consist only of C code (allows some assertions, etc.)
-        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC = false , bool lineMarks = false, bool printTypeExpr = false );
+        /// Generate code for a single node -- helpful for debugging in gdb
+        void generate( BaseSyntaxNode * node, std::ostream & os );
+/// Generates all code in transUnit and writing it to the os.
+/// doIntrinsics: Should intrinsic functions be printed?
+/// pretty: Format output nicely (e.g., uses unmangled names, etc.).
+/// generateC: Make sure the output only consists of C code (allows some assertions, etc.)
+/// lineMarks: Output line marks (processed line directives) in the output.
+/// printExprTypes: Print the types of expressions in comments.
+void generate( ast::TranslationUnit & transUnit, std::ostream &os, bool doIntrinsics,
+                bool pretty, bool generateC, bool lineMarks, bool printExprTypes );
 } // namespace CodeGen

src/CodeGen/LinkOnce.cc

-              r0030b508
+              rfc12f05
 #include "AST/Expr.hpp"
 #include "AST/Pass.hpp"
-#include "Common/PassVisitor.h"       // for PassVisitor, WithShortCircuiting
 namespace CodeGen {
 namespace {
-bool is_cfa_linkonce_old( Attribute const * attr ) {
-        return std::string("cfa_linkonce") == attr->name;
+}
-bool is_section_attribute_old( Attribute const * attr ) {
-        return std::string("section") == attr->name;
+}
-class LinkOnceVisitorCore : public WithShortCircuiting {
-public:
-        void previsit( Declaration * ) {
-                visit_children = false;
+        }
-        void previsit( DeclarationWithType * decl ) {
-                std::list< Attribute * > & attributes = decl->attributes;
-                // See if we can find the element:
-                auto found = std::find_if(attributes.begin(), attributes.end(), is_cfa_linkonce_old );
-                if ( attributes.end() != found ) {
-                        // Remove any other sections:
-                        attributes.remove_if( is_section_attribute_old );
-                        // Iterator to the cfa_linkonce attribute should still be valid.
-                        Attribute * attribute = *found;
-                        assert( attribute->parameters.empty() );
-                        assert( !decl->mangleName.empty() );
-                        // Overwrite the attribute in place.
-                        const std::string section_name = ".gnu.linkonce." + decl->mangleName;
-                        attribute->name = "section";
-                        attribute->parameters.push_back(
-                                new ConstantExpr( Constant::from_string( section_name ) )
-                        );
-                        // Unconditionnaly add "visibility(default)" to anything with gnu.linkonce
-                        // visibility is a mess otherwise
-                        attributes.push_back(new Attribute("visibility", {new ConstantExpr( Constant::from_string( "default" ) )}));
+                }
-                visit_children = false;
+        }
-};
 bool is_cfa_linkonce( ast::Attribute const * attr ) {
 …
 } // namespace
-void translateLinkOnce( std::list< Declaration *> & translationUnit ) {
-        PassVisitor<LinkOnceVisitorCore> translator;
-        acceptAll( translationUnit, translator );
+}
 void translateLinkOnce( ast::TranslationUnit & translationUnit ) {
         ast::Pass<LinkOnceCore>::run( translationUnit );

src/CodeGen/LinkOnce.h

-              r0030b508
+              rfc12f05
 // for now its almost the only attribute we handle.
-#include <list>  // for list
-class Declaration;
 namespace ast {
         class TranslationUnit;
 …
 namespace CodeGen {
-void translateLinkOnce( std::list< Declaration *> & translationUnit );
 void translateLinkOnce( ast::TranslationUnit & translationUnit );
 /* Convert the cfa_linkonce attribute on top level declaration into

src/CodeGen/OperatorTable.cc

-              r0030b508
+              rfc12f05
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Feb 18 15:55:01 2020
 // Update Count     : 55
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Nov  3 16:00:00 2023
+// Update Count     : 56
 //
+#include <algorithm>  // for any_of
+#include <map>        // for map, _Rb_tree_const_iterator, map<>::const_iterator
+#include <utility>    // for pair
+using namespace std;
+#include "OperatorTable.h"
 #include "OperatorTable.h"
 #include "Common/utility.h"
+#include <cassert>         // for assert
+#include <unordered_map>   // for unordered_map
 namespace CodeGen {
-        const OperatorInfo CodeGen::tableValues[] = {
-                // inputName symbol   outputName                     friendlyName                  type
-                {       "?[?]",   "",     "_operator_index",             "Index",                      OT_INDEX          },
-                {       "?{}",    "=",    "_constructor",                "Constructor",                OT_CTOR           },
-                {       "^?{}",   "",     "_destructor",                 "Destructor",                 OT_DTOR           },
-                {       "?()",    "",     "_operator_call",              "Call Operator",              OT_CALL           },
-                {       "?++",    "++",   "_operator_postincr",          "Postfix Increment",          OT_POSTFIXASSIGN  },
-                {       "?--",    "--",   "_operator_postdecr",          "Postfix Decrement",          OT_POSTFIXASSIGN  },
-                {       "*?",     "*",    "_operator_deref",             "Dereference",                OT_PREFIX         },
-                {       "+?",     "+",    "_operator_unaryplus",         "Plus",                       OT_PREFIX         },
-                {       "-?",     "-",    "_operator_unaryminus",        "Minus",                      OT_PREFIX         },
-                {       "~?",     "~",    "_operator_bitnot",            "Bitwise Not",                OT_PREFIX         },
-                {       "!?",     "!",    "_operator_lognot",            "Logical Not",                OT_PREFIX         },
-                {       "++?",    "++",   "_operator_preincr",           "Prefix Increment",           OT_PREFIXASSIGN   },
-                {       "--?",    "--",   "_operator_predecr",           "Prefix Decrement",           OT_PREFIXASSIGN   },
-                {       "?\\?",   "\\",   "_operator_exponential",       "Exponentiation",             OT_INFIX          },
-                {       "?*?",    "*",    "_operator_multiply",          "Multiplication",             OT_INFIX          },
-                {       "?/?",    "/",    "_operator_divide",            "Division",                   OT_INFIX          },
-                {       "?%?",    "%",    "_operator_modulus",           "Modulo",                     OT_INFIX          },
-                {       "?+?",    "+",    "_operator_add",               "Addition",                   OT_INFIX          },
-                {       "?-?",    "-",    "_operator_subtract",          "Substraction",               OT_INFIX          },
-                {       "?<<?",   "<<",   "_operator_shiftleft",         "Shift Left",                 OT_INFIX          },
-                {       "?>>?",   ">>",   "_operator_shiftright",        "Shift Right",                OT_INFIX          },
-                {       "?<?",    "<",    "_operator_less",              "Less-than",                  OT_INFIX          },
-                {       "?>?",    ">",    "_operator_greater",           "Greater-than",               OT_INFIX          },
-                {       "?<=?",   "<=",   "_operator_lessequal",         "Less-than-or-Equal",         OT_INFIX          },
-                {       "?>=?",   ">=",   "_operator_greaterequal",      "Greater-than-or-Equal",      OT_INFIX          },
-                {       "?==?",   "==",   "_operator_equal",             "Equality",                   OT_INFIX          },
-                {       "?!=?",   "!=",   "_operator_notequal",          "Not-Equal",                  OT_INFIX          },
-                {       "?&?",    "&",    "_operator_bitand",            "Bitwise And",                OT_INFIX          },
-                {       "?^?",    "^",    "_operator_bitxor",            "Bitwise Xor",                OT_INFIX          },
-                {       "?|?",    "|",    "_operator_bitor",             "Bitwise Or",                 OT_INFIX          },
-                {       "?=?",    "=",    "_operator_assign",            "Assignment",                 OT_INFIXASSIGN    },
-                {       "?\\=?",  "\\=",  "_operator_expassign",         "Exponentiation Assignment",  OT_INFIXASSIGN    },
-                {       "?*=?",   "*=",   "_operator_multassign",        "Multiplication Assignment",  OT_INFIXASSIGN    },
-                {       "?/=?",   "/=",   "_operator_divassign",         "Division Assignment",        OT_INFIXASSIGN    },
-                {       "?%=?",   "%=",   "_operator_modassign",         "Modulo Assignment",          OT_INFIXASSIGN    },
-                {       "?+=?",   "+=",   "_operator_addassign",         "Addition Assignment",        OT_INFIXASSIGN    },
-                {       "?-=?",   "-=",   "_operator_subassign",         "Substrction Assignment",     OT_INFIXASSIGN    },
-                {       "?<<=?",  "<<=",  "_operator_shiftleftassign",   "Shift Left Assignment",      OT_INFIXASSIGN    },
-                {       "?>>=?",  ">>=",  "_operator_shiftrightassign",  "Shift Right Assignment",     OT_INFIXASSIGN    },
-                {       "?&=?",   "&=",   "_operator_bitandassign",      "Bitwise And Assignment",     OT_INFIXASSIGN    },
-                {       "?^=?",   "^=",   "_operator_bitxorassign",      "Bitwise Xor Assignment",     OT_INFIXASSIGN    },
-                {       "?|=?",   "|=",   "_operator_bitorassign",       "Bitwise Or Assignment",      OT_INFIXASSIGN    },
-        }; // tableValues
+        std::map< std::string, OperatorInfo > CodeGen::table;
+static const OperatorInfo tableValues[] = {
+        //  inputName symbol  outputName                     friendlyName                  type
+        {       "?[?]",   "",     "_operator_index",             "Index",                      OT_INDEX          },
+        {       "?{}",    "=",    "_constructor",                "Constructor",                OT_CTOR           },
+        {       "^?{}",   "",     "_destructor",                 "Destructor",                 OT_DTOR           },
+        {       "?()",    "",     "_operator_call",              "Call Operator",              OT_CALL           },
+        {       "?++",    "++",   "_operator_postincr",          "Postfix Increment",          OT_POSTFIXASSIGN  },
+        {       "?--",    "--",   "_operator_postdecr",          "Postfix Decrement",          OT_POSTFIXASSIGN  },
+        {       "*?",     "*",    "_operator_deref",             "Dereference",                OT_PREFIX         },
+        {       "+?",     "+",    "_operator_unaryplus",         "Plus",                       OT_PREFIX         },
+        {       "-?",     "-",    "_operator_unaryminus",        "Minus",                      OT_PREFIX         },
+        {       "~?",     "~",    "_operator_bitnot",            "Bitwise Not",                OT_PREFIX         },
+        {       "!?",     "!",    "_operator_lognot",            "Logical Not",                OT_PREFIX         },
+        {       "++?",    "++",   "_operator_preincr",           "Prefix Increment",           OT_PREFIXASSIGN   },
+        {       "--?",    "--",   "_operator_predecr",           "Prefix Decrement",           OT_PREFIXASSIGN   },
+        {       "?\\?",   "\\",   "_operator_exponential",       "Exponentiation",             OT_INFIX          },
+        {       "?*?",    "*",    "_operator_multiply",          "Multiplication",             OT_INFIX          },
+        {       "?/?",    "/",    "_operator_divide",            "Division",                   OT_INFIX          },
+        {       "?%?",    "%",    "_operator_modulus",           "Modulo",                     OT_INFIX          },
+        {       "?+?",    "+",    "_operator_add",               "Addition",                   OT_INFIX          },
+        {       "?-?",    "-",    "_operator_subtract",          "Substraction",               OT_INFIX          },
+        {       "?<<?",   "<<",   "_operator_shiftleft",         "Shift Left",                 OT_INFIX          },
+        {       "?>>?",   ">>",   "_operator_shiftright",        "Shift Right",                OT_INFIX          },
+        {       "?<?",    "<",    "_operator_less",              "Less-than",                  OT_INFIX          },
+        {       "?>?",    ">",    "_operator_greater",           "Greater-than",               OT_INFIX          },
+        {       "?<=?",   "<=",   "_operator_lessequal",         "Less-than-or-Equal",         OT_INFIX          },
+        {       "?>=?",   ">=",   "_operator_greaterequal",      "Greater-than-or-Equal",      OT_INFIX          },
+        {       "?==?",   "==",   "_operator_equal",             "Equality",                   OT_INFIX          },
+        {       "?!=?",   "!=",   "_operator_notequal",          "Not-Equal",                  OT_INFIX          },
+        {       "?&?",    "&",    "_operator_bitand",            "Bitwise And",                OT_INFIX          },
+        {       "?^?",    "^",    "_operator_bitxor",            "Bitwise Xor",                OT_INFIX          },
+        {       "?|?",    "|",    "_operator_bitor",             "Bitwise Or",                 OT_INFIX          },
+        {       "?=?",    "=",    "_operator_assign",            "Assignment",                 OT_INFIXASSIGN    },
+        {       "?\\=?",  "\\=",  "_operator_expassign",         "Exponentiation Assignment",  OT_INFIXASSIGN    },
+        {       "?*=?",   "*=",   "_operator_multassign",        "Multiplication Assignment",  OT_INFIXASSIGN    },
+        {       "?/=?",   "/=",   "_operator_divassign",         "Division Assignment",        OT_INFIXASSIGN    },
+        {       "?%=?",   "%=",   "_operator_modassign",         "Modulo Assignment",          OT_INFIXASSIGN    },
+        {       "?+=?",   "+=",   "_operator_addassign",         "Addition Assignment",        OT_INFIXASSIGN    },
+        {       "?-=?",   "-=",   "_operator_subassign",         "Substrction Assignment",     OT_INFIXASSIGN    },
+        {       "?<<=?",  "<<=",  "_operator_shiftleftassign",   "Shift Left Assignment",      OT_INFIXASSIGN    },
+        {       "?>>=?",  ">>=",  "_operator_shiftrightassign",  "Shift Right Assignment",     OT_INFIXASSIGN    },
+        {       "?&=?",   "&=",   "_operator_bitandassign",      "Bitwise And Assignment",     OT_INFIXASSIGN    },
+        {       "?^=?",   "^=",   "_operator_bitxorassign",      "Bitwise Xor Assignment",     OT_INFIXASSIGN    },
+        {       "?|=?",   "|=",   "_operator_bitorassign",       "Bitwise Or Assignment",      OT_INFIXASSIGN    },
+}; // tableValues
+        CodeGen::CodeGen() {
+                enum { numOps = sizeof( tableValues ) / sizeof( OperatorInfo ) };
+                for ( int i = 0; i < numOps; i += 1 ) {
+                        table[ tableValues[i].inputName ] = tableValues[i];
+                } // for
+enum { numOps = sizeof( tableValues ) / sizeof( OperatorInfo ) };
+const OperatorInfo * operatorLookup( const std::string & inputName ) {
+        // Static information set up:
+        static std::unordered_map<std::string, const OperatorInfo *> inputTable;
+        if ( inputTable.empty() ) for ( const OperatorInfo & op : tableValues ) {
+                inputTable[ op.inputName ] = &op;
+        }
+        const OperatorInfo * operatorLookup( const string & funcName ) {
+                if ( funcName.find_first_of( "?^*+-!", 0, 1 ) == string::npos ) return nullptr; // prefilter
+                const OperatorInfo * ret = &CodeGen::table.find( funcName )->second; // must be in the table
+                assert( ret );
+                return ret;
+        if ( inputName.find_first_of( "?^*+-!", 0, 1 ) == std::string::npos ) return nullptr; // prefilter
+        const OperatorInfo * ret = inputTable.find( inputName )->second;
+        // This can only happen if an invalid identifier name has been used.
+        assert( ret );
+        return ret;
+}
+bool isOperator( const std::string & inputName ) {
+        return operatorLookup( inputName ) != nullptr;
+}
+std::string operatorFriendlyName( const std::string & inputName ) {
+        const OperatorInfo * info = operatorLookup( inputName );
+        if ( info ) return info->friendlyName;
+        return "";
+}
+// This is only used in the demangler, so it is smaller (and only maybe slow).
+const OperatorInfo * operatorLookupByOutput( const std::string & outputName ) {
+        if ( '_' != outputName[0] ) return nullptr;
+        for ( const OperatorInfo & op : tableValues ) {
+                if ( outputName == op.outputName ) {
+                        return &op;
+                }
+        }
+        return nullptr;
+}
+        bool isOperator( const string & funcName ) {
+                return operatorLookup( funcName ) != nullptr;
+        }
+bool isConstructor( const std::string & inputName ) {
+        const OperatorInfo * info = operatorLookup( inputName );
+        if ( info ) return info->type == OT_CTOR;
+        return false;
+}
         string operatorFriendlyName( const string & funcName ) {
                 const OperatorInfo * info = operatorLookup( funcName );
                 if ( info ) return info->friendlyName;
                 return "";
+        }
+bool isDestructor( const std::string & inputName ) {
+        const OperatorInfo * info = operatorLookup( inputName );
+        if ( info ) return info->type == OT_DTOR;
+        return false;
+}
         bool isConstructor( const string & funcName ) {
                 const OperatorInfo * info = operatorLookup( funcName );
                 if ( info ) return info->type == OT_CTOR;
                 return false;
+        }
+bool isCtorDtor( const std::string & inputName ) {
+        const OperatorInfo * info = operatorLookup( inputName );
+        if ( info ) return info->type <= OT_CONSTRUCTOR;
+        return false;
+}
         bool isDestructor( const string & funcName ) {
                 const OperatorInfo * info = operatorLookup( funcName );
                 if ( info ) return info->type == OT_DTOR;
                 return false;
+        }
+bool isAssignment( const std::string & inputName ) {
+        const OperatorInfo * info = operatorLookup( inputName );
+        if ( info ) return info->type > OT_CONSTRUCTOR && info->type <= OT_ASSIGNMENT;
+        return false;
+}
         bool isCtorDtor( const string & funcName ) {
                 const OperatorInfo * info = operatorLookup( funcName );
                 if ( info ) return info->type <= OT_CONSTRUCTOR;
                 return false;
+        }
+bool isCtorDtorAssign( const std::string & inputName ) {
+        const OperatorInfo * info = operatorLookup( inputName );
+        if ( info ) return info->type <= OT_ASSIGNMENT;
+        return false;
+}
-        bool isAssignment( const string & funcName ) {
-                const OperatorInfo * info = operatorLookup( funcName );
-                if ( info ) return info->type > OT_CONSTRUCTOR && info->type <= OT_ASSIGNMENT;
-                return false;
+        }
-        bool isCtorDtorAssign( const string & funcName ) {
-                const OperatorInfo * info = operatorLookup( funcName );
-                if ( info ) return info->type <= OT_ASSIGNMENT;
-                return false;
+        }
-        CodeGen codegen;                                                                        // initialize singleton package
 } // namespace CodeGen

src/CodeGen/OperatorTable.h

-              r0030b508
+              rfc12f05
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 08:13:34 2020
 // Update Count     : 26
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Nov  3 14:53:00 2023
+// Update Count     : 27
 //
 …
 #include <string>
-#include <map>
 namespace CodeGen {
-        enum OperatorType {
-                OT_CTOR,
-                OT_DTOR,
-                OT_CONSTRUCTOR = OT_DTOR,
-                OT_PREFIXASSIGN,
-                OT_POSTFIXASSIGN,
-                OT_INFIXASSIGN,
-                OT_ASSIGNMENT = OT_INFIXASSIGN,
-                OT_CALL,
-                OT_PREFIX,
-                OT_INFIX,
-                OT_POSTFIX,
-                OT_INDEX,
-                OT_LABELADDRESS,
-                OT_CONSTANT
-        };
+        struct OperatorInfo {
+                std::string inputName;
+                std::string symbol;
+                std::string outputName;
+                std::string friendlyName;
+                OperatorType type;
+        };
+enum OperatorType {
+        OT_CTOR,
+        OT_DTOR,
+        OT_CONSTRUCTOR = OT_DTOR,
+        OT_PREFIXASSIGN,
+        OT_POSTFIXASSIGN,
+        OT_INFIXASSIGN,
+        OT_ASSIGNMENT = OT_INFIXASSIGN,
+        OT_CALL,
+        OT_PREFIX,
+        OT_INFIX,
+        OT_POSTFIX,
+        OT_INDEX,
+        OT_LABELADDRESS,
+        OT_CONSTANT
+};
+        class CodeGen {
+                friend const OperatorInfo * operatorLookup( const std::string & funcName );
+struct OperatorInfo {
+        // The Cforall special function name.
+        std::string inputName;
+        // The string used when the operator is used as an operator.
+        std::string symbol;
+        // The base name used in the mangled name.
+        std::string outputName;
+        // Human-readable name of the operator.
+        std::string friendlyName;
+        // The type of operator shows how it is used as an operator.
+        OperatorType type;
+};
+                static const OperatorInfo tableValues[];
+                static std::map< std::string, OperatorInfo > table;
+          public:
+                CodeGen();
+        }; // CodeGen
+// Look up the operator (by inputName), return nullptr if no such operator.
+const OperatorInfo * operatorLookup( const std::string & inputName );
+// Is there an operator with this name?
+bool isOperator( const std::string & inputName );
+// Get the friendlyName of the operator with the inputName
+std::string operatorFriendlyName( const std::string & inputName );
+// Get the OperatorInfo with the given outputName, if one exists.
+const OperatorInfo * operatorLookupByOutput( const std::string & outputName );
+        bool isOperator( const std::string & funcName );
+        const OperatorInfo * operatorLookup( const std::string & funcName );
+        std::string operatorFriendlyName( const std::string & funcName );
+// Is the operator a constructor, destructor or any form of assignment.
+// (Last two are "or" combinations of the first three.)
+bool isConstructor( const std::string & );
+bool isDestructor( const std::string & );
+bool isAssignment( const std::string & );
+bool isCtorDtor( const std::string & );
+bool isCtorDtorAssign( const std::string & );
-        bool isConstructor( const std::string & );
-        bool isDestructor( const std::string & );
-        bool isAssignment( const std::string & );
-        bool isCtorDtor( const std::string & );
-        bool isCtorDtorAssign( const std::string & );
 } // namespace CodeGen

src/CodeGen/module.mk

-              r0030b508
+              rfc12f05
 SRC_CODEGEN = \
+        CodeGen/FixMain2.cc \
+        CodeGen/FixMain.h \
+        CodeGen/CodeGeneratorNew.cpp \
+        CodeGen/CodeGeneratorNew.hpp \
+        CodeGen/GenType.cc \
+        CodeGen/GenType.h \
         CodeGen/OperatorTable.cc \
         CodeGen/OperatorTable.h
 SRC += $(SRC_CODEGEN) \
-        CodeGen/CodeGenerator.cc \
-        CodeGen/CodeGenerator.h \
         CodeGen/Generate.cc \
         CodeGen/Generate.h \
         CodeGen/FixMain.cc \
+        CodeGen/FixMain.h \
         CodeGen/FixNames.cc \
         CodeGen/FixNames.h \
-        CodeGen/GenType.cc \
-        CodeGen/GenType.h \
         CodeGen/LinkOnce.cc \
         CodeGen/LinkOnce.h \

src/Common/CodeLocationTools.cpp

r0030b508	rfc12f05
138	138	macro(MutexStmt, Stmt) \
139	139	macro(CorunStmt, Stmt) \
	140	macro(CoforStmt, Stmt) \
140	141	macro(ApplicationExpr, Expr) \
141	142	macro(UntypedExpr, Expr) \

src/Common/Eval.cc

-              r0030b508
+              rfc12f05
 #include "AST/Inspect.hpp"
-#include "Common/PassVisitor.h"
 #include "CodeGen/OperatorTable.h"                                              // access: OperatorInfo
 #include "AST/Pass.hpp"
 #include "InitTweak/InitTweak.h"
+#include "SynTree/Expression.h"
+//-------------------------------------------------------------
+// Old AST
+struct EvalOld : public WithShortCircuiting {
+        long long int value = 0;                                                        // compose the result of the constant expression
+        bool valid = true;                                                                      // true => constant expression and value is the result
+                                                                                                                // false => not constant expression, e.g., ++i
+        bool cfavalid = true;                                                           // true => constant expression and value computable
+                                                                                                                // false => constant expression but value not computable, e.g., sizeof(int)
+        void previsit( const BaseSyntaxNode * ) { visit_children = false; }
+        void postvisit( const BaseSyntaxNode * ) { valid = false; }
+        void postvisit( const SizeofExpr * ) {
+        }
+        void postvisit( const ConstantExpr * expr ) {
+                value = expr->intValue();
+        }
+        void postvisit( const CastExpr * expr ) {
+                auto arg = eval(expr->arg);
+                valid = arg.second;
+                value = arg.first;
+                // TODO: perform type conversion on value if valid
+        }
+        void postvisit( const VariableExpr * const expr ) {
+                if ( EnumInstType * inst = dynamic_cast<EnumInstType *>(expr->result) ) {
+                        if ( EnumDecl * decl = inst->baseEnum ) {
+                                if ( decl->valueOf( expr->var, value ) ) { // value filled by valueOf
+                                        return;
+                                }
+                        }
+                }
+                valid = false;
+        }
+        void postvisit( const ApplicationExpr * expr ) {
+                DeclarationWithType * function = InitTweak::getFunction(const_cast<ApplicationExpr *>(expr));
+                if ( ! function || function->linkage != LinkageSpec::Intrinsic ) { valid = false; return; }
+                const std::string & fname = function->name;
+                assertf( expr->args.size() == 1 || expr->args.size() == 2, "Intrinsic function with %zd arguments: %s", expr->args.size(), fname.c_str() );
+                std::pair<long long int, bool> arg1, arg2;
+                arg1 = eval(expr->args.front());
+                valid = valid && arg1.second;
+                if ( ! valid ) return;
+                if ( expr->args.size() == 2 ) {
+                        arg2 = eval(expr->args.back());
+                        valid = valid && arg2.second;
+                        if ( ! valid ) return;
+                }
+                if (fname == "?+?") {
+                        value = arg1.first + arg2.first;
+                } else if (fname == "?-?") {
+                        value = arg1.first - arg2.first;
+                } else if (fname == "?*?") {
+                        value = arg1.first * arg2.first;
+                } else if (fname == "?/?") {
+                        value = arg1.first / arg2.first;
+                } else if (fname == "?%?") {
+                        value = arg1.first % arg2.first;
+                } else {
+                        valid = false;
+                }
+                // TODO: implement other intrinsic functions
+        }
+};
+//-------------------------------------------------------------
+// New AST
 struct EvalNew : public ast::WithShortCircuiting {
         Evaluation result = { 0, true, true };
 …
 };
-std::pair<long long int, bool> eval( const Expression * expr ) {
-        PassVisitor<EvalOld> ev;
-        if ( expr ) {
-                expr->accept( ev );
-                return std::make_pair( ev.pass.value, ev.pass.valid );
-        } else {
-                return std::make_pair( 0, false );
+        }
+}
 Evaluation eval( const ast::Expr * expr ) {
         if ( expr ) {

src/Common/Eval.h

r0030b508	rfc12f05
30	30
31	31	/// Evaluates expr as a long long int.
32		~~/// If second is false, expr could not be evaluated.~~
33		~~std::pair<long long int, bool> eval(const Expression * expr);~~
34	32	Evaluation eval(const ast::Expr * expr);
35	33

src/Common/Examine.cc

-              r0030b508
+              rfc12f05
 #include "CodeGen/OperatorTable.h"
 #include "InitTweak/InitTweak.h"
-DeclarationWithType * isMainFor( FunctionDecl * func, AggregateDecl::Aggregate kind ) {
-        if (func->name != "main") return nullptr;
-        if (func->type->parameters.size() != 1) return nullptr;
-        auto param = func->type->parameters.front();
-        auto type = dynamic_cast<ReferenceType * >(param->get_type());
-        if (!type) return nullptr;
-        auto obj = dynamic_cast<StructInstType *>(type->base);
-        if (!obj) return nullptr;
-        if (kind != obj->baseStruct->kind) return nullptr;
-        return param;
+}
 namespace {
 …
 namespace {
-        Type * getDestructorParam( FunctionDecl * func ) {
-                if ( !CodeGen::isDestructor( func->name ) ) return nullptr;
-                auto params = func->type->parameters;
-                if ( 1 != params.size() ) return nullptr;
-                auto ref = dynamic_cast<ReferenceType *>( params.front()->get_type() );
-                if ( ref ) {
-                        return ref->base;
+                }
-                return nullptr;
+        }
 const ast::Type * getDestructorParam( const ast::FunctionDecl * func ) {
 …
+}
+}
-bool isDestructorFor( FunctionDecl * func, StructDecl * type_decl ) {
-        if ( Type * type = getDestructorParam( func ) ) {
-                auto stype = dynamic_cast<StructInstType *>( type );
-                return stype && stype->baseStruct == type_decl;
+        }
-        return false;
+}

src/Common/Examine.h

-              r0030b508
+              rfc12f05
 #include "AST/Decl.hpp"
-#include "SynTree/Declaration.h"
 /// Check if this is a main function for a type of an aggregate kind.
-DeclarationWithType * isMainFor( FunctionDecl * func, AggregateDecl::Aggregate kind );
 const ast::DeclWithType * isMainFor(
         const ast::FunctionDecl * func, ast::AggregateDecl::Aggregate kind );
 …
 /// Check if this function is a destructor for the given structure.
-bool isDestructorFor( FunctionDecl * func, StructDecl * type_decl );
 bool isDestructorFor(
         const ast::FunctionDecl * func, const ast::StructDecl * type );

src/Common/UniqueName.cc

-              r0030b508
+              rfc12f05
 // file "LICENCE" distributed with Cforall.
 //
 // UniqueName.cc --
+// UniqueName.cc -- Create a unique variants of a base name with a counter.
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jun  8 14:47:49 2015
 // Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Nov  7 15:04:00 2023
+// Update Count     : 4
 //
+#include <string>
+#include <sstream>
+#include "UniqueName.h"
 #include "UniqueName.h"
+#include "Common/ToString.hpp"
 UniqueName::UniqueName( const std::string &base ) : base( base ), count( 0 ) {
 …
 std::string UniqueName::newName( const std::string &additional ) {
+        std::ostringstream os;
+        os << base << additional << count++;
+        return os.str();
+        return toString( base, additional, count++ );
+}

src/Common/UniqueName.h

-              r0030b508
+              rfc12f05
 // file "LICENCE" distributed with Cforall.
 //
 // UniqueName.h --
+// UniqueName.h -- Create a unique variants of a base name with a counter.
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:18:45 2017
 // Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Nov  7 15:00:00 2023
+// Update Count     : 3
 //
 …
 class UniqueName {
   public:
         UniqueName( const std::string &base = "" );
+public:
+        UniqueName( const std::string &base );
         std::string newName( const std::string &additional = "" );
   private:
+private:
         std::string base;
         int count;

src/Common/module.mk

-              r0030b508
+              rfc12f05
         Common/Indenter.cc \
         Common/Iterate.hpp \
-        Common/PassVisitor.cc \
-        Common/PassVisitor.h \
-        Common/PassVisitor.impl.h \
-        Common/PassVisitor.proto.h \
         Common/PersistentMap.h \
         Common/ResolvProtoDump.hpp \

src/Concurrency/Corun.cpp

-              r0030b508
+              rfc12f05
 struct CorunKeyword : public WithDeclsToAdd<>, public WithStmtsToAdd<> {
     UniqueName CorunFnNamer = "__CFA_corun_lambda_"s;
+    UniqueName CoforFnNamer = "__CFA_cofor_lambda_"s;
+    // UniqueName CoforFnVarNamer = "__CFA_cofor_lambda_var"s;
     UniqueName RunnerBlockNamer = "__CFA_corun_block_"s;
+    string coforArgName = "__CFA_cofor_lambda_arg";
+    string numProcsName = "__CFA_cofor_num_procs";
+    string currProcsName = "__CFA_cofor_curr_procs";
+    string thdArrName = "__CFA_cofor_thread_array";
+    string loopTempName = "__CFA_cofor_loop_temp";
     const StructDecl * runnerBlockDecl = nullptr;
+    // Finds select_node decl
+    const StructDecl * coforRunnerDecl = nullptr;
+    // Finds runner_block (corun task) and cofor_runner (cofor task) decls
     void previsit( const StructDecl * decl ) {
         if ( !decl->body ) {
 …
             assert( !runnerBlockDecl );
             runnerBlockDecl = decl;
+        } else if ( "cofor_runner" == decl->name ) {
+            assert( !coforRunnerDecl );
+            coforRunnerDecl = decl;
+        }
+    }
+    // codegen for cofor statements
+    Stmt * postvisit( const CoforStmt * stmt ) {
+        if ( !runnerBlockDecl || !coforRunnerDecl )
+            SemanticError( stmt->location, "To use cofor statements add #include <cofor.hfa>\n" );
+        if ( stmt->inits.size() != 1 )
+            SemanticError( stmt->location, "Cofor statements must have a single initializer in the loop control\n" );
+        if ( !stmt->body )
+            return nullptr;
+        const CodeLocation & loc = stmt->location;
+        const string fnName = CoforFnNamer.newName();
+        CompoundStmt * body = new CompoundStmt( loc );
+        // push back cofor initializer to generated body
+        body->push_back( deepCopy( stmt->inits.at(0) ) );
+        CompoundStmt * fnBody = new CompoundStmt( loc );
+        const DeclStmt * declStmtPtr = dynamic_cast<const DeclStmt *>(stmt->inits.at(0).get());
+        if ( ! declStmtPtr )
+            SemanticError( stmt->location, "Cofor statement initializer is somehow not a decl statement?\n" );
+        const Decl * declPtr = dynamic_cast<const Decl *>(declStmtPtr->decl.get());
+        if ( ! declPtr )
+            SemanticError( stmt->location, "Cofor statement initializer is somehow not a decl?\n" );
+        Type * initType = new TypeofType( new NameExpr( loc, declPtr->name ) );
+        // Generates:
+        // typeof(init) __CFA_cofor_lambda_var = *((typeof(init) *)val);
+        fnBody->push_back( new DeclStmt( loc,
+            new ObjectDecl( loc,
+                declPtr->name,
+                initType,
+                new SingleInit( loc,
+                    UntypedExpr::createDeref( loc,
+                        new CastExpr( loc,
+                            new NameExpr( loc, coforArgName ),
+                            new PointerType( initType ), ExplicitCast
+                        )
+                    )
+                )
+            )
+        ));
+        // push rest of cofor body into loop lambda
+        fnBody->push_back( deepCopy( stmt->body ) );
+        // Generates:
+        // void __CFA_cofor_lambda_() {
+        //    typeof(init) __CFA_cofor_lambda_var = *((typeof(init) *)val);
+        //    stmt->body;
+        // }
+        Stmt * coforLambda = new DeclStmt( loc,
+            new FunctionDecl( loc,
+                fnName,                                             // name
+                {},                                                 // forall
+                {
+                    new ObjectDecl( loc,
+                        coforArgName,
+                        new ast::PointerType( new ast::VoidType() )
+                    )
+                },                                                  // params
+                {},                                                 // return
+                fnBody   // body
+            )
+        );
+        body->push_back( coforLambda );
+        // Generates:
+        // unsigned __CFA_cofor_num_procs = get_proc_count();
+        body->push_back( new DeclStmt( loc,
+                new ObjectDecl( loc,
+                    numProcsName,
+                    new BasicType( BasicType::Kind::UnsignedInt ),
+                    new SingleInit( loc,
+                        new UntypedExpr( loc,
+                            new NameExpr( loc, "get_proc_count" ),
+                            {}
+                        )
+                    )
+                )
+            )
+        );
+        // Generates:
+        // unsigned __CFA_cofor_curr_procs = 0;
+        body->push_back( new DeclStmt( loc,
+                new ObjectDecl( loc,
+                    currProcsName,
+                    new BasicType( BasicType::Kind::UnsignedInt ),
+                    new SingleInit( loc, ConstantExpr::from_int( loc, 0 ) )
+                )
+            )
+        );
+        // Generates:
+        // unsigned cofor_runner __CFA_cofor_thread_array[nprocs];
+        body->push_back( new DeclStmt( loc,
+                new ObjectDecl( loc,
+                    thdArrName,
+                    new ast::ArrayType(
+                        new StructInstType( coforRunnerDecl ),
+                        new NameExpr( loc, numProcsName ),
+                        ast::FixedLen,
+                        ast::DynamicDim
+                    )
+                )
+            )
+        );
+        // Generates:
+        // start_runners( __CFA_cofor_thread_array, __CFA_cofor_num_procs, __CFA_cofor_lambda_ );
+        body->push_back( new ExprStmt( loc,
+            new UntypedExpr( loc,
+                new NameExpr( loc, "start_runners" ),
+                {
+                    new NameExpr( loc, thdArrName ),
+                    new NameExpr( loc, numProcsName ),
+                    new NameExpr( loc, fnName )
+                }
+            )
+        ));
+        // Generates:
+        // typeof(initializer) * __CFA_cofor_loop_temp = malloc();
+        CompoundStmt * forLoopBody = new CompoundStmt( loc );
+        forLoopBody->push_back( new DeclStmt( loc,
+                new ObjectDecl( loc,
+                    loopTempName,
+                    new PointerType( initType ),
+                    new SingleInit( loc,
+                        new UntypedExpr( loc,
+                            new NameExpr( loc, "malloc" ),
+                            {}
+                        )
+                    )
+                )
+            )
+        );
+        // Generates:
+        // *__CFA_cofor_loop_temp = initializer;
+        forLoopBody->push_back( new ExprStmt( loc,
+            UntypedExpr::createAssign( loc,
+                UntypedExpr::createDeref( loc, new NameExpr( loc, loopTempName ) ),
+                new NameExpr( loc, declPtr->name )
+            )
+        ));
+        // Generates:
+        // send_work( __CFA_cofor_thread_array, __CFA_cofor_num_procs,
+        //     __CFA_cofor_curr_procs, __CFA_cofor_loop_temp );
+        forLoopBody->push_back( new ExprStmt( loc,
+            new UntypedExpr( loc,
+                new NameExpr( loc, "send_work" ),
+                {
+                    new NameExpr( loc, thdArrName ),
+                    new NameExpr( loc, numProcsName ),
+                    new NameExpr( loc, currProcsName ),
+                    new NameExpr( loc, loopTempName )
+                }
+            )
+        ));
+        body->push_back( new ForStmt( loc,
+            {},
+            deepCopy( stmt->cond ),
+            deepCopy( stmt->inc ),
+            forLoopBody
+        ));
+        // Generates:
+        // end_runners( __CFA_cofor_thread_array, __CFA_cofor_num_procs );
+        body->push_back( new ExprStmt( loc,
+            new UntypedExpr( loc,
+                new NameExpr( loc, "end_runners" ),
+                {
+                    new NameExpr( loc, thdArrName ),
+                    new NameExpr( loc, numProcsName )
+                }
+            )
+        ));
+        return body;
+    }
+    // codegen for corun statements
     Stmt * postvisit( const CorunStmt * stmt ) {
         if ( !runnerBlockDecl )
+        if ( !runnerBlockDecl || !coforRunnerDecl )
             SemanticError( stmt->location, "To use corun statements add #include <cofor.hfa>\n" );

src/Concurrency/module.mk

-              r0030b508
+              rfc12f05
         Concurrency/Corun.hpp \
         Concurrency/KeywordsNew.cpp \
-        Concurrency/Keywords.cc \
         Concurrency/Keywords.h \
         Concurrency/WaitforNew.cpp \
-        Concurrency/Waitfor.cc \
         Concurrency/Waitfor.h \
         Concurrency/Waituntil.cpp \

src/ControlStruct/module.mk

-              r0030b508
+              rfc12f05
 SRC += \
-        ControlStruct/ExceptDecl.cc \
         ControlStruct/ExceptDeclNew.cpp \
         ControlStruct/ExceptDecl.h \
         ControlStruct/ExceptTranslateNew.cpp \
-        ControlStruct/ExceptTranslate.cc \
         ControlStruct/ExceptTranslate.h \
         ControlStruct/FixLabels.cpp \
         ControlStruct/FixLabels.hpp \
-        ControlStruct/ForExprMutator.cc \
-        ControlStruct/ForExprMutator.h \
         ControlStruct/HoistControlDecls.cpp \
         ControlStruct/HoistControlDecls.hpp \
-        ControlStruct/LabelFixer.cc \
-        ControlStruct/LabelFixer.h \
-        ControlStruct/LabelGenerator.cc \
-        ControlStruct/LabelGenerator.h \
         ControlStruct/LabelGeneratorNew.cpp \
         ControlStruct/LabelGeneratorNew.hpp \
-        ControlStruct/MLEMutator.cc \
-        ControlStruct/MLEMutator.h \
         ControlStruct/MultiLevelExit.cpp \
+        ControlStruct/MultiLevelExit.hpp \
+        ControlStruct/Mutate.cc \
+        ControlStruct/Mutate.h
+        ControlStruct/MultiLevelExit.hpp

src/GenPoly/BoxNew.cpp

-              r0030b508
+              rfc12f05
 namespace {
-/// Common field of several sub-passes of box.
-struct BoxPass {
-        TypeVarMap scopeTypeVars;
-        BoxPass() : scopeTypeVars( ast::TypeData() ) {}
-};
-// TODO: Could this be a common helper somewhere?
-ast::FunctionType * makeFunctionType( ast::FunctionDecl const * decl ) {
-        ast::FunctionType * type = new ast::FunctionType(
-                decl->type->isVarArgs, decl->type->qualifiers
-        );
-        for ( auto type_param : decl->type_params ) {
-                type->forall.emplace_back( new ast::TypeInstType( type_param ) );
+        }
-        for ( auto assertion : decl->assertions ) {
-                type->assertions.emplace_back( new ast::VariableExpr(
-                        assertion->location, assertion ) );
+        }
-        for ( auto param : decl->params ) {
-                type->params.emplace_back( param->get_type() );
+        }
-        for ( auto retval : decl->returns ) {
-                type->returns.emplace_back( retval->get_type() );
+        }
-        return type;
+}
 // --------------------------------------------------------------------------
 …
 /// * Adds appropriate type variables to the function calls.
 struct CallAdapter final :
-                public BoxPass,
                 public ast::WithConstTypeSubstitution,
                 public ast::WithGuards,
 …
         ast::Expr const * postvisit( ast::AddressExpr const * expr );
         ast::ReturnStmt const * previsit( ast::ReturnStmt const * stmt );
-        void previsit( ast::PointerType const * type );
-        void previsit( ast::FunctionType const * type );
         void beginScope();
 …
                 CodeLocation const & location, ast::Type const * type );
         /// Set of adapter functions in the current scope.
+        TypeVarMap scopeTypeVars;
         ScopedMap< std::string, ast::DeclWithType const * > adapters;
         std::map< ast::ApplicationExpr const *, ast::Expr const * > retVals;
 …
 ast::FunctionDecl const * CallAdapter::previsit( ast::FunctionDecl const * decl ) {
+        // Prevent type declaration information from leaking out.
+        GuardScope( scopeTypeVars );
         if ( nullptr == decl->stmts ) {
-                // This may keep TypeDecls we don't ever want from sneaking in.
-                // Not visiting child nodes might just be faster.
-                GuardScope( scopeTypeVars );
                 return decl;
+        }
-        GuardScope( scopeTypeVars );
         GuardValue( retval );
 …
         ptrdiff_t initArgCount = mutExpr->args.size();
         TypeVarMap exprTypeVars = { ast::TypeData() };
+        TypeVarMap exprTypeVars;
         // TODO: Should this take into account the variables already bound in
         // scopeTypeVars ([ex] remove them from exprTypeVars)?
 …
         assert( typeSubs );
-        ast::Type const * concRetType = replaceWithConcrete( dynRetType, *typeSubs );
-        // Used to use dynRetType instead of concRetType; this changed so that
-        // the correct type parameters are passed for return types (it should be
-        // the concrete type's parameters, not the formal type's).
         ast::vector<ast::Expr>::iterator argIt =
                 passTypeVars( mutExpr, function );
 …
+        }
         return stmt;
+}
-void CallAdapter::previsit( ast::PointerType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+}
-void CallAdapter::previsit( ast::FunctionType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+}
 …
 ast::FunctionDecl const * DeclAdapter::previsit( ast::FunctionDecl const * decl ) {
         TypeVarMap localTypeVars = { ast::TypeData() };
+        TypeVarMap localTypeVars;
         makeTypeVarMap( decl, localTypeVars );
 …
                         layoutParams.emplace_back( alignParam );
+                }
+                // TODO: These should possibly all be gone.
+                // More all assertions into parameter list.
+                for ( ast::ptr<ast::DeclWithType> & assert : mutParam->assertions ) {
+                        // Assertion parameters may not be used in body,
+                        // pass along with unused attribute.
+                        assert.get_and_mutate()->attributes.push_back(
+                                new ast::Attribute( "unused" ) );
+                        inferredParams.push_back( assert );
+                }
+                mutParam->assertions.clear();
+                // Assertions should be stored in the main list.
+                assert( mutParam->assertions.empty() );
                 typeParam = mutParam;
+        }
-        // TODO: New version of inner loop.
         for ( ast::ptr<ast::DeclWithType> & assert : mutDecl->assertions ) {
                 // Assertion parameters may not be used in body,
 …
         spliceBegin( mutDecl->params, layoutParams );
         addAdapters( mutDecl, localTypeVars );
+        // Now have to update the type to match the declaration.
+        ast::FunctionType * type = new ast::FunctionType(
+                mutDecl->type->isVarArgs, mutDecl->type->qualifiers );
+        for ( auto type_param : mutDecl->type_params ) {
+                type->forall.emplace_back( new ast::TypeInstType( type_param ) );
+        }
+        for ( auto param : mutDecl->params ) {
+                type->params.emplace_back( param->get_type() );
+        }
+        for ( auto retval : mutDecl->returns ) {
+                type->returns.emplace_back( retval->get_type() );
+        }
+        mutDecl->type = type;
         return mutDecl;
 …
+                }
+        }
-        // TODO: Can this be updated as we go along?
-        mutDecl->type = makeFunctionType( mutDecl );
         return mutDecl;
+}
 …
         assertf( it != adapters.end(), "Could not correct floating node." );
         return ast::mutate_field( expr, &ast::VariableExpr::var, it->second );
+}
 …
 /// * Inserts dynamic calculation of polymorphic type layouts where needed.
 struct PolyGenericCalculator final :
-                public BoxPass,
                 public ast::WithConstTypeSubstitution,
                 public ast::WithDeclsToAdd<>,
 …
         PolyGenericCalculator();
-        void previsit( ast::ObjectDecl const * decl );
         void previsit( ast::FunctionDecl const * decl );
         void previsit( ast::TypedefDecl const * decl );
 …
         ast::StructDecl const * previsit( ast::StructDecl const * decl );
         ast::UnionDecl const * previsit( ast::UnionDecl const * decl );
-        void previsit( ast::PointerType const * type );
-        void previsit( ast::FunctionType const * type );
         ast::DeclStmt const * previsit( ast::DeclStmt const * stmt );
         ast::Expr const * postvisit( ast::MemberExpr const * expr );
 …
         /// C sizeof().
         ast::Expr const * genSizeof( CodeLocation const &, ast::Type const * );
         /// Enters a new scope for type-variables,
         /// adding the type variables from the provided type.
         void beginTypeScope( ast::Type const * );
+        /// Enters a new scope for known layouts and offsets, and queues exit calls.
         void beginGenericScope();
+        /// The type variables and polymorphic parameters currently in scope.
+        TypeVarMap scopeTypeVars;
         /// Set of generic type layouts known in the current scope,
         /// indexed by sizeofName.
 …
         /// If the argument of an AddressExpr is MemberExpr, it is stored here.
         ast::MemberExpr const * addrMember = nullptr;
-        /// Used to avoid recursing too deep in type declarations.
-        bool expect_func_type = false;
 };
 …
+}
-void PolyGenericCalculator::previsit( ast::ObjectDecl const * decl ) {
-        beginTypeScope( decl->type );
+}
 void PolyGenericCalculator::previsit( ast::FunctionDecl const * decl ) {
         beginGenericScope();
+        GuardScope( *this );
         beginTypeScope( decl->type );
+}
 …
                 ast::TypeDecl const * decl ) {
         ast::Type const * base = decl->base;
         if ( nullptr == base) return decl;
+        if ( nullptr == base ) return decl;
         // Add size/align variables for opaque type declarations.
 …
         alignDecl->accept( *visitor );
         // Can't use [makeVar], because it inserts into stmtsToAdd and TypeDecls
         // can occur at global scope.
+        // A little trick to replace this with two declarations.
+        // Adding after makes sure that there is no conflict with adding stmts.
         declsToAddAfter.push_back( alignDecl );
-        // replace with sizeDecl.
         return sizeDecl;
+}
 …
+}
-void PolyGenericCalculator::previsit( ast::PointerType const * type ) {
-        beginTypeScope( type );
+}
-void PolyGenericCalculator::previsit( ast::FunctionType const * type ) {
-        beginTypeScope( type );
-        GuardValue( expect_func_type );
-        GuardScope( *this );
-        // The other functions type we will see in this scope are probably
-        // function parameters they don't help us with the layout and offsets so
-        // don't mark them as known in this scope.
-        expect_func_type = false;
+}
-//void PolyGenericCalculator::previsit( ast::DeclStmt const * stmt ) {
 ast::DeclStmt const * PolyGenericCalculator::previsit( ast::DeclStmt const * stmt ) {
         ast::ObjectDecl const * decl = stmt->decl.as<ast::ObjectDecl>();
 …
         // Change initialization of a polymorphic value object to allocate via a
+        // variable-length-array (alloca was previouly used, but it cannot be
+        // safely used in loops).
+        // variable-length-array (alloca cannot be safely used in loops).
         ast::ObjectDecl * newBuf = new ast::ObjectDecl( decl->location,
                 bufNamer.newName(),
 …
+}
-void PolyGenericCalculator::beginGenericScope() {
-        GuardScope( *this );
-        // We expect the first function type see to be the type relating to this
-        // scope but any further type is probably some unrelated function pointer
-        // keep track of whrich is the first.
-        GuardValue( expect_func_type ) = true;
+}
 // --------------------------------------------------------------------------
 /// No common theme found.
+/// Removes unneeded or incorrect type information.
 /// * Replaces initialization of polymorphic values with alloca.
 /// * Replaces declaration of dtype/ftype with appropriate void expression.
 …
 /// * Strips fields from generic structure declarations.
 struct Eraser final :
-                public BoxPass,
                 public ast::WithGuards {
         void guardTypeVarMap( ast::Type const * type ) {
 …
         void previsit( ast::PointerType const * type );
         void previsit( ast::FunctionType const * type );
+public:
+        TypeVarMap scopeTypeVars;
 };

src/GenPoly/FindFunction.cc

-              r0030b508
+              rfc12f05
 #include "AST/Pass.hpp"                 // for Pass
 #include "AST/Type.hpp"
-#include "Common/PassVisitor.h"         // for PassVisitor
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
 #include "GenPoly/GenPoly.h"            // for TyVarMap
 #include "ScrubTyVars.h"                // for ScrubTyVars
-#include "SynTree/Declaration.h"        // for DeclarationWithType, TypeDecl
-#include "SynTree/Mutator.h"            // for Mutator, mutateAll
-#include "SynTree/Type.h"               // for FunctionType, Type, Type::For...
 namespace GenPoly {
-        class FindFunction : public WithGuards, public WithVisitorRef<FindFunction>, public WithShortCircuiting {
-          public:
-                FindFunction( std::list< FunctionType const* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate );
-                void premutate( FunctionType * functionType );
-                Type * postmutate( FunctionType * functionType );
-                void premutate( PointerType * pointerType );
-          private:
-                void handleForall( const Type::ForallList &forall );
-                std::list< FunctionType const * > & functions;
-                TyVarMap tyVars;
-                bool replaceMode;
-                FindFunctionPredicate predicate;
-        };
-        void findFunction( Type *type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
-                PassVisitor<FindFunction> finder( functions, tyVars, false, predicate );
-                type->acceptMutator( finder );
+        }
-        void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
-                PassVisitor<FindFunction> finder( functions, tyVars, true, predicate );
-                type = type->acceptMutator( finder );
+        }
-        FindFunction::FindFunction( std::list< FunctionType const * > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate )
-                : functions( functions ), tyVars( tyVars ), replaceMode( replaceMode ), predicate( predicate ) {
+        }
-        void FindFunction::handleForall( const Type::ForallList &forall ) {
-                for ( const Declaration * td : forall ) {
-                        TyVarMap::iterator var = tyVars.find( td->name );
-                        if ( var != tyVars.end() ) {
-                                tyVars.erase( var->first );
-                        } // if
-                } // for
+        }
-        void FindFunction::premutate( FunctionType * functionType ) {
-                visit_children = false;
-                GuardScope( tyVars );
-                handleForall( functionType->get_forall() );
-                mutateAll( functionType->get_returnVals(), *visitor );
+        }
-        Type * FindFunction::postmutate( FunctionType * functionType ) {
-                Type *ret = functionType;
-                if ( predicate( functionType, tyVars ) ) {
-                        functions.push_back( functionType );
-                        if ( replaceMode ) {
-                                // replace type parameters in function type with void*
-                                ret = ScrubTyVars::scrub( functionType->clone(), tyVars );
-                        } // if
-                } // if
-                return ret;
+        }
-        void FindFunction::premutate( PointerType * pointerType ) {
-                GuardScope( tyVars );
-                handleForall( pointerType->get_forall() );
+        }
 namespace {
 …
 void FindFunctionCore::previsit( ast::PointerType const * /*type*/ ) {
         GuardScope( typeVars );
-        //handleForall( type->forall );
+}
 …
         ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, false );
         type->accept( pass );
-        //(void)type;
-        //(void)functions;
-        //(void)typeVars;
-        //(void)predicate;
+}
 …
         ast::Pass<FindFunctionCore> pass( functions, typeVars, predicate, true );
         return type->accept( pass );
-        //(void)functions;
-        //(void)typeVars;
-        //(void)predicate;
-        //return type;
+}

src/GenPoly/FindFunction.h

-              r0030b508
+              rfc12f05
 #pragma once
-#include <list>       // for list
 #include "GenPoly.h"  // for TyVarMap
-class FunctionType;
-class Type;
 namespace GenPoly {
-        typedef bool (*FindFunctionPredicate)( FunctionType*, const TyVarMap& );
-        /// recursively walk `type`, placing all functions that match `predicate` under `tyVars` into `functions`
-        void findFunction( Type *type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
-        /// like `findFunction`, but also replaces the function type with void ()(void)
-        void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
 typedef bool (*FindFunctionPred)( const ast::FunctionType *, const TypeVarMap & );

src/GenPoly/GenPoly.cc

-              r0030b508
+              rfc12f05
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::const_it...
 #include "ResolvExpr/typeops.h"         // for flatten
-#include "SynTree/Constant.h"           // for Constant
-#include "SynTree/Expression.h"         // for Expression, TypeExpr, Constan...
-#include "SynTree/Type.h"               // for Type, StructInstType, UnionIn...
-#include "SynTree/TypeSubstitution.h"   // for TypeSubstitution
 using namespace std;
 …
         namespace {
                 /// Checks a parameter list for polymorphic parameters; will substitute according to env if present
-                bool hasPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( isPolyType( paramType->get_type(), env ) ) return true;
+                        }
-                        return false;
+                }
                 bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env ) {
                         for ( auto &param : params ) {
 …
                 /// Checks a parameter list for polymorphic parameters from tyVars; will substitute according to env if present
-                bool hasPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( isPolyType( paramType->get_type(), tyVars, env ) ) return true;
+                        }
-                        return false;
+                }
                 bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TypeVarMap & typeVars, const ast::TypeSubstitution * env ) {
                         for ( auto & param : params ) {
 …
                 /// Checks a parameter list for dynamic-layout parameters from tyVars; will substitute according to env if present
-                bool hasDynParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( isDynType( paramType->get_type(), tyVars, env ) ) return true;
+                        }
-                        return false;
+                }
                 bool hasDynParams(
                                 const std::vector<ast::ptr<ast::Expr>> & params,
 …
                         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 ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( includesPolyType( paramType->get_type(), env ) ) return true;
+                        }
-                        return false;
+                }
-                /// Checks a parameter list for inclusion of polymorphic parameters from tyVars; will substitute according to env if present
-                bool includesPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                assertf(paramType, "Aggregate parameters should be type expressions");
-                                if ( includesPolyType( paramType->get_type(), tyVars, env ) ) return true;
+                        }
-                        return false;
+                }
+        }
-        Type* replaceTypeInst( Type* type, const TypeSubstitution* env ) {
-                if ( ! env ) return type;
-                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
-                        Type *newType = env->lookup( typeInst->get_name() );
-                        if ( newType ) return newType;
+                }
-                return type;
+        }
-        const Type* replaceTypeInst( const Type* type, const TypeSubstitution* env ) {
-                if ( ! env ) return type;
-                if ( auto typeInst = dynamic_cast< const TypeInstType* >( type ) ) {
-                        Type *newType = env->lookup( typeInst->get_name() );
-                        if ( newType ) return newType;
+                }
-                return type;
+        }
 …
+                }
                 return type;
+        }
-        Type *isPolyType( Type *type, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-                if ( dynamic_cast< TypeInstType * >( type ) ) {
-                        return type;
-                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        return isPolyType( arrayType->base, env );
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( hasPolyParams( structType->get_parameters(), env ) ) return type;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( hasPolyParams( unionType->get_parameters(), env ) ) return type;
+                }
-                return 0;
+        }
 …
+        }
-        Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( tyVars.contains( typeInst->get_name() ) ) {
-                                return type;
+                        }
-                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        return isPolyType( arrayType->base, tyVars, env );
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( hasPolyParams( structType->get_parameters(), tyVars, env ) ) return type;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( hasPolyParams( unionType->get_parameters(), tyVars, env ) ) return type;
+                }
-                return 0;
+        }
 const ast::Type * isPolyType( const ast::Type * type,
                 const TypeVarMap & typeVars, const ast::TypeSubstitution * subst ) {
 …
+}
-        ReferenceToType *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
-                        auto var = tyVars.find( typeInst->get_name() );
-                        if ( var != tyVars.end() && var->second.isComplete ) {
-                                return typeInst;
+                        }
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( hasDynParams( structType->get_parameters(), tyVars, env ) ) return structType;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( hasDynParams( unionType->get_parameters(), tyVars, env ) ) return unionType;
+                }
-                return 0;
+        }
 const ast::BaseInstType * isDynType(
                 const ast::Type * type, const TypeVarMap & typeVars,
 …
+}
-        ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &forallTypes ) {
-                if ( function->get_returnVals().empty() ) return 0;
-                return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
+        }
 const ast::BaseInstType *isDynRet(
                 const ast::FunctionType * type, const TypeVarMap & typeVars ) {
 …
+}
-        ReferenceToType *isDynRet( FunctionType *function ) {
-                if ( function->get_returnVals().empty() ) return 0;
-                TyVarMap forallTypes( TypeDecl::Data{} );
-                makeTyVarMap( function, forallTypes );
-                return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
+        }
 const ast::BaseInstType *isDynRet( const ast::FunctionType * func ) {
         if ( func->returns.empty() ) return nullptr;
         TypeVarMap forallTypes = { ast::TypeData() };
+        TypeVarMap forallTypes;
         makeTypeVarMap( func, forallTypes );
         return isDynType( func->returns.front(), forallTypes );
+}
-        bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) {
-//              if ( ! adaptee->get_returnVals().empty() && isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
-//                      return true;
-//              } // if
-                if ( isDynRet( adaptee, tyVars ) ) return true;
-                for ( std::list< DeclarationWithType* >::const_iterator innerArg = adaptee->get_parameters().begin(); innerArg != adaptee->get_parameters().end(); ++innerArg ) {
-//                      if ( isPolyType( (*innerArg)->get_type(), tyVars ) ) {
-                        if ( isDynType( (*innerArg)->get_type(), tyVars ) ) {
-                                return true;
-                        } // if
-                } // for
-                return false;
+        }
 bool needsAdapter(
 …
         return false;
+}
-        Type *isPolyPtr( Type *type, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-                if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
-                        return isPolyType( ptr->get_base(), env );
+                }
-                return 0;
+        }
-        Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-                if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
-                        return isPolyType( ptr->get_base(), tyVars, env );
+                }
-                return 0;
+        }
 const ast::Type * isPolyPtr(
 …
         return nullptr;
+}
-        Type * hasPolyBase( Type *type, int *levels, const TypeSubstitution *env ) {
-                int dummy;
-                if ( ! levels ) { levels = &dummy; }
-                *levels = 0;
-                while ( true ) {
-                        type = replaceTypeInst( type, env );
-                        if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
-                                type = ptr->get_base();
-                                ++(*levels);
-                        } else break;
+                }
-                return isPolyType( type, env );
+        }
-        Type * hasPolyBase( Type *type, const TyVarMap &tyVars, int *levels, const TypeSubstitution *env ) {
-                int dummy;
-                if ( ! levels ) { levels = &dummy; }
-                *levels = 0;
-                while ( true ) {
-                        type = replaceTypeInst( type, env );
-                        if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
-                                type = ptr->get_base();
-                                ++(*levels);
-                        } else break;
+                }
-                return isPolyType( type, tyVars, env );
+        }
 ast::Type const * hasPolyBase(
 …
+}
-        bool includesPolyType( Type *type, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-                if ( dynamic_cast< TypeInstType * >( type ) ) {
-                        return true;
-                } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
-                        if ( includesPolyType( pointerType->get_base(), env ) ) return true;
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( includesPolyParams( structType->get_parameters(), env ) ) return true;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( includesPolyParams( unionType->get_parameters(), env ) ) return true;
+                }
-                return false;
+        }
-        bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
-                type = replaceTypeInst( type, env );
-                if ( TypeInstType *typeInstType = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( tyVars.contains( typeInstType->get_name() ) ) {
-                                return true;
+                        }
-                } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
-                        if ( includesPolyType( pointerType->get_base(), tyVars, env ) ) return true;
-                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
-                        if ( includesPolyParams( structType->get_parameters(), tyVars, env ) ) return true;
-                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
-                        if ( includesPolyParams( unionType->get_parameters(), tyVars, env ) ) return true;
+                }
-                return false;
+        }
-        FunctionType * getFunctionType( Type *ty ) {
-                PointerType *ptrType;
-                if ( ( ptrType = dynamic_cast< PointerType* >( ty ) ) ) {
-                        return dynamic_cast< FunctionType* >( ptrType->get_base() ); // pointer if FunctionType, NULL otherwise
-                } else {
-                        return dynamic_cast< FunctionType* >( ty ); // pointer if FunctionType, NULL otherwise
+                }
+        }
         const ast::FunctionType * getFunctionType( const ast::Type * ty ) {
                 if ( auto pty = dynamic_cast< const ast::PointerType * >( ty ) ) {
 …
+        }
-        VariableExpr * getBaseVar( Expression *expr, int *levels ) {
-                int dummy;
-                if ( ! levels ) { levels = &dummy; }
-                *levels = 0;
-                while ( true ) {
-                        if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( expr ) ) {
-                                return varExpr;
-                        } else if ( MemberExpr *memberExpr = dynamic_cast< MemberExpr* >( expr ) ) {
-                                expr = memberExpr->get_aggregate();
-                        } else if ( AddressExpr *addressExpr = dynamic_cast< AddressExpr* >( expr ) ) {
-                                expr = addressExpr->get_arg();
-                        } else if ( UntypedExpr *untypedExpr = dynamic_cast< UntypedExpr* >( expr ) ) {
-                                // look for compiler-inserted dereference operator
-                                NameExpr *fn = dynamic_cast< NameExpr* >( untypedExpr->get_function() );
-                                if ( ! fn || fn->get_name() != std::string("*?") ) return 0;
-                                expr = *untypedExpr->begin_args();
-                        } else if ( CommaExpr *commaExpr = dynamic_cast< CommaExpr* >( expr ) ) {
-                                // copy constructors insert comma exprs, look at second argument which contains the variable
-                                expr = commaExpr->get_arg2();
-                                continue;
-                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( expr ) ) {
-                                int lvl1;
-                                int lvl2;
-                                VariableExpr * var1 = getBaseVar( condExpr->get_arg2(), &lvl1 );
-                                VariableExpr * var2 = getBaseVar( condExpr->get_arg3(), &lvl2 );
-                                if ( lvl1 == lvl2 && var1 && var2 && var1->get_var() == var2->get_var() ) {
-                                        *levels = lvl1;
-                                        return var1;
+                                }
-                                break;
-                        } else break;
-                        ++(*levels);
+                }
-                return 0;
+        }
         namespace {
                 /// Checks if is a pointer to D
 …
                 inline D const * as( B const * p ) {
                         return reinterpret_cast<D const *>( p );
+                }
-                /// Flattens a declaration list
-                template<typename Output>
-                void flattenList( list< DeclarationWithType* > src, Output out ) {
-                        for ( DeclarationWithType* decl : src ) {
-                                ResolvExpr::flatten( decl->get_type(), out );
+                        }
+                }
-                /// Flattens a list of types
-                template<typename Output>
-                void flattenList( list< Type* > src, Output out ) {
-                        for ( Type* ty : src ) {
-                                ResolvExpr::flatten( ty, out );
+                        }
+                }
 …
+                }
-                /// Checks if two lists of parameters are equal up to polymorphic substitution.
-                bool paramListsPolyCompatible( const list< Expression* >& aparams, const list< Expression* >& bparams ) {
-                        if ( aparams.size() != bparams.size() ) return false;
-                        for ( list< Expression* >::const_iterator at = aparams.begin(), bt = bparams.begin();
-                                        at != aparams.end(); ++at, ++bt ) {
-                                TypeExpr *aparam = dynamic_cast< TypeExpr* >(*at);
-                                assertf(aparam, "Aggregate parameters should be type expressions");
-                                TypeExpr *bparam = dynamic_cast< TypeExpr* >(*bt);
-                                assertf(bparam, "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>( 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,
 …
                         return true;
+                }
+        }
-        bool typesPolyCompatible( Type *a, Type *b ) {
-                type_index aid{ typeid(*a) };
-                // polymorphic types always match
-                if ( aid == type_index{typeid(TypeInstType)} ) return true;
-                type_index bid{ typeid(*b) };
-                // polymorphic types always match
-                if ( bid == type_index{typeid(TypeInstType)} ) return true;
-                // can't match otherwise if different types
-                if ( aid != bid ) return false;
-                // recurse through type structure (conditions borrowed from Unify.cc)
-                if ( aid == type_index{typeid(BasicType)} ) {
-                        return as<BasicType>(a)->get_kind() == as<BasicType>(b)->get_kind();
-                } else if ( aid == type_index{typeid(PointerType)} ) {
-                        PointerType *ap = as<PointerType>(a), *bp = as<PointerType>(b);
-                        // void pointers should match any other pointer type
-                        return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
-                                || typesPolyCompatible( ap->get_base(), bp->get_base() );
-                } else if ( aid == type_index{typeid(ReferenceType)} ) {
-                        ReferenceType *ap = as<ReferenceType>(a), *bp = as<ReferenceType>(b);
-                        return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
-                                || typesPolyCompatible( ap->get_base(), bp->get_base() );
-                } else if ( aid == type_index{typeid(ArrayType)} ) {
-                        ArrayType *aa = as<ArrayType>(a), *ba = as<ArrayType>(b);
-                        if ( aa->get_isVarLen() ) {
-                                if ( ! ba->get_isVarLen() ) return false;
-                        } else {
-                                if ( ba->get_isVarLen() ) return false;
-                                ConstantExpr *ad = dynamic_cast<ConstantExpr*>( aa->get_dimension() );
-                                ConstantExpr *bd = dynamic_cast<ConstantExpr*>( ba->get_dimension() );
-                                if ( ad && bd
-                                                && ad->get_constant()->get_value() != bd->get_constant()->get_value() )
-                                        return false;
+                        }
-                        return typesPolyCompatible( aa->get_base(), ba->get_base() );
-                } else if ( aid == type_index{typeid(FunctionType)} ) {
-                        FunctionType *af = as<FunctionType>(a), *bf = as<FunctionType>(b);
-                        vector<Type*> aparams, bparams;
-                        flattenList( af->get_parameters(), back_inserter( aparams ) );
-                        flattenList( bf->get_parameters(), back_inserter( bparams ) );
-                        if ( aparams.size() != bparams.size() ) return false;
-                        vector<Type*> areturns, breturns;
-                        flattenList( af->get_returnVals(), back_inserter( areturns ) );
-                        flattenList( bf->get_returnVals(), back_inserter( breturns ) );
-                        if ( areturns.size() != breturns.size() ) return false;
-                        for ( unsigned i = 0; i < aparams.size(); ++i ) {
-                                if ( ! typesPolyCompatible( aparams[i], bparams[i] ) ) return false;
+                        }
-                        for ( unsigned i = 0; i < areturns.size(); ++i ) {
-                                if ( ! typesPolyCompatible( areturns[i], breturns[i] ) ) return false;
+                        }
-                        return true;
-                } else if ( aid == type_index{typeid(StructInstType)} ) {
-                        StructInstType *aa = as<StructInstType>(a), *ba = as<StructInstType>(b);
-                        if ( aa->get_name() != ba->get_name() ) return false;
-                        return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
-                } else if ( aid == type_index{typeid(UnionInstType)} ) {
-                        UnionInstType *aa = as<UnionInstType>(a), *ba = as<UnionInstType>(b);
-                        if ( aa->get_name() != ba->get_name() ) return false;
-                        return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
-                } else if ( aid == type_index{typeid(EnumInstType)} ) {
-                        return as<EnumInstType>(a)->get_name() == as<EnumInstType>(b)->get_name();
-                } else if ( aid == type_index{typeid(TraitInstType)} ) {
-                        return as<TraitInstType>(a)->get_name() == as<TraitInstType>(b)->get_name();
-                } else if ( aid == type_index{typeid(TupleType)} ) {
-                        TupleType *at = as<TupleType>(a), *bt = as<TupleType>(b);
-                        vector<Type*> atypes, btypes;
-                        flattenList( at->get_types(), back_inserter( atypes ) );
-                        flattenList( bt->get_types(), back_inserter( btypes ) );
-                        if ( atypes.size() != btypes.size() ) return false;
-                        for ( unsigned i = 0; i < atypes.size(); ++i ) {
-                                if ( ! typesPolyCompatible( atypes[i], btypes[i] ) ) return false;
+                        }
-                        return true;
-                } else return true; // VoidType, VarArgsType, ZeroType & OneType just need the same type
+        }
 …
+}
-        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
-                // is parameter is not polymorphic, don't need to box
-                if ( ! isPolyType( param, exprTyVars ) ) return false;
-                Type * newType = arg->clone();
-                if ( env ) env->apply( newType );
-                std::unique_ptr<Type> manager( newType );
-                // if the argument's type is polymorphic, we don't need to box again!
-                return ! isPolyType( newType );
+        }
 bool needsBoxing( const ast::Type * param, const ast::Type * arg,
                 const TypeVarMap & typeVars, const ast::TypeSubstitution * subst ) {
 …
         return !isPolyType( newType );
+}
-        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
-                FunctionType * function = getFunctionType( appExpr->function->result );
-                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );
-                TyVarMap exprTyVars( TypeDecl::Data{} );
-                makeTyVarMap( function, exprTyVars );
-                return needsBoxing( param, arg, exprTyVars, env );
+        }
 bool needsBoxing(
 …
         const ast::FunctionType * function = getFunctionType( expr->func->result );
         assertf( function, "ApplicationExpr has non-function type: %s", toString( expr->func->result ).c_str() );
         TypeVarMap exprTyVars = { ast::TypeData() };
+        TypeVarMap exprTyVars;
         makeTypeVarMap( function, exprTyVars );
         return needsBoxing( param, arg, exprTyVars, subst );
+}
-        void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
-                tyVarMap.insert( tyVar->name, TypeDecl::Data{ tyVar } );
+        }
 void addToTypeVarMap( const ast::TypeDecl * decl, TypeVarMap & typeVars ) {
         typeVars.insert( ast::TypeEnvKey( decl, 0, 0 ), ast::TypeData( decl ) );
 …
         typeVars.insert( ast::TypeEnvKey( *type ), ast::TypeData( type->base ) );
+}
-        void makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
-                for ( Type::ForallList::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
-                        assert( *tyVar );
-                        addToTyVarMap( *tyVar, tyVarMap );
+                }
-                if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
-                        makeTyVarMap( pointer->get_base(), tyVarMap );
+                }
+        }
 void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars ) {
 …
+}
-        void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
-                for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {
-                        os << i->first << " (" << i->second << ") ";
-                } // for
-                os << std::endl;
+        }
 } // namespace GenPoly

src/GenPoly/GenPoly.h

-              r0030b508
+              rfc12f05
 #include "AST/Fwd.hpp"            // for ApplicationExpr, BaseInstType, Func...
 #include "SymTab/Mangler.h"       // for Mangler
-#include "SynTree/Declaration.h"  // for TypeDecl::Data, AggregateDecl, Type...
-#include "SynTree/SynTree.h"      // for Visitor Nodes
 namespace ast {
 …
 namespace GenPoly {
+        typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
+        using TypeVarMap = ErasableScopedMap< ast::TypeEnvKey, ast::TypeData >;
+        struct TypeVarMap : public ErasableScopedMap<ast::TypeEnvKey, ast::TypeData> {
+                TypeVarMap() : ErasableScopedMap( ast::TypeData() ) {}
+        };
         /// Replaces a TypeInstType by its referrent in the environment, if applicable
-        Type* replaceTypeInst( Type* type, const TypeSubstitution* env );
-        const Type* replaceTypeInst( const Type* type, const TypeSubstitution* env );
         const ast::Type * replaceTypeInst( const ast::Type *, const ast::TypeSubstitution * );
         /// returns polymorphic type if is polymorphic type, NULL otherwise; will look up substitution in env if provided
-        Type *isPolyType( Type *type, const TypeSubstitution *env = 0 );
         const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env = nullptr);
         /// returns polymorphic type if is polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
-        Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
         const ast::Type * isPolyType( const ast::Type * type, const TypeVarMap & typeVars, const ast::TypeSubstitution * subst = nullptr );
         /// 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 TypeVarMap & typeVars, const ast::TypeSubstitution * subst = 0 );
         /// true iff function has dynamic-layout return type under the given type variable map
-        ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &tyVars );
         const ast::BaseInstType *isDynRet( const ast::FunctionType * type, const TypeVarMap & typeVars );
         /// true iff function has dynamic-layout return type under the type variable map generated from its forall-parameters
-        ReferenceToType *isDynRet( FunctionType *function );
         const ast::BaseInstType *isDynRet( const ast::FunctionType * func );
         /// A function needs an adapter if it returns a dynamic-layout value or if any of its parameters have dynamic-layout type
-        bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVarr );
         bool needsAdapter( ast::FunctionType const * adaptee, const TypeVarMap & typeVars );
-        /// returns polymorphic type if is pointer to polymorphic type, NULL otherwise; will look up substitution in env if provided
-        Type *isPolyPtr( Type *type, const TypeSubstitution *env = 0 );
         /// returns polymorphic type if is pointer to polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
-        Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
         const ast::Type * isPolyPtr( const ast::Type * type, const TypeVarMap & typeVars, const ast::TypeSubstitution * env = 0 );
-        /// if the base type (after dereferencing N >= 0 pointers) is a polymorphic type, returns the base type, NULL otherwise;
-        /// N will be stored in levels, if provided, will look up substitution in env if provided
-        Type *hasPolyBase( Type *type, int *levels = 0, const TypeSubstitution *env = 0 );
         /// if the base type (after dereferencing N >= 0 pointers) is a polymorphic type in tyVars, returns the base type, NULL otherwise;
         /// N will be stored in levels, if provided, will look up substitution in env if provided
-        Type *hasPolyBase( Type *type, const TyVarMap &tyVars, int *levels = 0, const TypeSubstitution *env = 0 );
         const ast::Type * hasPolyBase( const ast::Type * type, const TypeVarMap & typeVars, int * levels = 0, const ast::TypeSubstitution * env = 0 );
-        /// true iff this type or some base of this type after dereferencing pointers is either polymorphic or a generic type with at least one
-        /// polymorphic parameter; will look up substitution in env if provided.
-        bool includesPolyType( Type *type, const TypeSubstitution *env = 0 );
-        /// true iff this type or some base of this type after dereferencing pointers is either polymorphic in tyVars, or a generic type with
-        /// at least one polymorphic parameter in tyVars; will look up substitution in env if provided.
-        bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
         /// Returns a pointer to the base FunctionType if ty is the type of a function (or pointer to one), NULL otherwise
-        FunctionType *getFunctionType( Type *ty );
         const ast::FunctionType * getFunctionType( const ast::Type * ty );
-        /// If expr (after dereferencing N >= 0 pointers) is a variable expression, returns the variable expression, NULL otherwise;
-        /// N will be stored in levels, if provided
-        VariableExpr *getBaseVar( Expression *expr, int *levels = 0 );
         /// 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
-        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env );
         bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TypeVarMap & typeVars, const ast::TypeSubstitution * subst );
         /// true if arg requires boxing in the call to appExpr
-        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env );
         bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * expr, const ast::TypeSubstitution * subst );
         /// Adds the type variable `tyVar` to `tyVarMap`
-        void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap );
         void addToTypeVarMap( const ast::TypeDecl * type, TypeVarMap & typeVars );
         void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars );
         /// Adds the declarations in the forall list of type (and its pointed-to type if it's a pointer type) to `tyVarMap`
-        void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
         void makeTypeVarMap( const ast::Type * type, TypeVarMap & typeVars );
         void makeTypeVarMap( const ast::FunctionDecl * decl, TypeVarMap & typeVars );
-        /// Prints type variable map
-        void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap );
-        /// Gets the mangled name of this type; alias for SymTab::Mangler::mangleType().
-        inline std::string mangleType( const Type *ty ) { return SymTab::Mangler::mangleType( ty ); }
         /// Gets the name of the sizeof parameter for the type, given its mangled name
 …
         /// Gets the name of the layout function for a given aggregate type, given its declaration
-        inline std::string layoutofName( AggregateDecl *decl ) { return std::string( "_layoutof_" ) + decl->get_name(); }
         inline std::string layoutofName( ast::AggregateDecl const * decl ) {
                 return std::string( "_layoutof_" ) + decl->name;

src/GenPoly/ScrubTyVars.cc

-              r0030b508
+              rfc12f05
 #include "ScrubTyVars.h"
 #include "SymTab/Mangler.h"             // for mangleType
-#include "SynTree/Declaration.h"        // for TypeDecl, TypeDecl::Data, Typ...
-#include "SynTree/Expression.h"         // for Expression (ptr only), NameExpr
-#include "SynTree/Mutator.h"            // for Mutator
-#include "SynTree/Type.h"               // for PointerType, TypeInstType, Type
 namespace GenPoly {
-        Type * ScrubTyVars::postmutate( TypeInstType * typeInst ) {
-                if ( ! tyVars ) {
-                        if ( typeInst->get_isFtype() ) {
-                                delete typeInst;
-                                return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
-                        } else {
-                                PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
-                                delete typeInst;
-                                return ret;
+                        }
+                }
-                TyVarMap::const_iterator tyVar = tyVars->find( typeInst->name );
-                if ( tyVar != tyVars->end() ) {
-                        switch ( tyVar->second.kind ) {
-                          case TypeDecl::Dtype:
-                          case TypeDecl::Ttype:
+                                {
-                                        PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
-                                        delete typeInst;
-                                        return ret;
+                                }
-                          case TypeDecl::Ftype:
-                                delete typeInst;
-                                return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
-                          default:
-                                assertf(false, "Unhandled tyvar kind: %d", tyVar->second.kind);
-                        } // switch
-                } // if
-                return typeInst;
+        }
-        Type * ScrubTyVars::mutateAggregateType( Type * ty ) {
-                if ( shouldScrub( ty ) ) {
-                        PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );
-                        delete ty;
-                        return ret;
+                }
-                return ty;
+        }
-        Type * ScrubTyVars::postmutate( StructInstType * structInst ) {
-                return mutateAggregateType( structInst );
+        }
-        Type * ScrubTyVars::postmutate( UnionInstType * unionInst ) {
-                return mutateAggregateType( unionInst );
+        }
-        void ScrubTyVars::primeBaseScrub( Type * type ) {
-                // need to determine whether type needs to be scrubbed to determine whether
-                // automatic recursion is necessary
-                if ( Type * t = shouldScrub( type ) ) {
-                        visit_children = false;
-                        GuardValue( dynType );
-                        dynType = t;
+                }
+        }
-        Expression * ScrubTyVars::postmutate( SizeofExpr * szeof ) {
-                // sizeof( T ) => _sizeof_T parameter, which is the size of T
-                if ( dynType ) {
-                        Expression *expr = new NameExpr( sizeofName( mangleType( dynType ) ) );
-                        return expr;
-                } // if
-                return szeof;
+        }
-        Expression * ScrubTyVars::postmutate( AlignofExpr * algnof ) {
-                // alignof( T ) => _alignof_T parameter, which is the alignment of T
-                if ( dynType ) {
-                        Expression *expr = new NameExpr( alignofName( mangleType( dynType ) ) );
-                        return expr;
-                } // if
-                return algnof;
+        }
-        Type * ScrubTyVars::postmutate( PointerType * pointer ) {
-                if ( dynType ) {
-                        Type * ret = dynType->acceptMutator( *visitor );
-                        ret->get_qualifiers() |= pointer->get_qualifiers();
-                        pointer->base = nullptr;
-                        delete pointer;
-                        return ret;
+                }
-                return pointer;
+        }
 namespace {

src/GenPoly/ScrubTyVars.h

-              r0030b508
+              rfc12f05
 #include "AST/Fwd.hpp"        // for Node
-#include "Common/PassVisitor.h"
 #include "GenPoly.h"          // for TyVarMap, isPolyType, isDynType
-#include "SynTree/Mutator.h"  // for Mutator
-#include "SynTree/Type.h"     // for Type (ptr only), PointerType (ptr only)
-class AlignofExpr;
-class Expression;
-class SizeofExpr;
 namespace GenPoly {
-        struct ScrubTyVars : public WithVisitorRef<ScrubTyVars>, public WithShortCircuiting, public WithGuards {
-                /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables
-                enum ScrubMode { FromMap, DynamicFromMap, All };
-                ScrubTyVars() : tyVars(nullptr), mode( All ) {}
-                ScrubTyVars( const TyVarMap &tyVars, ScrubMode mode = FromMap ): tyVars( &tyVars ), mode( mode ) {}
-        public:
-                /// For all polymorphic types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type,
-                /// and sizeof/alignof expressions with the proper variable
-                template< typename SynTreeClass >
-                static SynTreeClass *scrub( SynTreeClass *target, const TyVarMap &tyVars );
-                /// For all dynamic-layout types with type variables in `tyVars`, replaces generic types, dtypes, and ftypes with the appropriate void type,
-                /// and sizeof/alignof expressions with the proper variable
-                template< typename SynTreeClass >
-                static SynTreeClass *scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars );
-                /// For all polymorphic types, replaces generic types, dtypes, and ftypes with the appropriate void type,
-                /// and sizeof/alignof expressions with the proper variable
-                template< typename SynTreeClass >
-                static SynTreeClass *scrubAll( SynTreeClass *target );
-                /// determine if children should be visited based on whether base type should be scrubbed.
-                void primeBaseScrub( Type * );
-                void premutate( TypeInstType * ) { visit_children = false; }
-                void premutate( StructInstType * ) { visit_children = false; }
-                void premutate( UnionInstType * ) { visit_children = false; }
-                void premutate( SizeofExpr * szeof ) { primeBaseScrub( szeof->type ); }
-                void premutate( AlignofExpr * algnof ) { primeBaseScrub( algnof->type ); }
-                void premutate( PointerType * pointer ) { primeBaseScrub( pointer->base ); }
-                Type * postmutate( TypeInstType * typeInst );
-                Type * postmutate( StructInstType * structInst );
-                Type * postmutate( UnionInstType * unionInst );
-                Expression * postmutate( SizeofExpr * szeof );
-                Expression * postmutate( AlignofExpr * algnof );
-                Type * postmutate( PointerType * pointer );
-          private:
-                /// Returns the type if it should be scrubbed, NULL otherwise.
-                Type* shouldScrub( Type *ty ) {
-                        switch ( mode ) {
-                        case FromMap: return isPolyType( ty, *tyVars );
-                        case DynamicFromMap: return isDynType( ty, *tyVars );
-                        case All: return isPolyType( ty );
+                        }
-                        assert(false); return nullptr; // unreachable
-                        // return dynamicOnly ? isDynType( ty, tyVars ) : isPolyType( ty, tyVars );
+                }
-                /// Mutates (possibly generic) aggregate types appropriately
-                Type* mutateAggregateType( Type *ty );
-                const TyVarMap *tyVars;  ///< Type variables to scrub
-                ScrubMode mode;          ///< which type variables to scrub? [FromMap]
-                Type * dynType = nullptr; ///< result of shouldScrub
-        };
-        template< typename SynTreeClass >
-        SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) {
-                PassVisitor<ScrubTyVars> scrubber( tyVars );
-                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
+        }
-        template< typename SynTreeClass >
-        SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) {
-                PassVisitor<ScrubTyVars> scrubber( tyVars, ScrubTyVars::DynamicFromMap );
-                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
+        }
-        template< typename SynTreeClass >
-        SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) {
-                PassVisitor<ScrubTyVars> scrubber;
-                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
+        }
 // ScrubMode and scrubTypeVarsBase are internal.

src/GenPoly/SpecializeNew.cpp

-              r0030b508
+              rfc12f05
 #include "GenPoly/GenPoly.h"             // for getFunctionType
 #include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
-#include "ResolvExpr/TypeEnvironment.h"  // for FirstOpen, FirstClosed
 namespace GenPoly {
 …
+}
 // The number of elements in a type if it is a flattened tuple.
 size_t flatTupleSize( const ast::Type * type ) {
         if ( auto tuple = dynamic_cast<const ast::TupleType *>( type ) ) {
                 size_t sum = 0;
                 for ( auto t : *tuple ) {
                         sum += flatTupleSize( t );
+                }
                 return sum;
         } else {
                 return 1;
+        }
+// The number of elements in a list, if all tuples had been flattened.
+size_t flatTypeListSize( const std::vector<ast::ptr<ast::Type>> & types ) {
+        size_t sum = 0;
+        for ( const ast::ptr<ast::Type> & type : types ) {
+                if ( const ast::TupleType * tuple = type.as<ast::TupleType>() ) {
+                        sum += flatTypeListSize( tuple->types );
+                } else {
+                        sum += 1;
+                }
+        }
+        return sum;
+}
 // Find the total number of components in a parameter list.
 size_t functionParameterSize( const ast::FunctionType * type ) {
+        size_t sum = 0;
+        for ( auto param : type->params ) {
+                sum += flatTupleSize( param );
+        }
+        return sum;
+        return flatTypeListSize( type->params );
+}

src/GenPoly/module.mk

-              r0030b508
+              rfc12f05
 SRC += $(SRC_GENPOLY) \
         GenPoly/BoxNew.cpp \
-        GenPoly/Box.cc \
         GenPoly/Box.h \
         GenPoly/ErasableScopedMap.h \
 …
         GenPoly/FindFunction.h \
         GenPoly/InstantiateGenericNew.cpp \
-        GenPoly/InstantiateGeneric.cc \
         GenPoly/InstantiateGeneric.h \
         GenPoly/LvalueNew.cpp \
-        GenPoly/Lvalue.cc \
         GenPoly/ScopedSet.h \
         GenPoly/ScrubTyVars.cc \
         GenPoly/ScrubTyVars.h \
-        GenPoly/Specialize.cc \
         GenPoly/SpecializeNew.cpp \
         GenPoly/Specialize.h

src/InitTweak/FixGlobalInit.cc

-              r0030b508
+              rfc12f05
 #include <algorithm>               // for replace_if
-#include "Common/PassVisitor.h"
-#include "Common/UniqueName.h"     // for UniqueName
-#include "InitTweak.h"             // for isIntrinsicSingleArgCallStmt
-#include "SynTree/LinkageSpec.h"   // for C
-#include "SynTree/Attribute.h"     // for Attribute
-#include "SynTree/Constant.h"      // for Constant
-#include "SynTree/Declaration.h"   // for FunctionDecl, ObjectDecl, Declaration
-#include "SynTree/Expression.h"    // for ConstantExpr, Expression (ptr only)
-#include "SynTree/Initializer.h"   // for ConstructorInit, Initializer
-#include "SynTree/Label.h"         // for Label
-#include "SynTree/Statement.h"     // for CompoundStmt, Statement (ptr only)
-#include "SynTree/Type.h"          // for Type, Type::StorageClasses, Functi...
-#include "SynTree/Visitor.h"       // for acceptAll, Visitor
 #include "AST/Expr.hpp"
 #include "AST/Node.hpp"
 #include "AST/Pass.hpp"
+#include "Common/UniqueName.h"     // for UniqueName
+#include "InitTweak.h"             // for isIntrinsicSingleArgCallStmt
 namespace InitTweak {
-        class GlobalFixer : public WithShortCircuiting {
-          public:
-                GlobalFixer( bool inLibrary );
-                void previsit( ObjectDecl *objDecl );
-                void previsit( FunctionDecl *functionDecl );
-                void previsit( StructDecl *aggregateDecl );
-                void previsit( UnionDecl *aggregateDecl );
-                void previsit( EnumDecl *aggregateDecl );
-                void previsit( TraitDecl *aggregateDecl );
-                void previsit( TypeDecl *typeDecl );
-                UniqueName tempNamer;
-                FunctionDecl * initFunction;
-                FunctionDecl * destroyFunction;
-        };
         class GlobalFixer_new : public ast::WithShortCircuiting {
         public:
 …
                 std::list< ast::ptr<ast::Stmt> > destroyStmts;
         };
-        void fixGlobalInit( std::list< Declaration * > & translationUnit, bool inLibrary ) {
-                PassVisitor<GlobalFixer> visitor( inLibrary );
-                acceptAll( translationUnit, visitor );
-                GlobalFixer & fixer = visitor.pass;
-                // don't need to include function if it's empty
-                if ( fixer.initFunction->get_statements()->get_kids().empty() ) {
-                        delete fixer.initFunction;
-                } else {
-                        translationUnit.push_back( fixer.initFunction );
-                } // if
-                if ( fixer.destroyFunction->get_statements()->get_kids().empty() ) {
-                        delete fixer.destroyFunction;
-                } else {
-                        translationUnit.push_back( fixer.destroyFunction );
-                } // if
+        }
-        GlobalFixer::GlobalFixer( bool inLibrary ) : tempNamer( "_global_init" ) {
-                std::list< Expression * > ctorParameters;
-                std::list< Expression * > dtorParameters;
-                if ( inLibrary ) {
-                        // Constructor/destructor attributes take a single parameter which
-                        // is the priority, with lower numbers meaning higher priority.
-                        // Functions specified with priority are guaranteed to run before
-                        // functions without a priority. To ensure that constructors and destructors
-                        // for library code are run before constructors and destructors for user code,
-                        // specify a priority when building the library. Priorities 0-100 are reserved by gcc.
-                        // Priorities 101-200 are reserved by cfa, so use priority 200 for CFA library globals,
-                        // allowing room for overriding with a higher priority.
-                        ctorParameters.push_back( new ConstantExpr( Constant::from_int( 200 ) ) );
-                        dtorParameters.push_back( new ConstantExpr( Constant::from_int( 200 ) ) );
+                }
-                initFunction = new FunctionDecl( "__global_init__", Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
-                initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
-                destroyFunction = new FunctionDecl( "__global_destroy__", Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
-                destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
+        }
         void fixGlobalInit(ast::TranslationUnit & translationUnit, bool inLibrary) {
 …
+        }
-        void GlobalFixer::previsit( ObjectDecl *objDecl ) {
-                std::list< Statement * > & initStatements = initFunction->get_statements()->get_kids();
-                std::list< Statement * > & destroyStatements = destroyFunction->get_statements()->get_kids();
-                // C allows you to initialize objects with constant expressions
-                // xxx - this is an optimization. Need to first resolve constructors before we decide
-                // to keep C-style initializer.
-                // if ( isConstExpr( objDecl->get_init() ) ) return;
-                if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
-                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
-                        assert( ! ctorInit->ctor || ! ctorInit->init );
-                        Statement * dtor = ctorInit->dtor;
-                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
-                                // don't need to call intrinsic dtor, because it does nothing, but
-                                // non-intrinsic dtors must be called
-                                destroyStatements.push_front( dtor );
-                                ctorInit->dtor = nullptr;
-                        } // if
-                        if ( Statement * ctor = ctorInit->ctor ) {
-                                addDataSectionAttribute( objDecl );
-                                initStatements.push_back( ctor );
-                                objDecl->init = nullptr;
-                                ctorInit->ctor = nullptr;
-                        } else if ( Initializer * init = ctorInit->init ) {
-                                objDecl->init = init;
-                                ctorInit->init = nullptr;
-                        } else {
-                                // no constructor and no initializer, which is okay
-                                objDecl->init = nullptr;
-                        } // if
-                        delete ctorInit;
-                } // if
+        }
         void GlobalFixer_new::previsit(const ast::ObjectDecl * objDecl) {
                 auto mutDecl = mutate(objDecl);
 …
+        }
-        // only modify global variables
-        void GlobalFixer::previsit( FunctionDecl * ) { visit_children = false; }
-        void GlobalFixer::previsit( StructDecl * ) { visit_children = false; }
-        void GlobalFixer::previsit( UnionDecl * ) { visit_children = false; }
-        void GlobalFixer::previsit( EnumDecl * ) { visit_children = false; }
-        void GlobalFixer::previsit( TraitDecl * ) { visit_children = false; }
-        void GlobalFixer::previsit( TypeDecl * ) { visit_children = false; }
 } // namespace InitTweak

src/InitTweak/FixInitNew.cpp

-              r0030b508
+              rfc12f05
 #include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 extern bool ctordtorp; // print all debug
 extern bool ctorp; // print ctor debug
 extern bool cpctorp; // print copy ctor debug
 extern bool dtorp; // print dtor debug
+bool ctordtorp = false; // print all debug
+bool ctorp = false; // print ctor debug
+bool cpctorp = false; // print copy ctor debug
+bool dtorp = false; // print dtor debug
 #define PRINT( text ) if ( ctordtorp ) { text }
 #define CP_CTOR_PRINT( text ) if ( ctordtorp || cpctorp ) { text }
 …
 /// (currently by FixInit)
 struct InsertDtors final : public ObjDeclCollector, public ast::WithStmtsToAdd<> {
-        typedef std::list< ObjectDecl * > OrderedDecls;
-        typedef std::list< OrderedDecls > OrderedDeclsStack;
         InsertDtors( ast::Pass<LabelFinder> & finder ) : finder( finder ), labelVars( finder.core.vars ) {}
 …
         ast::Pass<LabelFinder> & finder;
         LabelFinder::LabelMap & labelVars;
-        OrderedDeclsStack reverseDeclOrder;
 };

src/InitTweak/GenInit.cc

-              r0030b508
+              rfc12f05
 #include "CompilationState.h"
 #include "CodeGen/OperatorTable.h"
-#include "Common/PassVisitor.h"        // for PassVisitor, WithGuards, WithShort...
 #include "Common/SemanticError.h"      // for SemanticError
 #include "Common/ToString.hpp"         // for toCString
 …
 #include "InitTweak.h"                 // for isConstExpr, InitExpander, checkIn...
 #include "ResolvExpr/Resolver.h"
-#include "SymTab/Autogen.h"            // for genImplicitCall
 #include "SymTab/GenImplicitCall.hpp"  // for genImplicitCall
 #include "SymTab/Mangler.h"            // for Mangler
-#include "SynTree/LinkageSpec.h"       // for isOverridable, C
-#include "SynTree/Declaration.h"       // for ObjectDecl, DeclarationWithType
-#include "SynTree/Expression.h"        // for VariableExpr, UntypedExpr, Address...
-#include "SynTree/Initializer.h"       // for ConstructorInit, SingleInit, Initi...
-#include "SynTree/Label.h"             // for Label
-#include "SynTree/Mutator.h"           // for mutateAll
-#include "SynTree/Statement.h"         // for CompoundStmt, ImplicitCtorDtorStmt
-#include "SynTree/Type.h"              // for Type, ArrayType, Type::Qualifiers
-#include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
 #include "Tuples/Tuples.h"             // for maybeImpure
 #include "Validate/FindSpecialDecls.h" // for SizeType
 namespace InitTweak {
-        namespace {
-                const std::list<Label> noLabels;
-                const std::list<Expression *> noDesignators;
+        }
-        struct ReturnFixer : public WithStmtsToAdd, public WithGuards {
-                /// consistently allocates a temporary variable for the return value
-                /// of a function so that anything which the resolver decides can be constructed
-                /// into the return type of a function can be returned.
-                static void makeReturnTemp( std::list< Declaration * > &translationUnit );
-                void premutate( FunctionDecl *functionDecl );
-                void premutate( ReturnStmt * returnStmt );
-          protected:
-                FunctionType * ftype = nullptr;
-                std::string funcName;
-        };
-        struct CtorDtor : public WithGuards, public WithShortCircuiting, public WithVisitorRef<CtorDtor>  {
-                /// create constructor and destructor statements for object declarations.
-                /// the actual call statements will be added in after the resolver has run
-                /// so that the initializer expression is only removed if a constructor is found
-                /// and the same destructor call is inserted in all of the appropriate locations.
-                static void generateCtorDtor( std::list< Declaration * > &translationUnit );
-                void previsit( ObjectDecl * );
-                void previsit( FunctionDecl *functionDecl );
-                // should not traverse into any of these declarations to find objects
-                // that need to be constructed or destructed
-                void previsit( StructDecl *aggregateDecl );
-                void previsit( AggregateDecl * ) { visit_children = false; }
-                void previsit( NamedTypeDecl * ) { visit_children = false; }
-                void previsit( FunctionType * ) { visit_children = false; }
-                void previsit( CompoundStmt * compoundStmt );
-          private:
-                // set of mangled type names for which a constructor or destructor exists in the current scope.
-                // these types require a ConstructorInit node to be generated, anything else is a POD type and thus
-                // should not have a ConstructorInit generated.
-                ManagedTypes managedTypes;
-                bool inFunction = false;
-        };
-        struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards, public WithIndexer {
-                /// hoist dimension from array types in object declaration so that it uses a single
-                /// const variable of type size_t, so that side effecting array dimensions are only
-                /// computed once.
-                static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
-                void premutate( ObjectDecl * objectDecl );
-                DeclarationWithType * postmutate( ObjectDecl * objectDecl );
-                void premutate( FunctionDecl *functionDecl );
-                // should not traverse into any of these declarations to find objects
-                // that need to be constructed or destructed
-                void premutate( AggregateDecl * ) { visit_children = false; }
-                void premutate( NamedTypeDecl * ) { visit_children = false; }
-                void premutate( FunctionType * ) { visit_children = false; }
-                // need this so that enumerators are added to the indexer, due to premutate(AggregateDecl *)
-                void premutate( EnumDecl * ) {}
-                void hoist( Type * type );
-                Type::StorageClasses storageClasses;
-                bool inFunction = false;
-        };
-        struct HoistArrayDimension_NoResolve final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
-                /// hoist dimension from array types in object declaration so that it uses a single
-                /// const variable of type size_t, so that side effecting array dimensions are only
-                /// computed once.
-                static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
-                void premutate( ObjectDecl * objectDecl );
-                DeclarationWithType * postmutate( ObjectDecl * objectDecl );
-                void premutate( FunctionDecl *functionDecl );
-                // should not traverse into any of these declarations to find objects
-                // that need to be constructed or destructed
-                void premutate( AggregateDecl * ) { visit_children = false; }
-                void premutate( NamedTypeDecl * ) { visit_children = false; }
-                void premutate( FunctionType * ) { visit_children = false; }
-                void hoist( Type * type );
-                Type::StorageClasses storageClasses;
-                bool inFunction = false;
-        };
-        void genInit( std::list< Declaration * > & translationUnit ) {
-                if (!useNewAST) {
-                        HoistArrayDimension::hoistArrayDimension( translationUnit );
+                }
-                else {
-                        HoistArrayDimension_NoResolve::hoistArrayDimension( translationUnit );
+                }
-                fixReturnStatements( translationUnit );
-                if (!useNewAST) {
-                        CtorDtor::generateCtorDtor( translationUnit );
+                }
+        }
-        void fixReturnStatements( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<ReturnFixer> fixer;
-                mutateAll( translationUnit, fixer );
+        }
-        void ReturnFixer::premutate( ReturnStmt *returnStmt ) {
-                std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
-                assert( returnVals.size() == 0 || returnVals.size() == 1 );
-                // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
-                // is being returned
-                if ( returnStmt->expr && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
-                        // explicitly construct the return value using the return expression and the retVal object
-                        assertf( returnVals.front()->name != "", "Function %s has unnamed return value\n", funcName.c_str() );
-                        ObjectDecl * retVal = strict_dynamic_cast< ObjectDecl * >( returnVals.front() );
-                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( returnStmt->expr ) ) {
-                                // return statement has already been mutated - don't need to do it again
-                                if ( varExpr->var == retVal ) return;
+                        }
-                        Statement * stmt = genCtorDtor( "?{}", retVal, returnStmt->expr );
-                        assertf( stmt, "ReturnFixer: genCtorDtor returned nullptr: %s / %s", toString( retVal ).c_str(), toString( returnStmt->expr ).c_str() );
-                        stmtsToAddBefore.push_back( stmt );
-                        // return the retVal object
-                        returnStmt->expr = new VariableExpr( returnVals.front() );
-                } // if
+        }
-        void ReturnFixer::premutate( FunctionDecl *functionDecl ) {
-                GuardValue( ftype );
-                GuardValue( funcName );
-                ftype = functionDecl->type;
-                funcName = functionDecl->name;
+        }
-        // precompute array dimension expression, because constructor generation may duplicate it,
-        // which would be incorrect if it is a side-effecting computation.
-        void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<HoistArrayDimension> hoister;
-                mutateAll( translationUnit, hoister );
+        }
-        void HoistArrayDimension::premutate( ObjectDecl * objectDecl ) {
-                GuardValue( storageClasses );
-                storageClasses = objectDecl->get_storageClasses();
+        }
-        DeclarationWithType * HoistArrayDimension::postmutate( ObjectDecl * objectDecl ) {
-                hoist( objectDecl->get_type() );
-                return objectDecl;
+        }
-        void HoistArrayDimension::hoist( Type * type ) {
-                // if in function, generate const size_t var
-                static UniqueName dimensionName( "_array_dim" );
-                // C doesn't allow variable sized arrays at global scope or for static variables, so don't hoist dimension.
-                if ( ! inFunction ) return;
-                if ( storageClasses.is_static ) return;
-                if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
-                        // need to resolve array dimensions in order to accurately determine if constexpr
-                        ResolvExpr::findSingleExpression( arrayType->dimension, Validate::SizeType->clone(), indexer );
-                        // array is variable-length when the dimension is not constexpr
-                        arrayType->isVarLen = ! isConstExpr( arrayType->dimension );
-                        // don't need to hoist dimension if it's definitely pure - only need to if there's potential for side effects.
-                        // xxx - hoisting has no side effects anyways, so don't skip since we delay resolve
-                        // still try to detect constant expressions
-                        if ( ! Tuples::maybeImpure( arrayType->dimension ) ) return;
-                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, Validate::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
-                        arrayDimension->get_type()->set_const( true );
-                        arrayType->set_dimension( new VariableExpr( arrayDimension ) );
-                        declsToAddBefore.push_back( arrayDimension );
-                        hoist( arrayType->get_base() );
-                        return;
+                }
+        }
-        void HoistArrayDimension::premutate( FunctionDecl * ) {
-                GuardValue( inFunction );
-                inFunction = true;
+        }
-        // precompute array dimension expression, because constructor generation may duplicate it,
-        // which would be incorrect if it is a side-effecting computation.
-        void HoistArrayDimension_NoResolve::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<HoistArrayDimension_NoResolve> hoister;
-                mutateAll( translationUnit, hoister );
+        }
-        void HoistArrayDimension_NoResolve::premutate( ObjectDecl * objectDecl ) {
-                GuardValue( storageClasses );
-                storageClasses = objectDecl->get_storageClasses();
+        }
-        DeclarationWithType * HoistArrayDimension_NoResolve::postmutate( ObjectDecl * objectDecl ) {
-                hoist( objectDecl->get_type() );
-                return objectDecl;
+        }
-        void HoistArrayDimension_NoResolve::hoist( Type * type ) {
-                // if in function, generate const size_t var
-                static UniqueName dimensionName( "_array_dim" );
-                // C doesn't allow variable sized arrays at global scope or for static variables, so don't hoist dimension.
-                if ( ! inFunction ) return;
-                if ( storageClasses.is_static ) return;
-                if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
-                        // don't need to hoist dimension if it's definitely pure - only need to if there's potential for side effects.
-                        // xxx - hoisting has no side effects anyways, so don't skip since we delay resolve
-                        // still try to detect constant expressions
-                        if ( ! Tuples::maybeImpure( arrayType->dimension ) ) return;
-                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, Validate::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
-                        arrayDimension->get_type()->set_const( true );
-                        arrayType->set_dimension( new VariableExpr( arrayDimension ) );
-                        declsToAddBefore.push_back( arrayDimension );
-                        hoist( arrayType->get_base() );
-                        return;
+                }
+        }
-        void HoistArrayDimension_NoResolve::premutate( FunctionDecl * ) {
-                GuardValue( inFunction );
-                inFunction = true;
+        }
 namespace {
 …
+        }
-        void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<CtorDtor> ctordtor;
-                acceptAll( translationUnit, ctordtor );
+        }
-        bool ManagedTypes::isManaged( Type * type ) const {
-                // references are never constructed
-                if ( dynamic_cast< ReferenceType * >( type ) ) return false;
-                // need to clear and reset qualifiers when determining if a type is managed
-                ValueGuard< Type::Qualifiers > qualifiers( type->get_qualifiers() );
-                type->get_qualifiers() = Type::Qualifiers();
-                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
-                        // tuple is also managed if any of its components are managed
-                        if ( std::any_of( tupleType->types.begin(), tupleType->types.end(), [&](Type * type) { return isManaged( type ); }) ) {
-                                return true;
+                        }
+                }
-                // a type is managed if it appears in the map of known managed types, or if it contains any polymorphism (is a type variable or generic type containing a type variable)
-                return managedTypes.find( SymTab::Mangler::mangleConcrete( type ) ) != managedTypes.end() || GenPoly::isPolyType( type );
+        }
-        bool ManagedTypes::isManaged( ObjectDecl * objDecl ) const {
-                Type * type = objDecl->get_type();
-                while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
-                        // must always construct VLAs with an initializer, since this is an error in C
-                        if ( at->isVarLen && objDecl->init ) return true;
-                        type = at->get_base();
+                }
-                return isManaged( type );
+        }
-        // why is this not just on FunctionDecl?
-        void ManagedTypes::handleDWT( DeclarationWithType * dwt ) {
-                // if this function is a user-defined constructor or destructor, mark down the type as "managed"
-                if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) {
-                        std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters();
-                        assert( ! params.empty() );
-                        Type * type = InitTweak::getPointerBase( params.front()->get_type() );
-                        assert( type );
-                        managedTypes.insert( SymTab::Mangler::mangleConcrete( type ) );
+                }
+        }
-        void ManagedTypes::handleStruct( StructDecl * aggregateDecl ) {
-                // don't construct members, but need to take note if there is a managed member,
-                // because that means that this type is also managed
-                for ( Declaration * member : aggregateDecl->get_members() ) {
-                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
-                                if ( isManaged( field ) ) {
-                                        // generic parameters should not play a role in determining whether a generic type is constructed - construct all generic types, so that
-                                        // polymorphic constructors make generic types managed types
-                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
-                                        managedTypes.insert( SymTab::Mangler::mangleConcrete( &inst ) );
-                                        break;
+                                }
+                        }
+                }
+        }
-        void ManagedTypes::beginScope() { managedTypes.beginScope(); }
-        void ManagedTypes::endScope() { managedTypes.endScope(); }
         bool ManagedTypes_new::isManaged( const ast::Type * type ) const {
                 // references are never constructed
 …
         void ManagedTypes_new::endScope() { managedTypes.endScope(); }
-        ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg ) {
-                // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
-                assertf( objDecl, "genCtorDtor passed null objDecl" );
-                std::list< Statement * > stmts;
-                InitExpander_old srcParam( maybeClone( arg ) );
-                SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), fname, back_inserter( stmts ), objDecl );
-                assert( stmts.size() <= 1 );
-                return stmts.size() == 1 ? strict_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;
+        }
         ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg) {
                 assertf(objDecl, "genCtorDtor passed null objDecl");
                 InitExpander_new srcParam(arg);
                 return SymTab::genImplicitCall(srcParam, new ast::VariableExpr(loc, objDecl), loc, fname, objDecl);
+        }
-        ConstructorInit * genCtorInit( ObjectDecl * objDecl ) {
-                // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
-                // for each constructable object
-                std::list< Statement * > ctor;
-                std::list< Statement * > dtor;
-                InitExpander_old srcParam( objDecl->get_init() );
-                InitExpander_old nullParam( (Initializer *)NULL );
-                SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
-                SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
-                // Currently genImplicitCall produces a single Statement - a CompoundStmt
-                // which  wraps everything that needs to happen. As such, it's technically
-                // possible to use a Statement ** in the above calls, but this is inherently
-                // unsafe, so instead we take the slightly less efficient route, but will be
-                // immediately informed if somehow the above assumption is broken. In this case,
-                // we could always wrap the list of statements at this point with a CompoundStmt,
-                // but it seems reasonable at the moment for this to be done by genImplicitCall
-                // itself. It is possible that genImplicitCall produces no statements (e.g. if
-                // an array type does not have a dimension). In this case, it's fine to ignore
-                // the object for the purposes of construction.
-                assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
-                if ( ctor.size() == 1 ) {
-                        // need to remember init expression, in case no ctors exist
-                        // if ctor does exist, want to use ctor expression instead of init
-                        // push this decision to the resolver
-                        assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
-                        return new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() );
+                }
-                return nullptr;
+        }
-        void CtorDtor::previsit( ObjectDecl * objDecl ) {
-                managedTypes.handleDWT( objDecl );
-                // hands off if @=, extern, builtin, etc.
-                // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C
-                if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
-                        // constructed objects cannot be designated
-                        if ( isDesignated( objDecl->get_init() ) ) SemanticError( objDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
-                        // constructed objects should not have initializers nested too deeply
-                        if ( ! checkInitDepth( objDecl ) ) SemanticError( objDecl, "Managed object's initializer is too deep " );
-                        objDecl->set_init( genCtorInit( objDecl ) );
+                }
+        }
-        void CtorDtor::previsit( FunctionDecl *functionDecl ) {
-                visit_children = false;  // do not try and construct parameters or forall parameters
-                GuardValue( inFunction );
-                inFunction = true;
-                managedTypes.handleDWT( functionDecl );
-                GuardScope( managedTypes );
-                // go through assertions and recursively add seen ctor/dtors
-                for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
-                        for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
-                                managedTypes.handleDWT( assertion );
+                        }
+                }
-                maybeAccept( functionDecl->get_statements(), *visitor );
+        }
-        void CtorDtor::previsit( StructDecl *aggregateDecl ) {
-                visit_children = false; // do not try to construct and destruct aggregate members
-                managedTypes.handleStruct( aggregateDecl );
+        }
-        void CtorDtor::previsit( CompoundStmt * ) {
-                GuardScope( managedTypes );
+        }

src/InitTweak/GenInit.h

-              r0030b508
+              rfc12f05
 #include "Common/CodeLocation.h"
 #include "GenPoly/ScopedSet.h" // for ScopedSet
-#include "SynTree/SynTree.h"   // for Visitor Nodes
 namespace InitTweak {
         /// Adds return value temporaries and wraps Initializers in ConstructorInit nodes
-        void genInit( std::list< Declaration * > & translationUnit );
         void genInit( ast::TranslationUnit & translationUnit );
         /// Converts return statements into copy constructor calls on the hidden return variable.
         /// This pass must happen before auto-gen.
-        void fixReturnStatements( std::list< Declaration * > & translationUnit );
         void fixReturnStatements( ast::TranslationUnit & translationUnit );
         /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
-        ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
         ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg = nullptr);
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
-        ConstructorInit * genCtorInit( ObjectDecl * objDecl );
         ast::ConstructorInit * genCtorInit( const CodeLocation & loc, const ast::ObjectDecl * objDecl );
-        class ManagedTypes {
-        public:
-                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
-                bool isManaged( Type * type ) const; // determine if type is managed
-                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
-                void handleStruct( StructDecl * aggregateDecl ); // add type to managed if child is managed
-                void beginScope();
-                void endScope();
-        private:
-                GenPoly::ScopedSet< std::string > managedTypes;
-        };
         class ManagedTypes_new {

src/InitTweak/InitTweak.cc

-              r0030b508
+              rfc12f05
 #include "AST/Type.hpp"
 #include "CodeGen/OperatorTable.h" // for isConstructor, isDestructor, isCto...
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
 …
 #include "InitTweak.h"
 #include "ResolvExpr/Unify.h"      // for typesCompatibleIgnoreQualifiers
-#include "SymTab/Autogen.h"
-#include "SymTab/Indexer.h"        // for Indexer
-#include "SynTree/LinkageSpec.h"   // for Spec, isBuiltin, Intrinsic
-#include "SynTree/Attribute.h"     // for Attribute
-#include "SynTree/Constant.h"      // for Constant
-#include "SynTree/Declaration.h"   // for ObjectDecl, DeclarationWithType
-#include "SynTree/Expression.h"    // for Expression, UntypedExpr, Applicati...
-#include "SynTree/Initializer.h"   // for Initializer, ListInit, Designation
-#include "SynTree/Label.h"         // for Label
-#include "SynTree/Statement.h"     // for CompoundStmt, ExprStmt, BranchStmt
-#include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
-#include "SynTree/Visitor.h"       // for Visitor, maybeAccept
 #include "Tuples/Tuples.h"         // for Tuples::isTtype
 namespace InitTweak {
         namespace {
-                struct HasDesignations : public WithShortCircuiting {
-                        bool hasDesignations = false;
-                        void previsit( BaseSyntaxNode * ) {
-                                // short circuit if we already know there are designations
-                                if ( hasDesignations ) visit_children = false;
+                        }
-                        void previsit( Designation * des ) {
-                                // short circuit if we already know there are designations
-                                if ( hasDesignations ) visit_children = false;
-                                else if ( ! des->get_designators().empty() ) {
-                                        hasDesignations = true;
-                                        visit_children = false;
+                                }
+                        }
-                };
-                struct InitDepthChecker : public WithGuards {
-                        bool depthOkay = true;
-                        Type * type;
-                        int curDepth = 0, maxDepth = 0;
-                        InitDepthChecker( Type * type ) : type( type ) {
-                                Type * t = type;
-                                while ( ArrayType * at = dynamic_cast< ArrayType * >( t ) ) {
-                                        maxDepth++;
-                                        t = at->get_base();
+                                }
-                                maxDepth++;
+                        }
-                        void previsit( ListInit * ) {
-                                curDepth++;
-                                GuardAction( [this]() { curDepth--; } );
-                                if ( curDepth > maxDepth ) depthOkay = false;
+                        }
-                };
                 struct HasDesignations_new : public ast::WithShortCircuiting {
                         bool result = false;
 …
                 };
                 struct InitDepthChecker_new : public ast::WithGuards {
+                struct InitDepthChecker_new {
                         bool result = true;
                         const ast::Type * type;
 …
                                 maxDepth++;
+                        }
                         void previsit( ListInit * ) {
+                        void previsit( ast::ListInit const * ) {
                                 curDepth++;
-                                GuardAction( [this]() { curDepth--; } );
                                 if ( curDepth > maxDepth ) result = false;
+                        }
+                };
+                struct InitFlattener_old : public WithShortCircuiting {
+                        void previsit( SingleInit * singleInit ) {
+                                visit_children = false;
+                                argList.push_back( singleInit->value->clone() );
+                        }
+                        std::list< Expression * > argList;
+                        void postvisit( ast::ListInit const * ) {
+                                curDepth--;
+                        }
                 };
 …
         } // anonymous namespace
-        std::list< Expression * > makeInitList( Initializer * init ) {
-                PassVisitor<InitFlattener_old> flattener;
-                maybeAccept( init, flattener );
-                return flattener.pass.argList;
+        }
-        bool isDesignated( Initializer * init ) {
-                PassVisitor<HasDesignations> finder;
-                maybeAccept( init, finder );
-                return finder.pass.hasDesignations;
+        }
-        bool checkInitDepth( ObjectDecl * objDecl ) {
-                PassVisitor<InitDepthChecker> checker( objDecl->type );
-                maybeAccept( objDecl->init, checker );
-                return checker.pass.depthOkay;
+        }
         bool isDesignated( const ast::Init * init ) {
 …
         return std::move( flattener.core.argList );
+}
-        class InitExpander_old::ExpanderImpl {
-        public:
-                virtual ~ExpanderImpl() = default;
-                virtual std::list< Expression * > next( std::list< Expression * > & indices ) = 0;
-                virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices ) = 0;
-        };
-        class InitImpl_old : public InitExpander_old::ExpanderImpl {
-        public:
-                InitImpl_old( Initializer * init ) : init( init ) {}
-                virtual ~InitImpl_old() = default;
-                virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
-                        // this is wrong, but just a placeholder for now
-                        // if ( ! flattened ) flatten( indices );
-                        // return ! inits.empty() ? makeInitList( inits.front() ) : std::list< Expression * >();
-                        return makeInitList( init );
+                }
-                virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices );
-        private:
-                Initializer * init;
-        };
-        class ExprImpl_old : public InitExpander_old::ExpanderImpl {
-        public:
-                ExprImpl_old( Expression * expr ) : arg( expr ) {}
-                virtual ~ExprImpl_old() { delete arg; }
-                virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
-                        std::list< Expression * > ret;
-                        Expression * expr = maybeClone( arg );
-                        if ( expr ) {
-                                for ( std::list< Expression * >::reverse_iterator it = indices.rbegin(); it != indices.rend(); ++it ) {
-                                        // go through indices and layer on subscript exprs ?[?]
-                                        ++it;
-                                        UntypedExpr * subscriptExpr = new UntypedExpr( new NameExpr( "?[?]") );
-                                        subscriptExpr->get_args().push_back( expr );
-                                        subscriptExpr->get_args().push_back( (*it)->clone() );
-                                        expr = subscriptExpr;
+                                }
-                                ret.push_back( expr );
+                        }
-                        return ret;
+                }
-                virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices );
-        private:
-                Expression * arg;
-        };
-        InitExpander_old::InitExpander_old( Initializer * init ) : expander( new InitImpl_old( init ) ) {}
-        InitExpander_old::InitExpander_old( Expression * expr ) : expander( new ExprImpl_old( expr ) ) {}
-        std::list< Expression * > InitExpander_old::operator*() {
-                return cur;
+        }
-        InitExpander_old & InitExpander_old::operator++() {
-                cur = expander->next( indices );
-                return *this;
+        }
-        // use array indices list to build switch statement
-        void InitExpander_old::addArrayIndex( Expression * index, Expression * dimension ) {
-                indices.push_back( index );
-                indices.push_back( dimension );
+        }
-        void InitExpander_old::clearArrayIndices() {
-                deleteAll( indices );
-                indices.clear();
+        }
-        bool InitExpander_old::addReference() {
-                bool added = false;
-                for ( Expression *& expr : cur ) {
-                        expr = new AddressExpr( expr );
-                        added = true;
+                }
-                return added;
+        }
-        namespace {
-                /// given index i, dimension d, initializer init, and callExpr f, generates
-                ///   if (i < d) f(..., init)
-                ///   ++i;
-                /// so that only elements within the range of the array are constructed
-                template< typename OutIterator >
-                void buildCallExpr( UntypedExpr * callExpr, Expression * index, Expression * dimension, Initializer * init, OutIterator out ) {
-                        UntypedExpr * cond = new UntypedExpr( new NameExpr( "?<?") );
-                        cond->get_args().push_back( index->clone() );
-                        cond->get_args().push_back( dimension->clone() );
-                        std::list< Expression * > args = makeInitList( init );
-                        callExpr->get_args().splice( callExpr->get_args().end(), args );
-                        *out++ = new IfStmt( cond, new ExprStmt( callExpr ), nullptr );
-                        UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
-                        increment->get_args().push_back( index->clone() );
-                        *out++ = new ExprStmt( increment );
+                }
-                template< typename OutIterator >
-                void build( UntypedExpr * callExpr, InitExpander_old::IndexList::iterator idx, InitExpander_old::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) {
-                        if ( idx == idxEnd ) return;
-                        Expression * index = *idx++;
-                        assert( idx != idxEnd );
-                        Expression * dimension = *idx++;
-                        // xxx - may want to eventually issue a warning here if we can detect
-                        // that the number of elements exceeds to dimension of the array
-                        if ( idx == idxEnd ) {
-                                if ( ListInit * listInit = dynamic_cast< ListInit * >( init ) ) {
-                                        for ( Initializer * init : *listInit ) {
-                                                buildCallExpr( callExpr->clone(), index, dimension, init, out );
+                                        }
-                                } else {
-                                        buildCallExpr( callExpr->clone(), index, dimension, init, out );
+                                }
-                        } else {
-                                std::list< Statement * > branches;
-                                unsigned long cond = 0;
-                                ListInit * listInit = dynamic_cast< ListInit * >( init );
-                                if ( ! listInit ) {
-                                        // xxx - this shouldn't be an error, but need a way to
-                                        // terminate without creating output, so should catch this error
-                                        SemanticError( init->location, "unbalanced list initializers" );
+                                }
-                                static UniqueName targetLabel( "L__autogen__" );
-                                Label switchLabel( targetLabel.newName(), 0, std::list< Attribute * >{ new Attribute("unused") } );
-                                for ( Initializer * init : *listInit ) {
-                                        Expression * condition;
-                                        // check for designations
-                                        // if ( init-> ) {
-                                                condition = new ConstantExpr( Constant::from_ulong( cond ) );
-                                                ++cond;
-                                        // } else {
-                                        //      condition = // ... take designation
-                                        //      cond = // ... take designation+1
-                                        // }
-                                        std::list< Statement * > stmts;
-                                        build( callExpr, idx, idxEnd, init, back_inserter( stmts ) );
-                                        stmts.push_back( new BranchStmt( switchLabel, BranchStmt::Break ) );
-                                        CaseStmt * caseStmt = new CaseStmt( condition, stmts );
-                                        branches.push_back( caseStmt );
+                                }
-                                *out++ = new SwitchStmt( index->clone(), branches );
-                                *out++ = new NullStmt( { switchLabel } );
+                        }
+                }
+        }
-        // if array came with an initializer list: initialize each element
-        // may have more initializers than elements in the array - need to check at each index that
-        // we haven't exceeded size.
-        // may have fewer initializers than elements in the array - need to default construct
-        // remaining elements.
-        // To accomplish this, generate switch statement, consuming all of expander's elements
-        Statement * InitImpl_old::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
-                if ( ! init ) return nullptr;
-                CompoundStmt * block = new CompoundStmt();
-                build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
-                if ( block->get_kids().empty() ) {
-                        delete block;
-                        return nullptr;
-                } else {
-                        init = nullptr; // init was consumed in creating the list init
-                        return block;
+                }
+        }
-        Statement * ExprImpl_old::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
-                return nullptr;
+        }
-        Statement * InitExpander_old::buildListInit( UntypedExpr * dst ) {
-                return expander->buildListInit( dst, indices );
+        }
 class InitExpander_new::ExpanderImpl {
 …
+}
-        Type * getTypeofThis( FunctionType * ftype ) {
-                assertf( ftype, "getTypeofThis: nullptr ftype" );
-                ObjectDecl * thisParam = getParamThis( ftype );
-                ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( thisParam->type );
-                return refType->base;
+        }
         const ast::Type * getTypeofThis( const ast::FunctionType * ftype ) {
                 assertf( ftype, "getTypeofThis: nullptr ftype" );
 …
+        }
-        ObjectDecl * getParamThis( FunctionType * ftype ) {
-                assertf( ftype, "getParamThis: nullptr ftype" );
-                auto & params = ftype->parameters;
-                assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( ftype ).c_str() );
-                return strict_dynamic_cast< ObjectDecl * >( params.front() );
+        }
         const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func) {
                 assertf( func, "getParamThis: nullptr ftype" );
 …
                 assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( func ).c_str());
                 return params.front().strict_as<ast::ObjectDecl>();
+        }
-        bool tryConstruct( DeclarationWithType * dwt ) {
-                ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
-                if ( ! objDecl ) return false;
-                return (objDecl->get_init() == nullptr ||
-                                ( objDecl->get_init() != nullptr && objDecl->get_init()->get_maybeConstructed() ))
-                        && ! objDecl->get_storageClasses().is_extern
-                        && isConstructable( objDecl->type );
+        }
-        bool isConstructable( Type * type ) {
-                return ! dynamic_cast< VarArgsType * >( type ) && ! dynamic_cast< ReferenceType * >( type ) && ! dynamic_cast< FunctionType * >( type ) && ! Tuples::isTtype( type );
+        }
 …
+        }
-        struct CallFinder_old {
-                CallFinder_old( const std::list< std::string > & names ) : names( names ) {}
-                void postvisit( ApplicationExpr * appExpr ) {
-                        handleCallExpr( appExpr );
+                }
-                void postvisit( UntypedExpr * untypedExpr ) {
-                        handleCallExpr( untypedExpr );
+                }
-                std::list< Expression * > * matches;
-        private:
-                const std::list< std::string > names;
-                template< typename CallExpr >
-                void handleCallExpr( CallExpr * expr ) {
-                        std::string fname = getFunctionName( expr );
-                        if ( std::find( names.begin(), names.end(), fname ) != names.end() ) {
-                                matches->push_back( expr );
+                        }
+                }
-        };
         struct CallFinder_new final {
                 std::vector< const ast::Expr * > matches;
 …
         };
-        void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches ) {
-                static PassVisitor<CallFinder_old> finder( std::list< std::string >{ "?{}", "^?{}" } );
-                finder.pass.matches = &matches;
-                maybeAccept( stmt, finder );
+        }
         std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt ) {
                 ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
 …
+        }
-        Expression * getCtorDtorCall( Statement * stmt ) {
-                std::list< Expression * > matches;
-                collectCtorDtorCalls( stmt, matches );
-                assertf( matches.size() <= 1, "%zd constructor/destructors found in %s", matches.size(), toString( stmt ).c_str() );
-                return matches.size() == 1 ? matches.front() : nullptr;
+        }
         namespace {
-                DeclarationWithType * getCalledFunction( Expression * expr );
-                template<typename CallExpr>
-                DeclarationWithType * handleDerefCalledFunction( CallExpr * expr ) {
-                        // (*f)(x) => should get "f"
-                        std::string name = getFunctionName( expr );
-                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
-                        assertf( ! expr->get_args().empty(), "Cannot get called function from dereference with no arguments" );
-                        return getCalledFunction( expr->get_args().front() );
+                }
-                DeclarationWithType * getCalledFunction( Expression * expr ) {
-                        assert( expr );
-                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
-                                return varExpr->var;
-                        } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) {
-                                return memberExpr->member;
-                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                                return getCalledFunction( castExpr->arg );
-                        } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
-                                return handleDerefCalledFunction( untypedExpr );
-                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
-                                return handleDerefCalledFunction( appExpr );
-                        } else if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
-                                return getCalledFunction( addrExpr->arg );
-                        } else if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( expr ) ) {
-                                return getCalledFunction( commaExpr->arg2 );
+                        }
-                        return nullptr;
+                }
-                DeclarationWithType * getFunctionCore( const Expression * expr ) {
-                        if ( const auto * appExpr = dynamic_cast< const ApplicationExpr * >( expr ) ) {
-                                return getCalledFunction( appExpr->function );
-                        } else if ( const auto * untyped = dynamic_cast< const UntypedExpr * >( expr ) ) {
-                                return getCalledFunction( untyped->function );
+                        }
-                        assertf( false, "getFunction with unknown expression: %s", toString( expr ).c_str() );
+                }
+        }
-        DeclarationWithType * getFunction( Expression * expr ) {
-                return getFunctionCore( expr );
+        }
-        const DeclarationWithType * getFunction( const Expression * expr ) {
-                return getFunctionCore( expr );
+        }
-        ApplicationExpr * isIntrinsicCallExpr( Expression * expr ) {
-                ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr );
-                if ( ! appExpr ) return nullptr;
-                DeclarationWithType * function = getCalledFunction( appExpr->get_function() );
-                assertf( function, "getCalledFunction returned nullptr: %s", toString( appExpr->get_function() ).c_str() );
-                // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
-                // will call all member dtors, and some members may have a user defined dtor.
-                return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : nullptr;
+        }
-        namespace {
-                template <typename Predicate>
-                bool allofCtorDtor( Statement * stmt, const Predicate & pred ) {
-                        std::list< Expression * > callExprs;
-                        collectCtorDtorCalls( stmt, callExprs );
-                        return std::all_of( callExprs.begin(), callExprs.end(), pred);
+                }
                 template <typename Predicate>
                 bool allofCtorDtor( const ast::Stmt * stmt, const Predicate & pred ) {
 …
                         return std::all_of( callExprs.begin(), callExprs.end(), pred );
+                }
+        }
-        bool isIntrinsicSingleArgCallStmt( Statement * stmt ) {
-                return allofCtorDtor( stmt, []( Expression * callExpr ){
-                        if ( ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
-                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->function->result );
-                                assert( funcType );
-                                return funcType->get_parameters().size() == 1;
+                        }
-                        return false;
-                });
+        }
 …
                         return false;
                 });
+        }
-        bool isIntrinsicCallStmt( Statement * stmt ) {
-                return allofCtorDtor( stmt, []( Expression * callExpr ) {
-                        return isIntrinsicCallExpr( callExpr );
-                });
+        }
-        namespace {
-                template<typename CallExpr>
-                Expression *& callArg( CallExpr * callExpr, unsigned int pos ) {
-                        if ( pos >= callExpr->get_args().size() ) assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.", pos, toString( callExpr ).c_str() );
-                        for ( Expression *& arg : callExpr->get_args() ) {
-                                if ( pos == 0 ) return arg;
-                                pos--;
+                        }
-                        assert( false );
+                }
+        }
-        Expression *& getCallArg( Expression * callExpr, unsigned int pos ) {
-                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr ) ) {
-                        return callArg( appExpr, pos );
-                } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( callExpr ) ) {
-                        return callArg( untypedExpr, pos );
-                } else if ( TupleAssignExpr * tupleExpr = dynamic_cast< TupleAssignExpr * > ( callExpr ) ) {
-                        std::list< Statement * > & stmts = tupleExpr->get_stmtExpr()->get_statements()->get_kids();
-                        assertf( ! stmts.empty(), "TupleAssignExpr somehow has no statements." );
-                        ExprStmt * stmt = strict_dynamic_cast< ExprStmt * >( stmts.back() );
-                        TupleExpr * tuple = strict_dynamic_cast< TupleExpr * >( stmt->get_expr() );
-                        assertf( ! tuple->get_exprs().empty(), "TupleAssignExpr somehow has empty tuple expr." );
-                        return getCallArg( tuple->get_exprs().front(), pos );
-                } else if ( ImplicitCopyCtorExpr * copyCtor = dynamic_cast< ImplicitCopyCtorExpr * >( callExpr ) ) {
-                        return getCallArg( copyCtor->callExpr, pos );
-                } else {
-                        assertf( false, "Unexpected expression type passed to getCallArg: %s", toString( callExpr ).c_str() );
+                }
+        }
-        namespace {
-                std::string funcName( Expression * func );
-                template<typename CallExpr>
-                std::string handleDerefName( CallExpr * expr ) {
-                        // (*f)(x) => should get name "f"
-                        std::string name = getFunctionName( expr );
-                        assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
-                        assertf( ! expr->get_args().empty(), "Cannot get function name from dereference with no arguments" );
-                        return funcName( expr->get_args().front() );
+                }
-                std::string funcName( Expression * func ) {
-                        if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
-                                return nameExpr->get_name();
-                        } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
-                                return varExpr->get_var()->get_name();
-                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
-                                return funcName( castExpr->get_arg() );
-                        } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( func ) ) {
-                                return memberExpr->get_member()->get_name();
-                        } else if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * > ( func ) ) {
-                                return funcName( memberExpr->get_member() );
-                        } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( func ) ) {
-                                return handleDerefName( untypedExpr );
-                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( func ) ) {
-                                return handleDerefName( appExpr );
-                        } else if ( ConstructorExpr * ctorExpr = dynamic_cast< ConstructorExpr * >( func ) ) {
-                                return funcName( getCallArg( ctorExpr->get_callExpr(), 0 ) );
-                        } else {
-                                assertf( false, "Unexpected expression type being called as a function in call expression: %s", toString( func ).c_str() );
+                        }
+                }
+        }
-        std::string getFunctionName( Expression * expr ) {
-                // there's some unforunate overlap here with getCalledFunction. Ideally this would be able to use getCalledFunction and
-                // return the name of the DeclarationWithType, but this needs to work for NameExpr and UntypedMemberExpr, where getCalledFunction
-                // can't possibly do anything reasonable.
-                if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
-                        return funcName( appExpr->get_function() );
-                } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * > ( expr ) ) {
-                        return funcName( untypedExpr->get_function() );
-                } else {
-                        std::cerr << expr << std::endl;
-                        assertf( false, "Unexpected expression type passed to getFunctionName" );
+                }
+        }
-        Type * getPointerBase( Type * type ) {
-                if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
-                        return ptrType->get_base();
-                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        return arrayType->get_base();
-                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
-                        return refType->get_base();
-                } else {
-                        return nullptr;
+                }
+        }
-        Type * isPointerType( Type * type ) {
-                return getPointerBase( type ) ? type : nullptr;
+        }
-        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src ) {
-                static FunctionDecl * assign = nullptr;
-                if ( ! assign ) {
-                        // temporary? Generate a fake assignment operator to represent bitwise assignments.
-                        // This operator could easily exist as a real function, but it's tricky because nothing should resolve to this function.
-                        TypeDecl * td = new TypeDecl( "T", noStorageClasses, nullptr, TypeDecl::Dtype, true );
-                        assign = new FunctionDecl( "?=?", noStorageClasses, LinkageSpec::Intrinsic, SymTab::genAssignType( new TypeInstType( noQualifiers, td->name, td ) ), nullptr );
+                }
-                if ( dynamic_cast< ReferenceType * >( dst->result ) ) {
-                        for (int depth = dst->result->referenceDepth(); depth > 0; depth--) {
-                                dst = new AddressExpr( dst );
+                        }
-                } else {
-                        dst = new CastExpr( dst, new ReferenceType( noQualifiers, dst->result->clone() ) );
+                }
-                if ( dynamic_cast< ReferenceType * >( src->result ) ) {
-                        for (int depth = src->result->referenceDepth(); depth > 0; depth--) {
-                                src = new AddressExpr( src );
+                        }
+                }
-                return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
+        }
 …
                 return app;
+        }
-        struct ConstExprChecker : public WithShortCircuiting {
-                // most expressions are not const expr
-                void previsit( Expression * ) { isConstExpr = false; visit_children = false; }
-                void previsit( AddressExpr *addressExpr ) {
-                        visit_children = false;
-                        // address of a variable or member expression is constexpr
-                        Expression * arg = addressExpr->get_arg();
-                        if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
+                }
-                // these expressions may be const expr, depending on their children
-                void previsit( SizeofExpr * ) {}
-                void previsit( AlignofExpr * ) {}
-                void previsit( UntypedOffsetofExpr * ) {}
-                void previsit( OffsetofExpr * ) {}
-                void previsit( OffsetPackExpr * ) {}
-                void previsit( CommaExpr * ) {}
-                void previsit( LogicalExpr * ) {}
-                void previsit( ConditionalExpr * ) {}
-                void previsit( CastExpr * ) {}
-                void previsit( ConstantExpr * ) {}
-                void previsit( VariableExpr * varExpr ) {
-                        visit_children = false;
-                        if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( varExpr->result ) ) {
-                                long long int value;
-                                if ( inst->baseEnum->valueOf( varExpr->var, value ) ) {
-                                        // enumerators are const expr
-                                        return;
+                                }
+                        }
-                        isConstExpr = false;
+                }
-                bool isConstExpr = true;
-        };
         struct ConstExprChecker_new : public ast::WithShortCircuiting {
 …
         };
-        bool isConstExpr( Expression * expr ) {
-                if ( expr ) {
-                        PassVisitor<ConstExprChecker> checker;
-                        expr->accept( checker );
-                        return checker.pass.isConstExpr;
+                }
-                return true;
+        }
-        bool isConstExpr( Initializer * init ) {
-                if ( init ) {
-                        PassVisitor<ConstExprChecker> checker;
-                        init->accept( checker );
-                        return checker.pass.isConstExpr;
-                } // if
-                // for all intents and purposes, no initializer means const expr
-                return true;
+        }
         bool isConstExpr( const ast::Expr * expr ) {
                 if ( expr ) {
 …
+        }
-        const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname ) {
-                const FunctionDecl * function = dynamic_cast< const FunctionDecl * >( decl );
-                if ( ! function ) return nullptr;
-                if ( function->name != fname ) return nullptr;
-                FunctionType * ftype = function->type;
-                if ( ftype->parameters.size() != 2 ) return nullptr;
-                Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
-                Type * t2 = ftype->parameters.back()->get_type();
-                assert( t1 );
-                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, SymTab::Indexer() ) ) {
-                        return function;
-                } else {
-                        return nullptr;
+                }
+        }
 bool isAssignment( const ast::FunctionDecl * decl ) {
         return CodeGen::isAssignment( decl->name ) && isCopyFunction( decl );
 …
         return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2 );
+}
-        const FunctionDecl * isAssignment( const Declaration * decl ) {
-                return isCopyFunction( decl, "?=?" );
+        }
-        const FunctionDecl * isDestructor( const Declaration * decl ) {
-                if ( CodeGen::isDestructor( decl->name ) ) {
-                        return dynamic_cast< const FunctionDecl * >( decl );
+                }
-                return nullptr;
+        }
-        const FunctionDecl * isDefaultConstructor( const Declaration * decl ) {
-                if ( CodeGen::isConstructor( decl->name ) ) {
-                        if ( const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl ) ) {
-                                if ( func->type->parameters.size() == 1 ) {
-                                        return func;
+                                }
+                        }
+                }
-                return nullptr;
+        }
-        const FunctionDecl * isCopyConstructor( const Declaration * decl ) {
-                return isCopyFunction( decl, "?{}" );
+        }
         #if defined( __x86_64 ) || defined( __i386 ) // assembler comment to prevent assembler warning message
 …
         static const char * const data_section =  ".data" ASM_COMMENT;
         static const char * const tlsd_section = ".tdata" ASM_COMMENT;
-        void addDataSectionAttribute( ObjectDecl * objDecl ) {
-                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", {
-                        new ConstantExpr( Constant::from_string( section ) )
-                }));
+        }
         void addDataSectionAttribute( ast::ObjectDecl * objDecl ) {

src/InitTweak/InitTweak.h

-              r0030b508
+              rfc12f05
 #include "AST/Fwd.hpp"        // for AST nodes
-#include "SynTree/SynTree.h"  // for Visitor Nodes
 // helper functions for initialization
 namespace InitTweak {
-        const FunctionDecl * isAssignment( const Declaration * decl );
-        const FunctionDecl * isDestructor( const Declaration * decl );
-        const FunctionDecl * isDefaultConstructor( const Declaration * decl );
-        const FunctionDecl * isCopyConstructor( const Declaration * decl );
-        const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname );
         bool isAssignment( const ast::FunctionDecl * decl );
         bool isDestructor( const ast::FunctionDecl * decl );
 …
         /// returns the base type of the first parameter to a constructor/destructor/assignment function
-        Type * getTypeofThis( FunctionType * ftype );
         const ast::Type * getTypeofThis( const ast::FunctionType * ftype );
         /// returns the first parameter of a constructor/destructor/assignment function
-        ObjectDecl * getParamThis( FunctionType * ftype );
         const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func);
         /// generate a bitwise assignment operation.
-        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
         ast::Expr * createBitwiseAssignment( const ast::Expr * dst, const ast::Expr * src);
         /// transform Initializer into an argument list that can be passed to a call expression
-        std::list< Expression * > makeInitList( Initializer * init );
         std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init );
         /// True if the resolver should try to construct dwt
-        bool tryConstruct( DeclarationWithType * dwt );
         bool tryConstruct( const ast::DeclWithType * dwt );
         /// True if the type can have a user-defined constructor
-        bool isConstructable( Type * t );
         bool isConstructable( const ast::Type * t );
         /// True if the Initializer contains designations
-        bool isDesignated( Initializer * init );
         bool isDesignated( const ast::Init * init );
         /// True if the ObjectDecl's Initializer nesting level is not deeper than the depth of its
         /// type, where the depth of its type is the number of nested ArrayTypes + 1
-        bool checkInitDepth( ObjectDecl * objDecl );
         bool checkInitDepth( const ast::ObjectDecl * objDecl );
-        /// returns the declaration of the function called by the expr (must be ApplicationExpr or UntypedExpr)
-        DeclarationWithType * getFunction( Expression * expr );
-        const DeclarationWithType * getFunction( const Expression * expr );
-        /// Non-Null if expr is a call expression whose target function is intrinsic
-        ApplicationExpr * isIntrinsicCallExpr( Expression * expr );
         /// True if stmt is a call statement where the function called is intrinsic and takes one parameter.
         /// Intended to be used for default ctor/dtor calls, but might have use elsewhere.
         /// Currently has assertions that make it less than fully general.
-        bool isIntrinsicSingleArgCallStmt( Statement * stmt );
         bool isIntrinsicSingleArgCallStmt( const ast::Stmt * stmt );
-        /// True if stmt is a call statement where the function called is intrinsic.
-        bool isIntrinsicCallStmt( Statement * stmt );
         /// get all Ctor/Dtor call expressions from a Statement
-        void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches );
         std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt );
-        /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
-        Expression * getCtorDtorCall( Statement * stmt );
-        /// returns the name of the function being called
-        std::string getFunctionName( Expression * expr );
-        /// returns the argument to a call expression in position N indexed from 0
-        Expression *& getCallArg( Expression * callExpr, unsigned int pos );
-        /// returns the base type of a PointerType or ArrayType, else returns NULL
-        Type * getPointerBase( Type * );
-        /// returns the argument if it is a PointerType or ArrayType, else returns NULL
-        Type * isPointerType( Type * );
         /// returns true if expr is trivially a compile-time constant
-        bool isConstExpr( Expression * expr );
-        bool isConstExpr( Initializer * init );
         bool isConstExpr( const ast::Expr * expr );
         bool isConstExpr( const ast::Init * init );
 …
         ///    .section .data#,"a"
         /// to avoid assembler warning "ignoring changed section attributes for .data"
-        void addDataSectionAttribute( ObjectDecl * objDecl );
         void addDataSectionAttribute( ast::ObjectDecl * objDecl );
-        class InitExpander_old {
-        public:
-                // expand by stepping through init to get each list of arguments
-                InitExpander_old( Initializer * init );
-                // always expand to expr
-                InitExpander_old( Expression * expr );
-                // iterator-like interface
-                std::list< Expression * > operator*();
-                InitExpander_old & operator++();
-                // builds statement which has the same semantics as a C-style list initializer
-                // (for array initializers) using callExpr as the base expression to perform initialization
-                Statement * buildListInit( UntypedExpr * callExpr );
-                void addArrayIndex( Expression * index, Expression * dimension );
-                void clearArrayIndices();
-                bool addReference();
-                class ExpanderImpl;
-                typedef std::list< Expression * > IndexList;
-        private:
-                std::shared_ptr< ExpanderImpl > expander;
-                std::list< Expression * > cur;
-                // invariant: list of size 2N (elements come in pairs [index, dimension])
-                IndexList indices;
-        };
         class InitExpander_new {

src/InitTweak/module.mk

r0030b508	rfc12f05
24	24	InitTweak/FixGlobalInit.cc \
25	25	InitTweak/FixGlobalInit.h \
26		~~InitTweak/FixInit.cc \~~
27	26	InitTweak/FixInit.h \
28	27	InitTweak/FixInitNew.cpp

src/MakeLibCfa.h

r0030b508	rfc12f05
24	24
25	25	namespace LibCfa {
26		~~void makeLibCfa( std::list< Declaration* > &prelude );~~
27	26	void makeLibCfa( ast::TranslationUnit & translationUnit );
28	27	} // namespace LibCfa

src/Makefile.am

-              r0030b508
+              rfc12f05
       CompilationState.cc \
       CompilationState.h \
-      MakeLibCfa.cc \
           MakeLibCfaNew.cpp \
         MakeLibCfa.h
 …
 include AST/module.mk
 include CodeGen/module.mk
-include CodeTools/module.mk
 include Concurrency/module.mk
 include Common/module.mk
 …
 include ResolvExpr/module.mk
 include SymTab/module.mk
-include SynTree/module.mk
 include Tuples/module.mk
 include Validate/module.mk
 include Virtual/module.mk
 $(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/SynTree/Type.h
+$(addprefix $(srcdir)/, ResolvExpr/ConversionCost.cc ResolvExpr/CommonType.cc SymTab/ManglerCommon.cc) : $(srcdir)/AST/Type.hpp
 $(srcdir)/AST/Type.hpp : BasicTypes-gen.cc

src/Parser/RunParser.cpp

-              r0030b508
+              rfc12f05
 #include "RunParser.hpp"
-#include "AST/Convert.hpp"                  // for convert
 #include "AST/TranslationUnit.hpp"          // for TranslationUnit
-#include "CodeTools/TrackLoc.h"             // for fillLocations
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
 #include "Parser/DeclarationNode.h"         // for DeclarationNode, buildList

src/Parser/StatementNode.cc

-              r0030b508
+              rfc12f05
 } // build_corun
+ast::Stmt * build_cofor( const CodeLocation & location, ForCtrl * forctl, StatementNode * stmt ) {
+        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
+        buildMoveList( forctl->init, astinit );
+        ast::Expr * astcond = nullptr;                                          // maybe empty
+        astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );
+        ast::Expr * astincr = nullptr;                                          // maybe empty
+        astincr = maybeMoveBuild( forctl->change );
+        delete forctl;
+        return new ast::CoforStmt( location,
+                std::move( astinit ),
+                astcond,
+                astincr,
+                buildMoveSingle( stmt )
+        );
+} // build_cofor
 // Local Variables: //
 // tab-width: 4 //

src/Parser/StatementNode.h

r0030b508	rfc12f05
106	106	ast::Stmt * build_mutex( const CodeLocation &, ExpressionNode * exprs, StatementNode * stmt );
107	107	ast::Stmt * build_corun( const CodeLocation &, StatementNode * stmt );
	108	ast::Stmt * build_cofor( const CodeLocation & location, ForCtrl * forctl, StatementNode * stmt );

src/Parser/parser.yy

-              r0030b508
+              rfc12f05
 using namespace std;
-#include "SynTree/Type.h"                               // for Type
 #include "DeclarationNode.h"                            // for DeclarationNode, ...
 #include "ExpressionNode.h"                             // for ExpressionNode, ...
 …
 #include "Common/SemanticError.h"                                               // error_str
 #include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
-#include "SynTree/Attribute.h"                                                  // for Attribute
 // lex uses __null in a boolean context, it's fine.
 …
 cofor_statement:
         COFOR '(' for_control_expression_list ')' statement
                 { SemanticError( yylloc, "cofor statement is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new StatementNode( build_cofor( yylloc, $3, maybe_build_compound( yylloc, $5 ) ) ); }
+        ;
 …
 type_qualifier_name:
         CONST
                 { $$ = DeclarationNode::newTypeQualifier( Type::Const ); }
+                { $$ = DeclarationNode::newTypeQualifier( ast::CV::Const ); }
         | RESTRICT
                 { $$ = DeclarationNode::newTypeQualifier( Type::Restrict ); }
+                { $$ = DeclarationNode::newTypeQualifier( ast::CV::Restrict ); }
         | VOLATILE
                 { $$ = DeclarationNode::newTypeQualifier( Type::Volatile ); }
+                { $$ = DeclarationNode::newTypeQualifier( ast::CV::Volatile ); }
         | ATOMIC
                 { $$ = DeclarationNode::newTypeQualifier( Type::Atomic ); }
+                { $$ = DeclarationNode::newTypeQualifier( ast::CV::Atomic ); }
         | forall
                 { $$ = DeclarationNode::newForall( $1 ); }
 …
 storage_class:
         EXTERN
                 { $$ = DeclarationNode::newStorageClass( Type::Extern ); }
+                { $$ = DeclarationNode::newStorageClass( ast::Storage::Extern ); }
         | STATIC
                 { $$ = DeclarationNode::newStorageClass( Type::Static ); }
+                { $$ = DeclarationNode::newStorageClass( ast::Storage::Static ); }
         | AUTO
                 { $$ = DeclarationNode::newStorageClass( Type::Auto ); }
+                { $$ = DeclarationNode::newStorageClass( ast::Storage::Auto ); }
         | REGISTER
                 { $$ = DeclarationNode::newStorageClass( Type::Register ); }
+                { $$ = DeclarationNode::newStorageClass( ast::Storage::Register ); }
         | THREADLOCALGCC                                                                                // GCC
                 { $$ = DeclarationNode::newStorageClass( Type::ThreadlocalGcc ); }
+                { $$ = DeclarationNode::newStorageClass( ast::Storage::ThreadLocalGcc ); }
         | THREADLOCALC11                                                                                // C11
                 { $$ = DeclarationNode::newStorageClass( Type::ThreadlocalC11 ); }
+                { $$ = DeclarationNode::newStorageClass( ast::Storage::ThreadLocalC11 ); }
                 // Put function specifiers here to simplify parsing rules, but separate them semantically.
         | INLINE                                                                                        // C99
                 { $$ = DeclarationNode::newFuncSpecifier( Type::Inline ); }
+                { $$ = DeclarationNode::newFuncSpecifier( ast::Function::Inline ); }
         | FORTRAN                                                                                       // C99
                 { $$ = DeclarationNode::newFuncSpecifier( Type::Fortran ); }
+                { $$ = DeclarationNode::newFuncSpecifier( ast::Function::Fortran ); }
         | NORETURN                                                                                      // C11
                 { $$ = DeclarationNode::newFuncSpecifier( Type::Noreturn ); }
+                { $$ = DeclarationNode::newFuncSpecifier( ast::Function::Noreturn ); }
+        ;
 …
                 { $$ = $1->addQualifiers( $2 ); }
         | '&' MUTEX paren_identifier attribute_list_opt
                 { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( ast::CV::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
         | identifier_parameter_ptr
         | identifier_parameter_array attribute_list_opt
 …
                 { $$ = $1->addQualifiers( $2 ); }
         | '&' MUTEX typedef_name attribute_list_opt
                 { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( ast::CV::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
         | type_parameter_ptr
         | type_parameter_array attribute_list_opt
 …
         abstract_parameter_ptr
         | '&' MUTEX attribute_list_opt
                 { $$ = DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf )->addQualifiers( $3 ); }
+                { $$ = DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( ast::CV::Mutex ), OperKinds::AddressOf )->addQualifiers( $3 ); }
         | abstract_parameter_array attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }

src/ResolvExpr/AdjustExprType.cc

-              r0030b508
+              rfc12f05
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"
-#include "SymTab/Indexer.h"       // for Indexer
-#include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Kind::Ftype
-#include "SynTree/Mutator.h"      // for Mutator
-#include "SynTree/Type.h"         // for PointerType, TypeInstType, Type
-#include "TypeEnvironment.h"      // for EqvClass, TypeEnvironment
 namespace ResolvExpr {
-namespace {
-        class AdjustExprType_old final : public WithShortCircuiting {
-                public:
-                AdjustExprType_old( const TypeEnvironment & env, const SymTab::Indexer & indexer );
-                void premutate( VoidType * ) { visit_children = false; }
-                void premutate( BasicType * ) { visit_children = false; }
-                void premutate( PointerType * ) { visit_children = false; }
-                void premutate( ArrayType * ) { visit_children = false; }
-                void premutate( FunctionType * ) { visit_children = false; }
-                void premutate( StructInstType * ) { visit_children = false; }
-                void premutate( UnionInstType * ) { visit_children = false; }
-                void premutate( EnumInstType * ) { visit_children = false; }
-                void premutate( TraitInstType * ) { visit_children = false; }
-                void premutate( TypeInstType * ) { visit_children = false; }
-                void premutate( TupleType * ) { visit_children = false; }
-                void premutate( VarArgsType * ) { visit_children = false; }
-                void premutate( ZeroType * ) { visit_children = false; }
-                void premutate( OneType * ) { visit_children = false; }
-                Type * postmutate( ArrayType * arrayType );
-                Type * postmutate( FunctionType * functionType );
-                Type * postmutate( TypeInstType * aggregateUseType );
-                private:
-                const TypeEnvironment & env;
-                const SymTab::Indexer & indexer;
-        };
-        AdjustExprType_old::AdjustExprType_old( const TypeEnvironment &env, const SymTab::Indexer &indexer )
-                : env( env ), indexer( indexer ) {
+        }
-        Type * AdjustExprType_old::postmutate( ArrayType * arrayType ) {
-                PointerType * pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base };
-                arrayType->base = nullptr;
-                delete arrayType;
-                return pointerType;
+        }
-        Type * AdjustExprType_old::postmutate( FunctionType * functionType ) {
-                return new PointerType{ Type::Qualifiers(), functionType };
+        }
-        Type * AdjustExprType_old::postmutate( TypeInstType * typeInst ) {
-                if ( const EqvClass * eqvClass = env.lookup( typeInst->get_name() ) ) {
-                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
-                                return new PointerType{ Type::Qualifiers(), typeInst };
+                        }
-                } else if ( const NamedTypeDecl * ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
-                        if ( const TypeDecl * tyDecl = dynamic_cast< const TypeDecl * >( ntDecl ) ) {
-                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
-                                        return new PointerType{ Type::Qualifiers(), typeInst };
-                                } // if
-                        } // if
-                } // if
-                return typeInst;
+        }
-} // anonymous namespace
-void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
-        PassVisitor<AdjustExprType_old> adjuster( env, indexer );
-        Type * newType = type->acceptMutator( adjuster );
-        type = newType;
+}
-void adjustExprType( Type *& type ) {
-        TypeEnvironment env;
-        SymTab::Indexer indexer;
-        adjustExprType( type, env, indexer );
+}
 namespace {

src/ResolvExpr/CandidateFinder.cpp

-              r0030b508
+              rfc12f05
 /// Unique identifier for matching expression resolutions to their requesting expression
 UniqueId globalResnSlot = 0;
+ast::UniqueId globalResnSlot = 0;
 namespace {
 …
         void Finder::inferParameters( CandidateRef & newCand, CandidateList & out ) {
                 // Set need bindings for any unbound assertions
                 UniqueId crntResnSlot = 0; // matching ID for this expression's assertions
+                ast::UniqueId crntResnSlot = 0; // matching ID for this expression's assertions
                 for ( auto & assn : newCand->need ) {
                         // skip already-matched assertions

src/ResolvExpr/CastCost.cc

-              r0030b508
+              rfc12f05
 #include "ResolvExpr/ConversionCost.h"   // for conversionCost
 #include "ResolvExpr/PtrsCastable.hpp"   // for ptrsCastable
-#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment, EqvClass
 #include "ResolvExpr/typeops.h"          // for ptrsCastable
 #include "ResolvExpr/Unify.h"            // for typesCompatibleIgnoreQualifiers
-#include "SymTab/Indexer.h"              // for Indexer
-#include "SynTree/Declaration.h"         // for TypeDecl, NamedTypeDecl
-#include "SynTree/Type.h"                // for PointerType, Type, TypeInstType
 #if 0
 …
 namespace ResolvExpr {
-        struct CastCost_old : public ConversionCost {
-          public:
-                CastCost_old( const Type * dest, bool srcIsLvalue,
-                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
-                using ConversionCost::previsit;
-                using ConversionCost::postvisit;
-                void postvisit( const BasicType * basicType );
-                void postvisit( const PointerType * pointerType );
-        };
-        Cost castCost( const Type * src, const Type * dest, bool srcIsLvalue,
-                        const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
-                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
-                                if ( eqvClass->type ) {
-                                        return castCost( src, eqvClass->type, srcIsLvalue, indexer, env );
-                                } else {
-                                        return Cost::infinity;
+                                }
-                        } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) {
-                                // all typedefs should be gone by this point
-                                const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( namedType );
-                                if ( type->base ) {
-                                        return castCost( src, type->base, srcIsLvalue, indexer, env ) + Cost::safe;
-                                } // if
-                        } // if
-                } // if
-                PRINT(
-                        std::cerr << "castCost ::: src is ";
-                        src->print( std::cerr );
-                        std::cerr << std::endl << "dest is ";
-                        dest->print( std::cerr );
-                        std::cerr << std::endl << "env is" << std::endl;
-                        env.print( std::cerr, 8 );
+                )
-                if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
-                        PRINT( std::cerr << "compatible!" << std::endl; )
-                        return Cost::zero;
-                } else if ( dynamic_cast< const VoidType * >( dest ) ) {
-                        return Cost::safe;
-                } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
-                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, srcIsLvalue, indexer, env, [](const Type * t1, const Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
-                                return ptrsCastable( t1, t2, env, indexer );
-                        });
-                } else {
-                        PassVisitor<CastCost_old> converter(
-                                dest, srcIsLvalue, indexer, env,
-                                (Cost (*)( const Type *, const Type *, bool, const SymTab::Indexer &, const TypeEnvironment & ))
-                                        castCost );
-                        src->accept( converter );
-                        if ( converter.pass.get_cost() == Cost::infinity ) {
-                                return Cost::infinity;
-                        } else {
-                                // xxx - why are we adding cost 0 here?
-                                return converter.pass.get_cost() + Cost::zero;
-                        } // if
-                } // if
+        }
-        CastCost_old::CastCost_old( const Type * dest, bool srcIsLvalue,
-                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
-                : ConversionCost( dest, srcIsLvalue, indexer, env, costFunc ) {
+        }
-        void CastCost_old::postvisit( const BasicType * basicType ) {
-                const PointerType * destAsPointer = dynamic_cast< const PointerType * >( dest );
-                if ( destAsPointer && basicType->isInteger() ) {
-                        // necessary for, e.g. unsigned long => void *
-                        cost = Cost::unsafe;
-                } else {
-                        cost = conversionCost( basicType, dest, srcIsLvalue, indexer, env );
-                } // if
+        }
-        void CastCost_old::postvisit( const PointerType * pointerType ) {
-                if ( const PointerType * destAsPtr = dynamic_cast< const PointerType * >( dest ) ) {
-                        if ( pointerType->tq <= destAsPtr->tq && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
-                                cost = Cost::safe;
-                        } else {
-                                TypeEnvironment newEnv( env );
-                                newEnv.add( pointerType->forall );
-                                newEnv.add( pointerType->base->forall );
-                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
-                                if ( castResult > 0 ) {
-                                        cost = Cost::safe;
-                                } else if ( castResult < 0 ) {
-                                        cost = Cost::infinity;
-                                } // if
-                        } // if
-                } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
-                        if ( destAsBasic->isInteger() ) {
-                                // necessary for, e.g. void * => unsigned long
-                                cost = Cost::unsafe;
-                        } // if
+                }
+        }
 namespace {
 …
 } // anonymous namespace
 Cost castCost(
         const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,

src/ResolvExpr/CommonType.cc

-              r0030b508
+              rfc12f05
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
-#include "Common/PassVisitor.h"
-#include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
-#include "SymTab/Indexer.h"              // for Indexer
-#include "SynTree/Declaration.h"         // for TypeDecl, NamedTypeDecl (ptr...
-#include "SynTree/Type.h"                // for BasicType, BasicType::Kind::...
-#include "SynTree/Visitor.h"             // for Visitor
 #include "Unify.h"                       // for unifyExact, WidenMode
 #include "typeops.h"                     // for isFtype
 …
 namespace ResolvExpr {
-        struct CommonType_old : public WithShortCircuiting {
-                CommonType_old( Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
-                Type * get_result() const { return result; }
-                void previsit( BaseSyntaxNode * ) { visit_children = false; }
-                void postvisit( VoidType * voidType );
-                void postvisit( BasicType * basicType );
-                void postvisit( PointerType * pointerType );
-                void postvisit( ArrayType * arrayType );
-                void postvisit( ReferenceType * refType );
-                void postvisit( FunctionType * functionType );
-                void postvisit( StructInstType * aggregateUseType );
-                void postvisit( UnionInstType * aggregateUseType );
-                void postvisit( EnumInstType * aggregateUseType );
-                void postvisit( TraitInstType * aggregateUseType );
-                void postvisit( TypeInstType * aggregateUseType );
-                void postvisit( TupleType * tupleType );
-                void postvisit( VarArgsType * varArgsType );
-                void postvisit( ZeroType * zeroType );
-                void postvisit( OneType * oneType );
-          private:
-                template< typename Pointer > void getCommonWithVoidPointer( Pointer * voidPointer, Pointer * otherPointer );
-                template< typename RefType > void handleRefType( RefType * inst, Type * other );
-                Type * result;
-                Type * type2;                           // inherited
-                bool widenFirst, widenSecond;
-                const SymTab::Indexer &indexer;
-                TypeEnvironment &env;
-                const OpenVarSet &openVars;
-        };
-        Type * handleReference( Type * t1, Type * t2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) {
-                Type * common = nullptr;
-                AssertionSet have, need;
-                OpenVarSet newOpen( openVars );
-                // need unify to bind type variables
-                if ( unify( t1, t2, env, have, need, newOpen, indexer, common ) ) {
-                        PRINT(
-                                std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl;
+                        )
-                        if ( (widenFirst || t2->tq <= t1->tq) && (widenSecond || t1->tq <= t2->tq) ) {
-                                PRINT(
-                                        std::cerr << "widen okay" << std::endl;
+                                )
-                                common->tq |= t1->tq;
-                                common->tq |= t2->tq;
-                                return common;
+                        }
+                }
-                PRINT(
-                        std::cerr << "exact unify failed: " << t1 << " " << t2 << std::endl;
+                )
-                return nullptr;
+        }
-        Type * commonType( Type * type1, Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) {
-                PassVisitor<CommonType_old> visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
-                int depth1 = type1->referenceDepth();
-                int depth2 = type2->referenceDepth();
-                if ( depth1 > 0 || depth2 > 0 ) {
-                        int diff = depth1-depth2;
-                        // TODO: should it be possible for commonType to generate complicated conversions? I would argue no, only conversions that involve types of the same reference level or a difference of 1 should be allowed.
-                        // if ( diff > 1 || diff < -1 ) return nullptr;
-                        // special case where one type has a reference depth of 1 larger than the other
-                        if ( diff > 0 || diff < 0 ) {
-                                PRINT(
-                                        std::cerr << "reference depth diff: " << diff << std::endl;
+                                )
-                                Type * result = nullptr;
-                                ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 );
-                                ReferenceType * ref2 = dynamic_cast< ReferenceType * >( type2 );
-                                if ( diff > 0 ) {
-                                        // deeper on the left
-                                        assert( ref1 );
-                                        result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars );
-                                } else {
-                                        // deeper on the right
-                                        assert( ref2 );
-                                        result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars );
+                                }
-                                if ( result && ref1 ) {
-                                        // formal is reference, so result should be reference
-                                        PRINT(
-                                                std::cerr << "formal is reference; result should be reference" << std::endl;
+                                        )
-                                        result = new ReferenceType( ref1->tq, result );
+                                }
-                                PRINT(
-                                        std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;
+                                )
-                                return result;
+                        }
-                        // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor.
+                }
-                type1->accept( visitor );
-                Type * result = visitor.pass.get_result();
-                if ( ! result ) {
-                        // this appears to be handling for opaque type declarations
-                        if ( widenSecond ) {
-                                if ( const TypeInstType * inst = dynamic_cast< const TypeInstType * >( type2 ) ) {
-                                        if ( const NamedTypeDecl * nt = indexer.lookupType( inst->get_name() ) ) {
-                                                const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( nt );
-                                                if ( type->get_base() ) {
-                                                        Type::Qualifiers tq1 = type1->tq, tq2 = type2->tq;
-                                                        AssertionSet have, need;
-                                                        OpenVarSet newOpen( openVars );
-                                                        type1->tq = Type::Qualifiers();
-                                                        type->get_base()->tq = tq1;
-                                                        if ( unifyExact( type1, type->get_base(), env, have, need, newOpen, indexer ) ) {
-                                                                result = type1->clone();
-                                                                result->tq = tq1 | tq2;
-                                                        } // if
-                                                        type1->tq = tq1;
-                                                        type->get_base()->tq = Type::Qualifiers();
-                                                } // if
-                                        } // if
-                                } // if
-                        } // if
-                } // if
-#ifdef DEBUG
-                std::cerr << "============= commonType" << std::endl << "type1 is ";
-                type1->print( std::cerr );
-                std::cerr << " type2 is ";
-                type2->print( std::cerr );
-                if ( result ) {
-                        std::cerr << " common type is ";
-                        result->print( std::cerr );
-                } else {
-                        std::cerr << " no common type";
-                } // if
-                std::cerr << std::endl;
-#endif
-                return result;
+        }
         // GENERATED START, DO NOT EDIT
         // GENERATED BY BasicTypes-gen.cc
         #define BT BasicType::
         static const BasicType::Kind commonTypes[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor
+        #define BT ast::BasicType::
+        static const BT Kind commonTypes[BT NUMBER_OF_BASIC_TYPES][BT NUMBER_OF_BASIC_TYPES] = { // nearest common ancestor
                 /*                                      B                       C                      SC                      UC                      SI                     SUI
                                                         I                      UI                      LI                     LUI                     LLI                    LLUI
 …
         // GENERATED END
         static_assert(
                 sizeof(commonTypes)/sizeof(commonTypes[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES,
+                sizeof(commonTypes)/sizeof(commonTypes[0][0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES * ast::BasicType::NUMBER_OF_BASIC_TYPES,
                 "Each basic type kind should have a corresponding row in the combined type matrix"
         );
-        CommonType_old::CommonType_old( Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars )
-                : result( 0 ), type2( type2 ), widenFirst( widenFirst ), widenSecond( widenSecond ), indexer( indexer ), env( env ), openVars( openVars ) {
+        }
-        void CommonType_old::postvisit( VoidType * ) {}
-        void CommonType_old::postvisit( BasicType * basicType ) {
-                if ( BasicType * otherBasic = dynamic_cast< BasicType * >( type2 ) ) {
-                        BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ otherBasic->get_kind() ];
-                        if ( ( ( newType == basicType->get_kind() && basicType->tq >= otherBasic->tq ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->tq <= otherBasic->tq ) || widenSecond ) ) {
-                                result = new BasicType( basicType->tq | otherBasic->tq, newType );
-                        } // if
-                } else if (  dynamic_cast< ZeroType * >( type2 ) || dynamic_cast< OneType * >( type2 ) ) {
-                        // use signed int in lieu of the enum/zero/one type
-                        BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
-                        if ( ( ( newType == basicType->get_kind() && basicType->tq >= type2->tq ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->tq <= type2->tq ) || widenSecond ) ) {
-                                result = new BasicType( basicType->tq | type2->tq, newType );
-                        } // if
-                } else if ( const EnumInstType * enumInst = dynamic_cast< const EnumInstType * > ( type2 ) ) {
-                        const EnumDecl* enumDecl = enumInst->baseEnum;
-                        if ( const Type* baseType = enumDecl->base ) {
-                                result = baseType->clone();
-                        } else {
-                                BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
-                                if ( ( ( newType == basicType->get_kind() && basicType->tq >= type2->tq ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->tq <= type2->tq ) || widenSecond ) ) {
-                                        result = new BasicType( basicType->tq | type2->tq, newType );
-                                } // if
+                        }
+                }
+        }
-        template< typename Pointer >
-        void CommonType_old::getCommonWithVoidPointer( Pointer * voidPointer, Pointer * otherPointer ) {
-                if ( TypeInstType * var = dynamic_cast< TypeInstType * >( otherPointer->get_base() ) ) {
-                        OpenVarSet::const_iterator entry = openVars.find( var->get_name() );
-                        if ( entry != openVars.end() ) {
-                                AssertionSet need, have;
-                                WidenMode widen( widenFirst, widenSecond );
-                                if ( entry != openVars.end() && ! env.bindVar(var, voidPointer->get_base(), entry->second, need, have, openVars, widen, indexer ) ) return;
+                        }
+                }
-                result = voidPointer->clone();
-                result->tq |= otherPointer->tq;
+        }
-        void CommonType_old::postvisit( PointerType * pointerType ) {
-                if ( PointerType * otherPointer = dynamic_cast< PointerType * >( type2 ) ) {
-                        // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl;
-                        if ( widenFirst && dynamic_cast< VoidType * >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) {
-                                getCommonWithVoidPointer( otherPointer, pointerType );
-                        } else if ( widenSecond && dynamic_cast< VoidType * >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base()) ) {
-                                getCommonWithVoidPointer( pointerType, otherPointer );
-                        } else if ( ( pointerType->get_base()->tq >= otherPointer->get_base()->tq || widenFirst )
-                                           && ( pointerType->get_base()->tq <= otherPointer->get_base()->tq || widenSecond ) ) {
-                                // std::cerr << "middle case" << std::endl;
-                                Type::Qualifiers tq1 = pointerType->get_base()->tq, tq2 = otherPointer->get_base()->tq;
-                                pointerType->get_base()->tq = Type::Qualifiers();
-                                otherPointer->get_base()->tq = Type::Qualifiers();
-                                AssertionSet have, need;
-                                OpenVarSet newOpen( openVars );
-                                if ( unifyExact( pointerType->get_base(), otherPointer->get_base(), env, have, need, newOpen, indexer ) ) {
-                                        // std::cerr << "unifyExact success" << std::endl;
-                                        if ( tq1 < tq2 ) {
-                                                result = pointerType->clone();
-                                        } else {
-                                                result = otherPointer->clone();
-                                        } // if
-                                        strict_dynamic_cast<PointerType *>(result)->base->tq = tq1 | tq2;
-                                } else {
-                                        /// std::cerr << "place for ptr-to-type" << std::endl;
-                                } // if
-                                pointerType->get_base()->tq = tq1;
-                                otherPointer->get_base()->tq = tq2;
-                        } // if
-                } else if ( widenSecond && dynamic_cast< ZeroType * >( type2 ) ) {
-                        result = pointerType->clone();
-                        result->tq |= type2->tq;
-                } // if
+        }
-        void CommonType_old::postvisit( ArrayType * ) {}
-        void CommonType_old::postvisit( ReferenceType * refType ) {
-                if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( type2 ) ) {
-                        // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl;
-                        // std::cerr << ( refType->get_base()->tq >= otherRef->get_base()->tq || widenFirst ) << (refType->get_base()->tq <= otherRef->get_base()->tq || widenSecond) << std::endl;
-                        if ( widenFirst && dynamic_cast< VoidType * >( otherRef->get_base() ) && ! isFtype(refType->get_base()) ) {
-                                getCommonWithVoidPointer( otherRef, refType );
-                        } else if ( widenSecond && dynamic_cast< VoidType * >( refType->get_base() ) && ! isFtype(otherRef->get_base()) ) {
-                                getCommonWithVoidPointer( refType, otherRef );
-                        } else if ( ( refType->get_base()->tq >= otherRef->get_base()->tq || widenFirst )
-                                           && ( refType->get_base()->tq <= otherRef->get_base()->tq || widenSecond ) ) {
-                                // std::cerr << "middle case" << std::endl;
-                                Type::Qualifiers tq1 = refType->get_base()->tq, tq2 = otherRef->get_base()->tq;
-                                refType->get_base()->tq = Type::Qualifiers();
-                                otherRef->get_base()->tq = Type::Qualifiers();
-                                AssertionSet have, need;
-                                OpenVarSet newOpen( openVars );
-                                if ( unifyExact( refType->get_base(), otherRef->get_base(), env, have, need, newOpen, indexer ) ) {
-                                        if ( tq1 < tq2 ) {
-                                                result = refType->clone();
-                                        } else {
-                                                result = otherRef->clone();
-                                        } // if
-                                        strict_dynamic_cast<ReferenceType *>(result)->base->tq = tq1 | tq2;
-                                } else {
-                                        /// std::cerr << "place for ptr-to-type" << std::endl;
-                                } // if
-                                refType->get_base()->tq = tq1;
-                                otherRef->get_base()->tq = tq2;
-                        } // if
-                } else if ( widenSecond && dynamic_cast< ZeroType * >( type2 ) ) {
-                        result = refType->clone();
-                        result->tq |= type2->tq;
-                } // if
+        }
-        void CommonType_old::postvisit( FunctionType * ) {}
-        void CommonType_old::postvisit( StructInstType * ) {}
-        void CommonType_old::postvisit( UnionInstType * ) {}
-        void CommonType_old::postvisit( EnumInstType * enumInstType ) {
-                if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType * >( type2 ) || dynamic_cast< OneType * >( type2 ) ) {
-                        // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
-                        result = commonType( type2, enumInstType, widenSecond, widenFirst, indexer, env, openVars );
-                } // if
+        }
-        void CommonType_old::postvisit( TraitInstType * ) {
+        }
-        void CommonType_old::postvisit( TypeInstType * inst ) {
-                if ( widenFirst ) {
-                        const NamedTypeDecl * nt = indexer.lookupType( inst->get_name() );
-                        if ( nt ) {
-                                const TypeDecl * type = strict_dynamic_cast< const TypeDecl * >( nt );
-                                if ( type->get_base() ) {
-                                        Type::Qualifiers tq1 = inst->tq, tq2 = type2->tq;
-                                        AssertionSet have, need;
-                                        OpenVarSet newOpen( openVars );
-                                        type2->tq = Type::Qualifiers();
-                                        type->get_base()->tq = tq1;
-                                        if ( unifyExact( type->get_base(), type2, env, have, need, newOpen, indexer ) ) {
-                                                result = type2->clone();
-                                                result->tq = tq1 | tq2;
-                                        } // if
-                                        type2->tq = tq2;
-                                        type->get_base()->tq = Type::Qualifiers();
-                                } // if
-                        } // if
-                } // if
+        }
-        void CommonType_old::postvisit( TupleType * ) {}
-        void CommonType_old::postvisit( VarArgsType * ) {}
-        void CommonType_old::postvisit( ZeroType * zeroType ) {
-                if ( widenFirst ) {
-                        if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< PointerType * >( type2 ) || dynamic_cast< EnumInstType * >( type2 ) ) {
-                                if ( widenSecond || zeroType->tq <= type2->tq ) {
-                                        result = type2->clone();
-                                        result->tq |= zeroType->tq;
+                                }
-                        } else if ( widenSecond && dynamic_cast< OneType * >( type2 ) ) {
-                                result = new BasicType( zeroType->tq, BasicType::SignedInt );
-                                result->tq |= type2->tq;
+                        }
+                }
+        }
-        void CommonType_old::postvisit( OneType * oneType ) {
-                if ( widenFirst ) {
-                        if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< EnumInstType * >( type2 ) ) {
-                                if ( widenSecond || oneType->tq <= type2->tq ) {
-                                        result = type2->clone();
-                                        result->tq |= oneType->tq;
+                                }
-                        } else if ( widenSecond && dynamic_cast< ZeroType * >( type2 ) ) {
-                                result = new BasicType( oneType->tq, BasicType::SignedInt );
-                                result->tq |= type2->tq;
+                        }
+                }
+        }
         class CommonType_new final : public ast::WithShortCircuiting {
 …
                                 else if (!widen.first) kind = basic->kind; // widen.second
                                 else if (!widen.second) kind = basic2->kind;
                                 else kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ];
+                                else kind = commonTypes[ basic->kind ][ basic2->kind ];
                                 // xxx - what does qualifiers even do here??
                                 if ( (basic->qualifiers >= basic2->qualifiers || widen.first)
 …
                                 } else {
                                         #warning remove casts when `commonTypes` moved to new AST
                                         ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ];
+                                        ast::BasicType::Kind kind = commonTypes[ basic->kind ][ ast::BasicType::SignedInt ];
                                         if (
                                                 ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )

src/ResolvExpr/CommonType.hpp

-              r0030b508
+              rfc12f05
 #include "AST/Fwd.hpp"
 #include "AST/TypeEnvironment.hpp"  // for AssertionSet, OpenVarSet
-#include "TypeEnvironment.h"        // for AssertionSet, OpenVarSet
 #include "WidenMode.h"              // for WidenMode
-class Type;
-namespace SymTab {
-        class Indexer;
+}
 namespace ResolvExpr {
-Type * commonType(
-        Type * type1, Type * type2, bool widenFirst, bool widenSecond,
-        const SymTab::Indexer & indexer, TypeEnvironment & env,
-        const OpenVarSet & openVars );
 ast::ptr< ast::Type > commonType(
         const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2,

src/ResolvExpr/ConversionCost.cc

-              r0030b508
+              rfc12f05
 #include "ResolvExpr/Cost.h"             // for Cost
-#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
 #include "ResolvExpr/Unify.h"            // for typesCompatibleIgnoreQualifiers
 #include "ResolvExpr/PtrsAssignable.hpp" // for ptrsAssignable
-#include "SymTab/Indexer.h"              // for Indexer
-#include "SynTree/Declaration.h"         // for TypeDecl, NamedTypeDecl
-#include "SynTree/Type.h"                // for Type, BasicType, TypeInstType
 namespace ResolvExpr {
-#if 0
-        const Cost Cost::zero =      Cost{  0,  0,  0,  0,  0,  0,  0 };
-        const Cost Cost::infinity =  Cost{ -1, -1, -1, -1, -1,  1, -1 };
-        const Cost Cost::unsafe =    Cost{  1,  0,  0,  0,  0,  0,  0 };
-        const Cost Cost::poly =      Cost{  0,  1,  0,  0,  0,  0,  0 };
-        const Cost Cost::safe =      Cost{  0,  0,  1,  0,  0,  0,  0 };
-        const Cost Cost::sign =      Cost{  0,  0,  0,  1,  0,  0,  0 };
-        const Cost Cost::var =       Cost{  0,  0,  0,  0,  1,  0,  0 };
-        const Cost Cost::spec =      Cost{  0,  0,  0,  0,  0, -1,  0 };
-        const Cost Cost::reference = Cost{  0,  0,  0,  0,  0,  0,  1 };
-#endif
 #if 0
 …
 #define PRINT(x)
 #endif
-        Cost conversionCost( const Type * src, const Type * dest, bool srcIsLvalue,
-                        const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType * >( dest ) ) {
-                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
-                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->name ) ) {
-                                if ( eqvClass->type ) {
-                                        return conversionCost( src, eqvClass->type, srcIsLvalue, indexer, env );
-                                } else {
-                                        return Cost::infinity;
+                                }
-                        } else if ( const NamedTypeDecl * namedType = indexer.lookupType( destAsTypeInst->name ) ) {
-                                PRINT( std::cerr << " found" << std::endl; )
-                                const TypeDecl * type = dynamic_cast< const TypeDecl * >( namedType );
-                                // all typedefs should be gone by this point
-                                assert( type );
-                                if ( type->base ) {
-                                        return conversionCost( src, type->base, srcIsLvalue, indexer, env )
-                                                + Cost::safe;
-                                } // if
-                        } // if
-                        PRINT( std::cerr << " not found" << std::endl; )
-                } // if
-                PRINT(
-                        std::cerr << "src is ";
-                        src->print( std::cerr );
-                        std::cerr << std::endl << "dest is ";
-                        dest->print( std::cerr );
-                        std::cerr << std::endl << "env is" << std::endl;
-                        env.print( std::cerr, 8 );
+                )
-                if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
-                        PRINT( std::cerr << "compatible!" << std::endl; )
-                        return Cost::zero;
-                } else if ( dynamic_cast< const VoidType * >( dest ) ) {
-                        return Cost::safe;
-                } else if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * > ( dest ) ) {
-                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, srcIsLvalue, indexer, env, [](const Type * const t1, const Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){
-                                return ptrsAssignable( t1, t2, env );
-                        });
-                } else {
-                        PassVisitor<ConversionCost> converter(
-                                dest, srcIsLvalue, indexer, env,
-                                (Cost (*)(const Type *, const Type *, bool, const SymTab::Indexer&, const TypeEnvironment&))
-                                        conversionCost );
-                        src->accept( converter );
-                        if ( converter.pass.get_cost() == Cost::infinity ) {
-                                return Cost::infinity;
-                        } else {
-                                return converter.pass.get_cost() + Cost::zero;
-                        } // if
-                } // if
+        }
-        static Cost convertToReferenceCost( const Type * src, const Type * dest, bool srcIsLvalue,
-                        int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
-                PRINT( std::cerr << "convert to reference cost... diff " << diff << " " << src << " / " << dest << std::endl; )
-                if ( diff > 0 ) {
-                        // TODO: document this
-                        Cost cost = convertToReferenceCost(
-                                strict_dynamic_cast< const ReferenceType * >( src )->base, dest, srcIsLvalue,
-                                diff-1, indexer, env, func );
-                        cost.incReference();
-                        return cost;
-                } else if ( diff < -1 ) {
-                        // TODO: document this
-                        Cost cost = convertToReferenceCost(
-                                src, strict_dynamic_cast< const ReferenceType * >( dest )->base, srcIsLvalue,
-                                diff+1, indexer, env, func );
-                        cost.incReference();
-                        return cost;
-                } else if ( diff == 0 ) {
-                        const ReferenceType * srcAsRef = dynamic_cast< const ReferenceType * >( src );
-                        const ReferenceType * destAsRef = dynamic_cast< const ReferenceType * >( dest );
-                        if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
-                                PRINT( std::cerr << "converting between references" << std::endl; )
-                                Type::Qualifiers tq1 = srcAsRef->base->tq;
-                                Type::Qualifiers tq2 = destAsRef->base->tq;
-                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) {
-                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
-                                        if ( tq1 == tq2 ) {
-                                                // types are the same
-                                                return Cost::zero;
-                                        } else {
-                                                // types are the same, except otherPointer has more qualifiers
-                                                return Cost::safe;
+                                        }
-                                } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
-                                        int assignResult = func( srcAsRef->base, destAsRef->base, indexer, env );
-                                        PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
-                                        if ( assignResult > 0 ) {
-                                                return Cost::safe;
-                                        } else if ( assignResult < 0 ) {
-                                                return Cost::unsafe;
-                                        } // if
-                                } // if
-                        } else {
-                                PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
-                                PassVisitor<ConversionCost> converter(
-                                        dest, srcIsLvalue, indexer, env,
-                                        (Cost (*)(const Type *, const Type *, bool, const SymTab::Indexer&, const TypeEnvironment&))
-                                                conversionCost );
-                                src->accept( converter );
-                                return converter.pass.get_cost();
-                        } // if
-                } else {
-                        const ReferenceType * destAsRef = dynamic_cast< const ReferenceType * >( dest );
-                        assert( diff == -1 && destAsRef );
-                        PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
-                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
-                                PRINT( std::cerr << "converting compatible base type" << std::endl; )
-                                if ( srcIsLvalue ) {
-                                        PRINT(
-                                                std::cerr << "lvalue to reference conversion" << std::endl;
-                                                std::cerr << src << " => " << destAsRef << std::endl;
+                                        )
-                                        // lvalue-to-reference conversion:  cv lvalue T => cv T &
-                                        if ( src->tq == destAsRef->base->tq ) {
-                                                return Cost::reference; // cost needs to be non-zero to add cast
-                                        } if ( src->tq < destAsRef->base->tq ) {
-                                                return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
-                                        } else {
-                                                return Cost::unsafe;
-                                        } // if
-                                } else if ( destAsRef->base->get_const() ) {
-                                        PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
-                                        // rvalue-to-const-reference conversion: T => const T &
-                                        return Cost::safe;
-                                } else {
-                                        PRINT( std::cerr << "rvalue to non-const reference conversion" << std::endl; )
-                                        // rvalue-to-reference conversion: T => T &
-                                        return Cost::unsafe;
-                                } // if
-                        } // if
-                        PRINT( std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl; )
+                }
-                return Cost::infinity;
+        }
-        Cost convertToReferenceCost( const Type * src, const ReferenceType * dest, bool srcIsLvalue,
-                        const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
-                int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth();
-                Cost cost = convertToReferenceCost( src, dest, srcIsLvalue, sdepth-ddepth, indexer, env, func );
-                PRINT( std::cerr << "convertToReferenceCost result: " << cost << std::endl; )
-                return cost;
+        }
-        ConversionCost::ConversionCost( const Type * dest, bool srcIsLvalue, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
-                : dest( dest ), srcIsLvalue( srcIsLvalue ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
+        }
         // GENERATED START, DO NOT EDIT
 …
         // GENERATED START, DO NOT EDIT
         // GENERATED BY BasicTypes-gen.cc
         static const int costMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
+        static const int costMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
                 /*               B    C   SC   UC   SI  SUI    I   UI   LI  LUI  LLI LLUI   IB  UIB  _FH  _FH   _F  _FC    F   FC  _FX _FXC   FD _FDC    D   DC F80X_FDXC  F80  _FB_FLDC   FB   LD  LDC _FBX_FLDXC */
                 /*      B */ {   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  15,  16,  17,  16,  18,  17, },
 …
         // GENERATED END
         static_assert(
                 sizeof(costMatrix)/sizeof(costMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES,
+                sizeof(costMatrix)/sizeof(costMatrix[0][0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES * ast::BasicType::NUMBER_OF_BASIC_TYPES,
                 "Missing row in the cost matrix"
         );
 …
         // GENERATED START, DO NOT EDIT
         // GENERATED BY BasicTypes-gen.cc
         static const int signMatrix[BasicType::NUMBER_OF_BASIC_TYPES][BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
+        static const int signMatrix[ast::BasicType::NUMBER_OF_BASIC_TYPES][ast::BasicType::NUMBER_OF_BASIC_TYPES] = { // number of sign changes in safe conversion
                 /*               B    C   SC   UC   SI  SUI    I   UI   LI  LUI  LLI LLUI   IB  UIB  _FH  _FH   _F  _FC    F   FC  _FX _FXC   FD _FDC    D   DC F80X_FDXC  F80  _FB_FLDC   FB   LD  LDC _FBX_FLDXC */
                 /*      B */ {   0,   0,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, },
 …
         // GENERATED END
         static_assert(
                 sizeof(signMatrix)/sizeof(signMatrix[0][0]) == BasicType::NUMBER_OF_BASIC_TYPES * BasicType::NUMBER_OF_BASIC_TYPES,
+                sizeof(signMatrix)/sizeof(signMatrix[0][0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES * ast::BasicType::NUMBER_OF_BASIC_TYPES,
                 "Missing row in the sign matrix"
         );
-        void ConversionCost::postvisit( const VoidType * ) {
-                cost = Cost::infinity;
+        }
-        // refactor for code resue
-        void ConversionCost::conversionCostFromBasicToBasic(const BasicType * src, const BasicType * dest) {
-                int tableResult = costMatrix[ src->kind ][ dest->kind ];
-                if ( tableResult == -1 ) {
-                        cost = Cost::unsafe;
-                } else {
-                        cost = Cost::zero;
-                        cost.incSafe( tableResult );
-                        cost.incSign( signMatrix[ src->kind ][ dest->kind ] );
-                } // if
-        } // ConversionCost::conversionCostFromBasicToBasic
-        void ConversionCost::postvisit(const BasicType * basicType) {
-                if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
-                        conversionCostFromBasicToBasic(basicType, destAsBasic);
-                } else if ( const EnumInstType * enumInst = dynamic_cast< const EnumInstType * >( dest ) ) {
-                        const EnumDecl * base_enum = enumInst->baseEnum;
-                        if ( const Type * base = base_enum->base ) {
-                                if ( const BasicType * enumBaseAstBasic = dynamic_cast< const BasicType *> (base) ) {
-                                        conversionCostFromBasicToBasic(basicType, enumBaseAstBasic);
-                                } else {
-                                        cost = Cost::infinity;
-                                } // if
-                        } else {
-                                cost = Cost::unsafe;
-                        } // if
-                } // if
-                // no cases for zero_t/one_t because it should not be possible to convert int, etc. to zero_t/one_t.
+        }
-        void ConversionCost::postvisit( const PointerType * pointerType ) {
-                if ( const PointerType * destAsPtr = dynamic_cast< const PointerType * >( dest ) ) {
-                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
-                        Type::Qualifiers tq1 = pointerType->base->tq;
-                        Type::Qualifiers tq2 = destAsPtr->base->tq;
-                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
-                                PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
-                                if ( tq1 == tq2 ) {
-                                        // types are the same
-                                        cost = Cost::zero;
-                                } else {
-                                        // types are the same, except otherPointer has more qualifiers
-                                        cost = Cost::safe;
-                                } // if
-                        } else {
-                                int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
-                                PRINT( std::cerr << " :: " << assignResult << std::endl; )
-                                if ( assignResult > 0 && tq1 <= tq2 ) {
-                                        // xxx - want the case where qualifiers are added to be more expensive than the case where qualifiers are the same. Is 1 safe vs. 2 safe correct?
-                                        if ( tq1 == tq2 ) {
-                                                cost = Cost::safe;
-                                        } else if ( tq1 < tq2 ) {
-                                                cost = Cost::safe+Cost::safe;
+                                        }
-                                } else if ( assignResult < 0 ) {
-                                        cost = Cost::unsafe;
-                                } // if
-                                // assignResult == 0 means Cost::Infinity
-                        } // if
-                        // case case for zero_t because it should not be possible to convert pointers to zero_t.
-                } // if
+        }
-        void ConversionCost::postvisit( const ArrayType * ) {}
-        void ConversionCost::postvisit( const ReferenceType * refType ) {
-                // Note: dest can never be a reference, since it would have been caught in an earlier check
-                assert( ! dynamic_cast< const ReferenceType * >( dest ) );
-                // convert reference to rvalue: cv T1 & => T2
-                // recursively compute conversion cost from T1 to T2.
-                // cv can be safely dropped because of 'implicit dereference' behavior.
-                cost = costFunc( refType->base, dest, srcIsLvalue, indexer, env );
-                if ( refType->base->tq == dest->tq ) {
-                        cost.incReference();  // prefer exact qualifiers
-                } else if ( refType->base->tq < dest->tq ) {
-                        cost.incSafe(); // then gaining qualifiers
-                } else {
-                        cost.incUnsafe(); // lose qualifiers as last resort
+                }
-                PRINT( std::cerr << refType << " ==> " << dest << " " << cost << std::endl; )
+        }
-        void ConversionCost::postvisit( const FunctionType * ) {}
-        void ConversionCost::postvisit( const EnumInstType * enumInst) {
-                const EnumDecl * enumDecl = enumInst -> baseEnum;
-                if ( const Type * enumType = enumDecl -> base ) { // if it is a typed enum
-                        cost = costFunc( enumType, dest, srcIsLvalue, indexer, env );
-                } else {
-                        static Type::Qualifiers q;
-                        static BasicType integer( q, BasicType::SignedInt );
-                        cost = costFunc( &integer, dest, srcIsLvalue, indexer, env );  // safe if dest >= int
-                } // if
-                if ( cost < Cost::unsafe ) {
-                                cost.incSafe();
-                } // if
+        }
-        void ConversionCost::postvisit( const TraitInstType * ) {}
-        void ConversionCost::postvisit( const TypeInstType * inst ) {
-                if ( const EqvClass * eqvClass = env.lookup( inst->name ) ) {
-                        cost = costFunc( eqvClass->type, dest, srcIsLvalue, indexer, env );
-                } else if ( const TypeInstType * destAsInst = dynamic_cast< const TypeInstType * >( dest ) ) {
-                        if ( inst->name == destAsInst->name ) {
-                                cost = Cost::zero;
+                        }
-                } else if ( const NamedTypeDecl * namedType = indexer.lookupType( inst->name ) ) {
-                        const TypeDecl * type = dynamic_cast< const TypeDecl * >( namedType );
-                        // all typedefs should be gone by this point
-                        assert( type );
-                        if ( type->base ) {
-                                cost = costFunc( type->base, dest, srcIsLvalue, indexer, env ) + Cost::safe;
-                        } // if
-                } // if
+        }
-        void ConversionCost::postvisit( const TupleType * tupleType ) {
-                Cost c = Cost::zero;
-                if ( const TupleType * destAsTuple = dynamic_cast< const TupleType * >( dest ) ) {
-                        std::list< Type * >::const_iterator srcIt = tupleType->types.begin();
-                        std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
-                        while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
-                                Cost newCost = costFunc( * srcIt++, * destIt++, srcIsLvalue, indexer, env );
-                                if ( newCost == Cost::infinity ) {
-                                        return;
-                                } // if
-                                c += newCost;
-                        } // while
-                        if ( destIt != destAsTuple->types.end() ) {
-                                cost = Cost::infinity;
-                        } else {
-                                cost = c;
-                        } // if
-                } // if
+        }
-        void ConversionCost::postvisit( const VarArgsType * ) {
-                if ( dynamic_cast< const VarArgsType * >( dest ) ) {
-                        cost = Cost::zero;
+                }
+        }
-        void ConversionCost::postvisit( const ZeroType * ) {
-                if ( dynamic_cast< const ZeroType * >( dest ) ) {
-                        cost = Cost::zero;
-                } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
-                        // copied from visit(BasicType *) for signed int, but +1 for safe conversions
-                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->kind ];
-                        if ( tableResult == -1 ) {
-                                cost = Cost::unsafe;
-                        } else {
-                                cost = Cost::zero;
-                                cost.incSafe( tableResult + 1 );
-                                cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->kind ] );
-                        } // if
-                } else if ( dynamic_cast< const PointerType * >( dest ) ) {
-                        cost = Cost::zero;
-                        cost.incSafe( maxIntCost + 2 ); // +1 for zero_t -> int, +1 for disambiguation
-                } // if
+        }
-        void ConversionCost::postvisit( const OneType * ) {
-                if ( dynamic_cast< const OneType * >( dest ) ) {
-                        cost = Cost::zero;
-                } else if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
-                        // copied from visit(BasicType *) for signed int, but +1 for safe conversions
-                        int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->kind ];
-                        if ( tableResult == -1 ) {
-                                cost = Cost::unsafe;
-                        } else {
-                                cost = Cost::zero;
-                                cost.incSafe( tableResult + 1 );
-                                cost.incSign( signMatrix[ BasicType::SignedInt ][ destAsBasic->kind ] );
-                        } // if
-                } // if
+        }
 namespace {

src/ResolvExpr/ConversionCost.h

-              r0030b508
+              rfc12f05
 #include "AST/Fwd.hpp"
 #include "AST/Pass.hpp"       // for WithShortCircuiting
-#include "Common/PassVisitor.h"
-#include "SynTree/Visitor.h"  // for Visitor
-#include "SynTree/SynTree.h"  // for Visitor Nodes
 namespace SymTab {
 …
 namespace ResolvExpr {
         class TypeEnvironment;
-        Cost conversionCost(
-                const Type * src, const Type * dest, bool srcIsLvalue,
-                const SymTab::Indexer & indexer, const TypeEnvironment & env );
-        typedef std::function<Cost(const Type *, const Type *, bool,
-                const SymTab::Indexer &, const TypeEnvironment &)> CostFunction;
-        struct ConversionCost : public WithShortCircuiting {
-          public:
-                ConversionCost( const Type * dest, bool srcIsLvalue,
-                        const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction );
-                Cost get_cost() const { return cost; }
-                void previsit( const BaseSyntaxNode * ) { visit_children = false; }
-                void postvisit( const VoidType * voidType );
-                void postvisit( const BasicType * basicType );
-                void postvisit( const PointerType * pointerType );
-                void postvisit( const ArrayType * arrayType );
-                void postvisit( const ReferenceType * refType );
-                void postvisit( const FunctionType * functionType );
-                void postvisit( const EnumInstType * aggregateUseType );
-                void postvisit( const TraitInstType * aggregateUseType );
-                void postvisit( const TypeInstType * aggregateUseType );
-                void postvisit( const TupleType * tupleType );
-                void postvisit( const VarArgsType * varArgsType );
-                void postvisit( const ZeroType * zeroType );
-                void postvisit( const OneType * oneType );
-          protected:
-                const Type * dest;
-                bool srcIsLvalue;
-                const SymTab::Indexer &indexer;
-                Cost cost;
-                const TypeEnvironment &env;
-                CostFunction costFunc;
-          private:
-                // refactor for code resue
-                void conversionCostFromBasicToBasic( const BasicType * src, const BasicType* dest );
-        };
-        typedef std::function<int(const Type *, const Type *, const SymTab::Indexer &, const TypeEnvironment &)> PtrsFunction;
-        Cost convertToReferenceCost( const Type * src, const ReferenceType * dest, bool srcIsLvalue,
-                const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func );
 // Some function pointer types, differ in return type.

src/ResolvExpr/CurrentObject.cc

-              r0030b508
+              rfc12f05
 #include "Common/utility.h"            // for toString
 #include "CurrentObject.h"
-#include "SynTree/Constant.h"          // for Constant
-#include "SynTree/Declaration.h"       // for ObjectDecl, Declaration, Struc...
-#include "SynTree/Expression.h"        // for InitAlternative, VariableExpr
-#include "SynTree/Initializer.h"       // for Designation, operator<<
-#include "SynTree/Type.h"              // for Type, StructInstType, UnionIns...
-#include "SynTree/TypeSubstitution.h"  // for TypeSubstitution
 #if 0
 …
 #define PRINT(x)
 #endif
-namespace ResolvExpr {
-        template< typename AggrInst >
-        TypeSubstitution makeGenericSubstitution( AggrInst * inst ) {
-                assert( inst );
-                assert( inst->get_baseParameters() );
-                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
-                std::list< Expression * > typeSubs = inst->get_parameters();
-                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
-                return subs;
+        }
-        TypeSubstitution makeGenericSubstitution( Type * type ) {
-                if ( StructInstType * inst = dynamic_cast< StructInstType * >( type ) ) {
-                        return makeGenericSubstitution( inst );
-                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( type ) ) {
-                        return makeGenericSubstitution( inst );
-                } else {
-                        return TypeSubstitution();
+                }
+        }
-        class MemberIterator {
-        public:
-                virtual ~MemberIterator() {}
-                /// walks the current object using the given designators as a guide
-                virtual void setPosition( std::list< Expression * > & designators ) = 0;
-                /// retrieve the list of possible Type/Designation pairs for the current position in the currect object
-                virtual std::list<InitAlternative> operator*() const = 0;
-                /// true if the iterator is not currently at the end
-                virtual operator bool() const = 0;
-                /// moves the iterator by one member in the current object
-                virtual MemberIterator & bigStep() = 0;
-                /// moves the iterator by one member in the current subobject
-                virtual MemberIterator & smallStep() = 0;
-                /// the type of the current object
-                virtual Type * getType() = 0;
-                /// the type of the current subobject
-                virtual Type * getNext() = 0;
-                /// printing for debug
-                virtual void print( std::ostream & out, Indenter indent ) const = 0;
-                /// helper for operator*; aggregates must add designator to each init alternative, but
-                /// adding designators in operator* creates duplicates.
-                virtual std::list<InitAlternative> first() const = 0; // should be protected
-        };
-        std::ostream & operator<<(std::ostream & out, const MemberIterator & it) {
-                Indenter indenter;
-                it.print( out, indenter );
-                return out;
+        }
-        /// create a new MemberIterator that traverses a type correctly
-        MemberIterator * createMemberIterator( Type * type );
-        /// iterates "other" types, e.g. basic types, pointer types, etc. which do not change at list initializer entry
-        class SimpleIterator : public MemberIterator {
-        public:
-                SimpleIterator( Type * type ) : type( type ) {}
-                virtual void setPosition( std::list< Expression * > & designators ) {
-                        assertf( designators.empty(), "simple iterator given non-empty designator..." ); // xxx - might be semantic error
+                }
-                virtual std::list<InitAlternative> operator*() const { return first(); }
-                virtual operator bool() const { return type; }
-                // big step is the same as small step
-                virtual MemberIterator & bigStep() { return smallStep(); }
-                virtual MemberIterator & smallStep() {
-                        type = nullptr;  // type is nullified on increment since SimpleIterators do not have members
-                        return *this;
+                }
-                virtual void print( std::ostream & out, __attribute__((unused)) Indenter indent ) const {
-                        out << "SimpleIterator(" << type << ")";
+                }
-                virtual Type * getType() { return type; }
-                virtual Type * getNext() { return type; }
-        protected:
-                virtual std::list<InitAlternative> first() const {
-                        if ( type ) return std::list<InitAlternative>{ { type->clone(), new Designation( {} ) } };
-                        else return std::list<InitAlternative>{};
+                }
-        private:
-                Type * type = nullptr;
-        };
-        class ArrayIterator : public MemberIterator {
-        public:
-                ArrayIterator( ArrayType * at ) : array( at ) {
-                        PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
-                        base = at->base;
-                        memberIter = createMemberIterator( base );
-                        if ( at->isVarLen ) SemanticError( at, "VLA initialization does not support @=: " );
-                        setSize( at->dimension );
+                }
-                ~ArrayIterator() {
-                        delete memberIter;
+                }
-        private:
-                void setSize( Expression * expr ) {
-                        auto res = eval( expr );
-                        if (res.second) {
-                                size = res.first;
-                        } else {
-                                SemanticError( expr->location, toString("Array designator must be a constant expression: ", expr) );
+                        }
+                }
-        public:
-                void setPosition( Expression * expr ) {
-                        // need to permit integer-constant-expressions, including: integer constants, enumeration constants, character constants, sizeof expressions, _Alignof expressions, cast expressions
-                        auto arg = eval( expr );
-                        index = arg.first;
-                        return;
-                        // if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
-                        //      try {
-                        //              index = constExpr->intValue();
-                        //      } catch( SemanticErrorException & ) {
-                        //              SemanticError( expr, "Constant expression of non-integral type in array designator: " );
-                        //      }
-                        // } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                        //      setPosition( castExpr->get_arg() );
-                        // } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
-                        //      EnumInstType * inst = dynamic_cast<EnumInstType *>( varExpr->get_result() );
-                        //      assertf( inst, "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() );
-                        //      long long int value;
-                        //      if ( inst->baseEnum->valueOf( varExpr->var, value ) ) {
-                        //              index = value;
-                        //      }
-                        // } else if ( dynamic_cast< SizeofExpr * >( expr ) || dynamic_cast< AlignofExpr * >( expr ) ) {
-                        //      index = 0; // xxx - get actual sizeof/alignof value?
-                        // } else {
-                        //      assertf( false, "4 bad designator given to ArrayIterator: %s", toString( expr ).c_str() );
-                        // }
+                }
-                virtual void setPosition( std::list< Expression * > & designators ) {
-                        if ( ! designators.empty() ) {
-                                setPosition( designators.front() );
-                                designators.pop_front();
-                                memberIter->setPosition( designators );
+                        }
+                }
-                virtual std::list<InitAlternative> operator*() const {
-                        return first();
+                }
-                virtual operator bool() const { return index < size; }
-                virtual MemberIterator & bigStep() {
-                        PRINT( std::cerr << "bigStep in ArrayIterator (" << index << "/" << size << ")" << std::endl; )
-                        ++index;
-                        delete memberIter;
-                        if ( index < size ) memberIter = createMemberIterator( base );
-                        else memberIter = nullptr;
-                        return *this;
+                }
-                virtual MemberIterator & smallStep() {
-                        PRINT( std::cerr << "smallStep in ArrayIterator (" << index << "/" << size << ")" << std::endl; )
-                        if ( memberIter ) {
-                                PRINT( std::cerr << "has member iter: " << *memberIter << std::endl; )
-                                memberIter->smallStep();
-                                if ( *memberIter ) {
-                                        PRINT( std::cerr << "has valid member iter" << std::endl; )
-                                        return *this;
+                                }
+                        }
-                        return bigStep();
+                }
-                virtual Type * getType() { return array; }
-                virtual Type * getNext() { return base; }
-                virtual std::list<InitAlternative> first() const {
-                        PRINT( std::cerr << "first in ArrayIterator (" << index << "/" << size << ")" << std::endl; )
-                        if ( memberIter && *memberIter ) {
-                                std::list<InitAlternative> ret = memberIter->first();
-                                for ( InitAlternative & alt : ret ) {
-                                        alt.designation->get_designators().push_front( new ConstantExpr( Constant::from_ulong( index ) ) );
+                                }
-                                return ret;
+                        }
-                        return std::list<InitAlternative>();
+                }
-                virtual void print( std::ostream & out, Indenter indent ) const {
-                        out << "ArrayIterator(Array of " << base << ")";
-                        if ( memberIter ) {
-                                Indenter childIndent = indent+1;
-                                out << std::endl << childIndent;
-                                memberIter->print( out, childIndent );
+                        }
+                }
-        private:
-                ArrayType * array = nullptr;
-                Type * base = nullptr;
-                size_t index = 0;
-                size_t size = 0;
-                MemberIterator * memberIter = nullptr;
-        };
-        class AggregateIterator : public MemberIterator {
-        public:
-                typedef std::list<Declaration *> MemberList;
-                typedef MemberList::const_iterator iterator;
-                std::string kind = ""; // for debug
-                std::string name;
-                Type * inst = nullptr;
-                const MemberList & members;
-                iterator curMember;
-                bool atbegin = true; // false at first {small,big}Step -- this aggr type is only added to the possibilities at the beginning
-                Type * curType = nullptr;
-                MemberIterator * memberIter = nullptr;
-                mutable TypeSubstitution sub;
-                AggregateIterator( const std::string & kind, const std::string & name, Type * inst, const MemberList & members ) : kind( kind ), name( name ), inst( inst ), members( members ), curMember( members.begin() ), sub( makeGenericSubstitution( inst ) ) {
-                        PRINT( std::cerr << "Creating " << kind << "(" << name << ")"; )
-                        init();
+                }
-                virtual ~AggregateIterator() {
-                        delete memberIter;
+                }
-                bool init() {
-                        PRINT( std::cerr << "--init()--" << members.size() << std::endl; )
-                        if ( curMember != members.end() ) {
-                                if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( *curMember ) ) {
-                                        PRINT( std::cerr << "incremented to field: " << field << std::endl; )
-                                        curType = field->get_type();
-                                        memberIter = createMemberIterator( curType );
-                                        return true;
+                                }
+                        }
-                        return false;
+                }
-                virtual std::list<InitAlternative> operator*() const {
-                        if (memberIter && *memberIter) {
-                                std::list<InitAlternative> ret = memberIter->first();
-                                PRINT( std::cerr << "sub: " << sub << std::endl; )
-                                for ( InitAlternative & alt : ret ) {
-                                        PRINT( std::cerr << "iterating and adding designators" << std::endl; )
-                                        alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) );
-                                        // need to substitute for generic types, so that casts are to concrete types
-                                        PRINT( std::cerr << "  type is: " << alt.type; )
-                                        sub.apply( alt.type ); // also apply to designation??
-                                        PRINT( std::cerr << " ==> " << alt.type << std::endl; )
+                                }
-                                return ret;
+                        }
-                        return std::list<InitAlternative>();
+                }
-                virtual void setPosition( std::list< Expression * > & designators ) {
-                        if ( ! designators.empty() ) {
-                                if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( designators.front() ) ) {
-                                        for ( curMember = members.begin(); curMember != members.end(); ++curMember ) {
-                                                if ( *curMember == varExpr->get_var() ) {
-                                                        designators.pop_front();
-                                                        delete memberIter;
-                                                        memberIter = createMemberIterator( varExpr->get_result() );
-                                                        curType = varExpr->get_result();
-                                                        atbegin = curMember == members.begin() && designators.empty(); // xxx - is this the right condition for atbegin??
-                                                        memberIter->setPosition( designators );
-                                                        return;
-                                                } // if
-                                        } // for
-                                        assertf( false, "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() );
-                                } else {
-                                        assertf( false, "3 bad designator given to %s: %s", kind.c_str(), toString( designators.front() ).c_str() );
-                                } // if
-                        } // if
+                }
-                virtual MemberIterator & smallStep() {
-                        PRINT( std::cerr << "smallStep in " << kind << std::endl; )
-                        atbegin = false;
-                        if ( memberIter ) {
-                                PRINT( std::cerr << "has member iter, incrementing..." << std::endl; )
-                                memberIter->smallStep();
-                                if ( *memberIter ) {
-                                        PRINT( std::cerr << "success!" << std::endl; )
-                                        return *this;
+                                }
+                        }
-                        return bigStep();
+                }
-                virtual Type * getType() { return inst; }
-                virtual Type * getNext() {
-                        if ( memberIter && *memberIter ) return memberIter->getType(); // xxx - ??? recursive call???
-                        return nullptr;
+                }
-                virtual std::list<InitAlternative> first() const {
-                        std::list<InitAlternative> ret;
-                        PRINT( std::cerr << "first " << kind << std::endl; )
-                        if ( memberIter && *memberIter ) { // might not need *memberIter??
-                                PRINT( std::cerr << "adding children" << std::endl; )
-                                ret = memberIter->first();
-                                for ( InitAlternative & alt : ret ) {
-                                        PRINT( std::cerr << "iterating and adding designators" << std::endl; )
-                                        alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) );
+                                }
+                        }
-                        if ( atbegin ) {
-                                // xxx - what about case of empty struct??
-                                // only add self if at the very beginning of the structure
-                                PRINT( std::cerr << "adding self" << std::endl; )
-                                ret.push_front( { inst->clone(), new Designation( {} ) } );
+                        }
-                        return ret;
+                }
-                virtual void print( std::ostream & out, Indenter indent ) const {
-                        out << kind << "(" << name << ")";
-                        if ( memberIter ) {
-                                Indenter childIndent = indent+1;
-                                out << std::endl << childIndent;
-                                memberIter->print( out, childIndent );
+                        }
+                }
-        };
-        class UnionIterator : public AggregateIterator {
-        public:
-                UnionIterator( UnionInstType * inst ) : AggregateIterator( "UnionIterator", inst->get_name(), inst, inst->get_baseUnion()->get_members() ) {}
-                virtual operator bool() const { return (memberIter && *memberIter); }
-                virtual MemberIterator & bigStep() {
-                        // unions only initialize one member
-                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
-                        atbegin = false;
-                        delete memberIter;
-                        memberIter = nullptr;
-                        curType = nullptr;
-                        curMember = members.end();
-                        return *this;
+                }
-        };
-        class StructIterator : public AggregateIterator {
-        public:
-                StructIterator( StructInstType * inst ) : AggregateIterator( "StructIterator", inst->get_name(), inst, inst->get_baseStruct()->get_members() ) {}
-                virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); }
-                virtual MemberIterator & bigStep() {
-                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
-                        atbegin = false;
-                        delete memberIter;
-                        memberIter = nullptr;
-                        curType = nullptr;
-                        for ( ; curMember != members.end(); ) {
-                                ++curMember;
-                                if ( init() ) {
-                                        return *this;
+                                }
+                        }
-                        return *this;
+                }
-        };
-        class TupleIterator : public AggregateIterator {
-        public:
-                TupleIterator( TupleType * inst ) : AggregateIterator( "TupleIterator", toString("Tuple", inst->size()), inst, inst->get_members() ) {}
-                virtual operator bool() const { return curMember != members.end() || (memberIter && *memberIter); }
-                virtual MemberIterator & bigStep() {
-                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
-                        atbegin = false;
-                        delete memberIter;
-                        memberIter = nullptr;
-                        curType = nullptr;
-                        for ( ; curMember != members.end(); ) {
-                                ++curMember;
-                                if ( init() ) {
-                                        return *this;
+                                }
+                        }
-                        return *this;
+                }
-        };
-        MemberIterator * createMemberIterator( Type * type ) {
-                if ( ReferenceToType * aggr = dynamic_cast< ReferenceToType * >( type ) ) {
-                        if ( StructInstType * sit = dynamic_cast< StructInstType * >( aggr ) ) {
-                                return new StructIterator( sit );
-                        } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( aggr ) ) {
-                                return new UnionIterator( uit );
-                        } else {
-                                assertf( dynamic_cast< EnumInstType * >( type ) || dynamic_cast< TypeInstType * >( type ), "Encountered unhandled ReferenceToType in createMemberIterator: %s", toString( type ).c_str() );
-                                return new SimpleIterator( type );
+                        }
-                } else if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
-                        return new ArrayIterator( at );
-                } else if ( TupleType * tt = dynamic_cast< TupleType * >( type ) ) {
-                        return new TupleIterator( tt );
-                } else {
-                        return new SimpleIterator( type );
+                }
+        }
-        CurrentObject::CurrentObject() {}
-        CurrentObject::CurrentObject( Type * type ) {
-                objStack.push( new SimpleIterator( type ) );
+        }
-        void CurrentObject::setNext( Designation * designation ) {
-                assertf( ! objStack.empty(), "obj stack empty in setNext" );
-                PRINT( std::cerr << "____setNext" << designation << std::endl; )
-                objStack.top()->setPosition( designation->get_designators() );
+        }
-        Designation * CurrentObject::findNext( Designation * designation ) {
-                typedef std::list< Expression * > DesignatorChain;
-                PRINT( std::cerr << "___findNext" << std::endl; )
-                // find all the d's
-                std::list<DesignatorChain> desigAlts{ { } }, newDesigAlts;
-                std::list<Type *> curTypes { (objStack.top())->getType() }, newTypes;
-                for ( Expression * expr : designation->get_designators() ) {
-                        PRINT( std::cerr << "____untyped: " << expr << std::endl; )
-                        std::list<DesignatorChain>::iterator dit = desigAlts.begin();
-                        if ( NameExpr * nexpr = dynamic_cast<NameExpr *>(expr) ) {
-                                for ( Type * t : curTypes ) {
-                                        assert( dit != desigAlts.end() );
-                                        DesignatorChain & d = *dit;
-                                        PRINT( std::cerr << "____actual: " << t << std::endl; )
-                                        ReferenceToType * refType = dynamic_cast<ReferenceToType *>(t);
-                                        std::list<Declaration *> members;
-                                        if ( refType ) {
-                                                refType->lookup( nexpr->get_name(), members ); // concatenate identical field name
-                                                // xxx - need to also include anonymous members in this somehow...
-                                                for ( Declaration * mem: members ) {
-                                                        if ( ObjectDecl * field = dynamic_cast<ObjectDecl *>(mem) ) {
-                                                                PRINT( std::cerr << "____alt: " << field->get_type() << std::endl; )
-                                                                DesignatorChain newD = d;
-                                                                newD.push_back( new VariableExpr( field ) );
-                                                                newDesigAlts.push_back( newD );
-                                                                newTypes.push_back( field->get_type() );
-                                                        } // if
-                                                } // for
-                                        } // if
-                                        ++dit;
-                                } // for
-                        } else {
-                                for ( Type * t : curTypes ) {
-                                        assert( dit != desigAlts.end() );
-                                        DesignatorChain & d = *dit;
-                                        if ( ArrayType * at = dynamic_cast< ArrayType * > ( t ) ) {
-                                                PRINT( std::cerr << "____alt: " << at->get_base() << std::endl; )
-                                                d.push_back( expr );
-                                                newDesigAlts.push_back( d );
-                                                newTypes.push_back( at->get_base() );
+                                        }
-                                        ++dit;
-                                } // for
-                        } // if
-                        desigAlts = newDesigAlts;
-                        newDesigAlts.clear();
-                        curTypes = newTypes;
-                        newTypes.clear();
-                        assertf( desigAlts.size() == curTypes.size(), "Designator alternatives (%zu) and current types (%zu) out of sync", desigAlts.size(), curTypes.size() );
-                } // for
-                if ( desigAlts.size() > 1 ) {
-                        SemanticError( designation, toString("Too many alternatives (", desigAlts.size(), ") for designation: ") );
-                } else if ( desigAlts.size() == 0 ) {
-                        SemanticError( designation, "No reasonable alternatives for designation: " );
+                }
-                DesignatorChain & d = desigAlts.back();
-                PRINT( for ( Expression * expr : d ) {
-                        std::cerr << "____desig: " << expr << std::endl;
-                } ) // for
-                assertf( ! curTypes.empty(), "empty designator chosen");
-                // set new designators
-                assertf( ! objStack.empty(), "empty object stack when setting designation" );
-                Designation * actualDesignation = new Designation( d );
-                objStack.top()->setPosition( d ); // destroys d
-                return actualDesignation;
+        }
-        void CurrentObject::increment() {
-                PRINT( std::cerr << "____increment" << std::endl; )
-                if ( ! objStack.empty() ) {
-                        PRINT( std::cerr << *objStack.top() << std::endl; )
-                        objStack.top()->smallStep();
+                }
+        }
-        void CurrentObject::enterListInit() {
-                PRINT( std::cerr << "____entering list init" << std::endl; )
-                assertf( ! objStack.empty(), "empty obj stack entering list init" );
-                Type * type = objStack.top()->getNext();
-                if ( type ) {
-                        objStack.push( createMemberIterator( type ) );
-                } else {
-                        assertf( false, "not sure about this case..." );
+                }
+        }
-        void CurrentObject::exitListInit() {
-                PRINT( std::cerr << "____exiting list init" << std::endl; )
-                assertf( ! objStack.empty(), "objstack empty" );
-                delete objStack.top();
-                objStack.pop();
-                if ( ! objStack.empty() ) {
-                        PRINT( std::cerr << *objStack.top() << std::endl; )
-                        objStack.top()->bigStep();
+                }
+        }
-        std::list< InitAlternative > CurrentObject::getOptions() {
-                PRINT( std::cerr << "____getting current options" << std::endl; )
-                assertf( ! objStack.empty(), "objstack empty in getOptions" );
-                return **objStack.top();
+        }
-        Type * CurrentObject::getCurrentType() {
-                PRINT( std::cerr << "____getting current type" << std::endl; )
-                assertf( ! objStack.empty(), "objstack empty in getCurrentType" );
-                return objStack.top()->getNext();
+        }
-} // namespace ResolvExpr
 namespace ast {
 …
                                         } else if ( auto at = dynamic_cast< const ArrayType * >( t ) ) {
                                                 auto nexpr = dynamic_cast< const NameExpr *>( expr );
-                                                auto res = eval( nexpr );
                                                 for ( const Decl * mem : refType->lookup( nexpr->name ) ) {
                                                         if ( auto field = dynamic_cast< const ObjectDecl * >( mem ) ) {
 …
                                                                 d2.emplace_back( new VariableExpr{ expr->location, field } );
                                                                 newDesigAlts.emplace_back( std::move( d2 ) );
-                                                                // newTypes.emplace_back( field->type );
                                                                 newTypes.emplace_back( at->base );
+                                                        }
+                                                }
-                                                // d.emplace_back( expr );
-                                                // newDesigAlts.emplace_back( d );
-                                                // newTypes.emplace_back( at->base );
+                                        }

src/ResolvExpr/FindOpenVars.cc

-              r0030b508
+              rfc12f05
 #include "FindOpenVars.h"
-#include <list>                   // for _List_const_iterator, list<>::const...
-#include <map>                    // for map<>::mapped_type
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"
-#include "SynTree/Declaration.h"  // for TypeDecl, DeclarationWithType (ptr ...
-#include "SynTree/Type.h"         // for Type, Type::ForallList, ArrayType
 #include <iostream>
 namespace ResolvExpr {
-        struct FindOpenVars_old : public WithGuards {
-                FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
-                void previsit( const PointerType * pointerType );
-                void previsit( const ArrayType * arrayType );
-                void previsit( const FunctionType * functionType );
-                void previsit( const TupleType * tupleType );
-                void common_action( const Type *type );
-                OpenVarSet &openVars, &closedVars;
-                AssertionSet &needAssertions, &haveAssertions;
-                bool nextIsOpen;
-        };
-        void findOpenVars( const Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
-                PassVisitor<FindOpenVars_old> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
-                type->accept( finder );
+        }
-        FindOpenVars_old::FindOpenVars_old( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen )
-                : openVars( openVars ), closedVars( closedVars ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), nextIsOpen( firstIsOpen ) {
+        }
-        void FindOpenVars_old::common_action( const Type * type ) {
-                if ( nextIsOpen ) {
-                        for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
-                                openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
-                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
-                                        needAssertions[ *assert ].isUsed = false;
+                                }
-///       cloneAll( (*i)->get_assertions(), needAssertions );
-///       needAssertions.insert( needAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() );
+                        }
-                } else {
-                        for ( Type::ForallList::const_iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
-                                closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
-                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
-                                        haveAssertions[ *assert ].isUsed = false;
+                                }
-///       cloneAll( (*i)->get_assertions(), haveAssertions );
-///       haveAssertions.insert( haveAssertions.end(), (*i)->get_assertions().begin(), (*i)->get_assertions().end() );
-                        } // for
-                } // if
-///   std::cerr << "type is ";
-///   type->print( std::cerr );
-///   std::cerr << std::endl << "need is" << std::endl;
-///   printAssertionSet( needAssertions, std::cerr );
-///   std::cerr << std::endl << "have is" << std::endl;
-///   printAssertionSet( haveAssertions, std::cerr );
+        }
-        void FindOpenVars_old::previsit(const PointerType * pointerType) {
-                common_action( pointerType );
+        }
-        void FindOpenVars_old::previsit(const ArrayType * arrayType) {
-                common_action( arrayType );
+        }
-        void FindOpenVars_old::previsit(const FunctionType * functionType) {
-                common_action( functionType );
-                nextIsOpen = ! nextIsOpen;
-                GuardAction( [this](){ nextIsOpen = ! nextIsOpen; } );
+        }
-        void FindOpenVars_old::previsit(const TupleType * tupleType) {
-                common_action( tupleType );
+        }
         namespace {

src/ResolvExpr/FindOpenVars.h

-              r0030b508
+              rfc12f05
 #include "AST/TypeEnvironment.hpp"  // for AssertionSet, OpenVarSet
-#include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
-class Type;
 namespace ast {
         class Type;
 …
 namespace ResolvExpr {
-        // Updates open and closed variables and their associated assertions
-        void findOpenVars( const Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
         enum FirstMode { FirstClosed, FirstOpen };

src/ResolvExpr/PolyCost.cc

-              r0030b508
+              rfc12f05
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"
-#include "SymTab/Indexer.h"   // for Indexer
-#include "SynTree/Type.h"     // for TypeInstType, Type
-#include "TypeEnvironment.h"  // for EqvClass, TypeEnvironment
 namespace ResolvExpr {
-        struct PolyCost {
-                PolyCost( const TypeEnvironment &env, const SymTab::Indexer &indexer );
-                void previsit( TypeInstType * aggregateUseType );
-                int result;
-                const TypeEnvironment &tenv;
-                const SymTab::Indexer &indexer;
-        };
-        int polyCost( Type *type, const TypeEnvironment & env, const SymTab::Indexer &indexer ) {
-                PassVisitor<PolyCost> coster( env, indexer );
-                type->accept( coster );
-                return (coster.pass.result > 0) ? 1 : 0;
+        }
-        PolyCost::PolyCost( const TypeEnvironment & env, const SymTab::Indexer & indexer ) : result( 0 ), tenv( env ), indexer( indexer ) {
+        }
-        void PolyCost::previsit(TypeInstType * typeInst) {
-                if ( const EqvClass *eqvClass = tenv.lookup( typeInst->name ) ) {
-                        if ( eqvClass->type ) {
-                                if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass->type ) ) {
-                                        if ( indexer.lookupType( otherTypeInst->name ) ) {
-                                                // bound to opaque type
-                                                result += 1;
-                                        } // if
-                                } else {
-                                        // bound to concrete type
-                                        result += 1;
-                                } // if
-                        } // if
-                } // if
+        }
 // TODO: When the old PolyCost is torn out get rid of the _new suffix.

src/ResolvExpr/PtrsAssignable.cc

-              r0030b508
+              rfc12f05
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"
-#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
-#include "SynTree/Type.h"                // for TypeInstType, Type, BasicType
-#include "SynTree/Visitor.h"             // for Visitor
 namespace ResolvExpr {
-        struct PtrsAssignable : public WithShortCircuiting {
-                PtrsAssignable( const Type * dest, const TypeEnvironment &env );
-                int get_result() const { return result; }
-                void previsit( const Type * ) { visit_children = false; }
-                void postvisit( const VoidType * voidType );
-                void postvisit( const BasicType * basicType );
-                void postvisit( const PointerType * pointerType );
-                void postvisit( const ArrayType * arrayType );
-                void postvisit( const FunctionType * functionType );
-                void postvisit( const StructInstType * inst );
-                void postvisit( const UnionInstType * inst );
-                void postvisit( const EnumInstType * inst );
-                void postvisit( const TraitInstType * inst );
-                void postvisit( const TypeInstType * inst );
-                void postvisit( const TupleType * tupleType );
-                void postvisit( const VarArgsType * varArgsType );
-                void postvisit( const ZeroType * zeroType );
-                void postvisit( const OneType * oneType );
-          private:
-                const Type * dest;
-                int result;
-                const TypeEnvironment &env;
-        };
-        int ptrsAssignable( const Type *src, const Type * dest, const TypeEnvironment &env ) {
-                // std::cerr << "assignable: " << src << " | " << dest << std::endl;
-                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType* >( dest ) ) {
-                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
-                                return ptrsAssignable( src, eqvClass->type, env );
-                        } // if
-                } // if
-                if ( dynamic_cast< const VoidType* >( dest ) ) {
-                        // void * = T * for any T is unsafe
-                        // xxx - this should be safe, but that currently breaks the build
-                        return -1;
-                } else {
-                        PassVisitor<PtrsAssignable> ptrs( dest, env );
-                        src->accept( ptrs );
-                        return ptrs.pass.get_result();
-                } // if
+        }
-        PtrsAssignable::PtrsAssignable( const Type * dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
-        void PtrsAssignable::postvisit( const VoidType * ) {
-                // T * = void * is disallowed - this is a change from C, where any
-                // void * can be assigned or passed to a non-void pointer without a cast.
+        }
-        void PtrsAssignable::postvisit( const BasicType * ) {}
-        void PtrsAssignable::postvisit( const PointerType * ) {}
-        void PtrsAssignable::postvisit( const ArrayType * ) {}
-        void PtrsAssignable::postvisit( const FunctionType * ) {}
-        void PtrsAssignable::postvisit( const StructInstType * ) {}
-        void PtrsAssignable::postvisit( const UnionInstType * ) {}
-        void PtrsAssignable::postvisit( const EnumInstType * ) {
-                if ( dynamic_cast< const BasicType* >( dest ) ) {
-                        // int * = E *, etc. is safe. This isn't technically correct, as each
-                        // enum has one basic type that it is compatible with, an that type can
-                        // differ from enum to enum. Without replicating GCC's internal logic,
-                        // there is no way to know which type this particular enum is compatible
-                        // with, so punt on this for now.
-                        result = 1;
+                }
+        }
-        void PtrsAssignable::postvisit(  const TraitInstType * ) {}
-        void PtrsAssignable::postvisit( const TypeInstType * inst ) {
-                if ( const EqvClass * eqvClass = env.lookup( inst->name ) ) {
-                        if ( eqvClass->type ) {
-                                // T * = S * for any S depends on the type bound to T
-                                result = ptrsAssignable( eqvClass->type, dest, env );
+                        }
-                } // if
+        }
-        void PtrsAssignable::postvisit( const TupleType * ) {}
-        void PtrsAssignable::postvisit( const VarArgsType * ) {}
-        void PtrsAssignable::postvisit( const ZeroType * ) {}
-        void PtrsAssignable::postvisit( const OneType * ) {}
 // TODO: Get rid of the `_new` suffix when the old version is removed.

src/ResolvExpr/PtrsCastable.cc

-              r0030b508
+              rfc12f05
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"
 #include "ResolvExpr/PtrsAssignable.hpp" // for ptrsAssignable
-#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
-#include "SymTab/Indexer.h"              // for Indexer
-#include "SynTree/Declaration.h"         // for TypeDecl, TypeDecl::Kind::Ftype
-#include "SynTree/Type.h"                // for TypeInstType, Type, BasicType
-#include "SynTree/Visitor.h"             // for Visitor
 namespace ResolvExpr {
-        struct PtrsCastable_old : public WithShortCircuiting  {
-          public:
-                PtrsCastable_old( const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
-                int get_result() const { return result; }
-                void previsit( const Type * ) { visit_children = false; }
-                void postvisit( const VoidType * voidType );
-                void postvisit( const BasicType * basicType );
-                void postvisit( const PointerType * pointerType );
-                void postvisit( const ArrayType * arrayType );
-                void postvisit( const FunctionType * functionType );
-                void postvisit( const StructInstType * inst );
-                void postvisit( const UnionInstType * inst );
-                void postvisit( const EnumInstType * inst );
-                void postvisit( const TraitInstType * inst );
-                void postvisit( const TypeInstType * inst );
-                void postvisit( const TupleType * tupleType );
-                void postvisit( const VarArgsType * varArgsType );
-                void postvisit( const ZeroType * zeroType );
-                void postvisit( const OneType * oneType );
-          private:
-                const Type * dest;
-                int result;
-                const TypeEnvironment &env;
-                const SymTab::Indexer &indexer;
-        };
-        namespace {
-                int objectCast( const Type * src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
-                        if ( dynamic_cast< const FunctionType* >( src ) ) {
-                                return -1;
-                        } else if ( const TypeInstType * typeInst = dynamic_cast< const TypeInstType* >( src ) ) {
-                                if ( const NamedTypeDecl * ntDecl = indexer.lookupType( typeInst->name ) ) {
-                                        if ( const TypeDecl * tyDecl = dynamic_cast< const TypeDecl* >( ntDecl ) ) {
-                                                if ( tyDecl->kind == TypeDecl::Ftype ) {
-                                                        return -1;
-                                                } // if
-                                        } //if
-                                } else if ( const EqvClass * eqvClass = env.lookup( typeInst->get_name() ) ) {
-                                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
-                                                return -1;
-                                        } // if
-                                } // if
-                        } //if
-                        return 1;
+                }
-                int functionCast( const Type * src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
-                        return -1 * objectCast( src, env, indexer );  // reverse the sense of objectCast
+                }
+        }
-        int ptrsCastable( const Type * src, const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
-                if ( const TypeInstType * destAsTypeInst = dynamic_cast< const TypeInstType* >( dest ) ) {
-                        if ( const EqvClass * eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
-                                // xxx - should this be ptrsCastable?
-                                return ptrsAssignable( src, eqvClass->type, env );
-                        } // if
-                } // if
-                if ( dynamic_cast< const VoidType* >( dest ) ) {
-                        return objectCast( src, env, indexer );
-                } else {
-                        PassVisitor<PtrsCastable_old> ptrs( dest, env, indexer );
-                        src->accept( ptrs );
-                        return ptrs.pass.get_result();
-                } // if
+        }
-        PtrsCastable_old::PtrsCastable_old( const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer )
-                : dest( dest ), result( 0 ), env( env ), indexer( indexer )     {
+        }
-        void PtrsCastable_old::postvisit( const VoidType * ) {
-                result = objectCast( dest, env, indexer );
+        }
-        void PtrsCastable_old::postvisit( const BasicType * ) {
-                result = objectCast( dest, env, indexer );
+        }
-        void PtrsCastable_old::postvisit( const PointerType * ) {
-                result = objectCast( dest, env, indexer );
+        }
-        void PtrsCastable_old::postvisit( const ArrayType * ) {
-                result = objectCast( dest, env, indexer );
+        }
-        void PtrsCastable_old::postvisit( const FunctionType * ) {
-                // result = -1;
-                result = functionCast( dest, env, indexer );
+        }
-        void PtrsCastable_old::postvisit( const StructInstType * ) {
-                result = objectCast( dest, env, indexer );
+        }
-        void PtrsCastable_old::postvisit( const UnionInstType * ) {
-                result = objectCast( dest, env, indexer );
+        }
-        void PtrsCastable_old::postvisit( const EnumInstType * ) {
-                if ( dynamic_cast< const EnumInstType * >( dest ) ) {
-                        result = 1;
-                } else if ( const BasicType * bt = dynamic_cast< const BasicType * >( dest ) ) {
-                        if ( bt->kind == BasicType::SignedInt ) {
-                                result = 0;
-                        } else {
-                                result = 1;
+                        }
-                } else {
-                        result = objectCast( dest, env, indexer );
+                }
+        }
-        void PtrsCastable_old::postvisit( const TraitInstType * ) {}
-        void PtrsCastable_old::postvisit( const TypeInstType *inst ) {
-                //result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1;
-                result = objectCast( inst, env, indexer ) == objectCast( dest, env, indexer ) ? 1 : -1;
+        }
-        void PtrsCastable_old::postvisit( const TupleType * ) {
-                result = objectCast( dest, env, indexer );
+        }
-        void PtrsCastable_old::postvisit( const VarArgsType * ) {
-                result = objectCast( dest, env, indexer );
+        }
-        void PtrsCastable_old::postvisit( const ZeroType * ) {
-                result = objectCast( dest, env, indexer );
+        }
-        void PtrsCastable_old::postvisit( const OneType * ) {
-                result = objectCast( dest, env, indexer );
+        }
 namespace {

src/ResolvExpr/RenameVars.cc

-              r0030b508
+              rfc12f05
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
-#include "Common/PassVisitor.h"
 #include "Common/ScopedMap.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "RenameVars.h"
-#include "SynTree/Declaration.h"   // for DeclarationWithType, TypeDecl, Dec...
-#include "SynTree/Expression.h"    // for Expression
-#include "SynTree/Type.h"          // for Type, TypeInstType, TraitInstType
-#include "SynTree/Visitor.h"       // for acceptAll, maybeAccept
 #include "AST/Copy.hpp"
 …
+                }
-                void rename( TypeInstType * type ) {
-                        auto it = nameMap.find( type->name );
-                        if ( it != nameMap.end() ) {
-                                type->name = it->second;
+                        }
+                }
                 void nextUsage() {
                         ++next_usage_id;
+                }
-                void openLevel( Type * type ) {
-                        if ( ! type->forall.empty() ) {
-                                nameMap.beginScope();
-                                // renames all "forall" type names to `_${level}_${name}'
-                                for ( auto td : type->forall ) {
-                                        std::ostringstream output;
-                                        output << "_" << resetCount << "_" << level << "_" << td->name;
-                                        std::string newname( output.str() );
-                                        nameMap[ td->get_name() ] = newname;
-                                        td->name = newname;
-                                        // ditto for assertion names, the next level in
-                                        level++;
+                                }
+                        }
+                }
-                void closeLevel( Type * type ) {
-                        if ( !type->forall.empty() ) {
-                                nameMap.endScope();
+                        }
+                }
 …
         RenamingData renaming;
-        struct RenameVars_old {
-                void previsit( TypeInstType * instType ) {
-                        renaming.openLevel( (Type*)instType );
-                        renaming.rename( instType );
+                }
-                void previsit( Type * type ) {
-                        renaming.openLevel( type );
+                }
-                void postvisit( Type * type ) {
-                        renaming.closeLevel( type );
+                }
-        };
         struct RenameVars_new : public ast::PureVisitor /*: public ast::WithForallSubstitutor*/ {
                 RenameMode mode;
 …
 } // namespace
-void renameTyVars( Type * t ) {
-        PassVisitor<RenameVars_old> renamer;
-        t->accept( renamer );
+}
 const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode, bool reset ) {
         ast::Pass<RenameVars_new> renamer;

src/ResolvExpr/RenameVars.h

-              r0030b508
+              rfc12f05
 #pragma once
-#include <list>               // for list
-#include <map>                // for map
-#include <string>             // for string
-#include "SynTree/SynTree.h"  // for Visitor Nodes
-#include "SynTree/Visitor.h"  // for Visitor
 namespace ast {
         class Type;
 …
 namespace ResolvExpr {
-        /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID
-        void renameTyVars( Type * );
         enum RenameMode {
                 GEN_USAGE, // for type in VariableExpr

src/ResolvExpr/ResolveTypeof.cc

-              r0030b508
+              rfc12f05
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"   // for PassVisitor
 #include "Common/utility.h"       // for copy
 #include "InitTweak/InitTweak.h"  // for isConstExpr
 …
 #include "Resolver.h"  // for resolveInVoidContext
 #include "SymTab/Mangler.h"
-#include "SynTree/Expression.h"  // for Expression
-#include "SynTree/Mutator.h"     // for Mutator
-#include "SynTree/Type.h"        // for TypeofType, Type
-namespace SymTab {
-class Indexer;
-}  // namespace SymTab
 namespace ResolvExpr {
-namespace {
-#if 0
-                void
-                printAlts( const AltList &list, std::ostream &os, int indent = 0 )
+                {
-                        for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
-                                i->print( os, indent );
-                                os << std::endl;
+                        }
+                }
-#endif
+        }
-class ResolveTypeof_old : public WithShortCircuiting {
-   public:
-                ResolveTypeof_old( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
-                void premutate( TypeofType *typeofType );
-                Type * postmutate( TypeofType *typeofType );
-   private:
-    const SymTab::Indexer &indexer;
-};
-        Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
-                PassVisitor<ResolveTypeof_old> mutator( indexer );
-                return type->acceptMutator( mutator );
+        }
-        void ResolveTypeof_old::premutate( TypeofType * ) {
-                visit_children = false;
+        }
-    Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) {
-#if 0
-                std::cerr << "resolving typeof: ";
-                typeofType->print( std::cerr );
-                std::cerr << std::endl;
-#endif
-    // pass on null expression
-                if ( ! typeofType->expr ) return typeofType;
-    bool isBasetypeof = typeofType->is_basetypeof;
-    auto oldQuals = typeofType->get_qualifiers().val;
-    Type* newType;
-                if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(typeofType->expr) ) {
-        // typeof wrapping type
-        newType = tyExpr->type;
-        tyExpr->type = nullptr;
-        delete tyExpr;
-    } else {
-        // typeof wrapping expression
-                        Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
-                        assert( newExpr->result && ! newExpr->result->isVoid() );
-        newType = newExpr->result;
-        newExpr->result = nullptr;
-        delete typeofType;
-        delete newExpr;
+    }
-    // clear qualifiers for base, combine with typeoftype quals in any case
-    if ( isBasetypeof ) {
-                        // replace basetypeof(<enum>) by int
-                        if ( dynamic_cast<EnumInstType*>(newType) ) {
-                                Type* newerType =
-                                        new BasicType{ newType->get_qualifiers(), BasicType::SignedInt,
-                                        newType->attributes };
-                                delete newType;
-                                newType = newerType;
+                        }
-                        newType->get_qualifiers().val
-                                = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
-                } else {
-        newType->get_qualifiers().val |= oldQuals;
+    }
-    return newType;
+}
 namespace {

src/ResolvExpr/Resolver.cc

-              r0030b508
+              rfc12f05
 #include <vector>                        // for vector
-#include "Alternative.h"                 // for Alternative, AltList
-#include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
 #include "Candidate.hpp"
 #include "CandidateFinder.hpp"
 …
 #include "Common/Eval.h"                 // for eval
 #include "Common/Iterate.hpp"            // for group_iterate
-#include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/Stats/ResolveTime.h"    // for ResolveTime::start(), ResolveTime::stop()
 #include "Common/ToString.hpp"           // for toCString
+#include "Common/UniqueName.h"           // for UniqueName
 #include "InitTweak/GenInit.h"
 #include "InitTweak/InitTweak.h"         // for isIntrinsicSingleArgCallStmt
-#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
-#include "SymTab/Autogen.h"              // for SizeType
-#include "SymTab/Indexer.h"              // for Indexer
 #include "SymTab/Mangler.h"              // for Mangler
-#include "SynTree/Declaration.h"         // for ObjectDecl, TypeDecl, Declar...
-#include "SynTree/Expression.h"          // for Expression, CastExpr, InitExpr
-#include "SynTree/Initializer.h"         // for ConstructorInit, SingleInit
-#include "SynTree/Statement.h"           // for ForStmt, Statement, BranchStmt
-#include "SynTree/Type.h"                // for Type, BasicType, PointerType
-#include "SynTree/TypeSubstitution.h"    // for TypeSubstitution
-#include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
 #include "Tuples/Tuples.h"
 #include "Validate/FindSpecialDecls.h"   // for SizeType
 …
 namespace ResolvExpr {
-        struct Resolver_old final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver_old>, public WithShortCircuiting, public WithStmtsToAdd {
-                Resolver_old() {}
-                Resolver_old( const SymTab::Indexer & other ) {
-                        indexer = other;
+                }
-                void previsit( FunctionDecl * functionDecl );
-                void postvisit( FunctionDecl * functionDecl );
-                void previsit( ObjectDecl * objectDecll );
-                void previsit( EnumDecl * enumDecl );
-                void previsit( StaticAssertDecl * assertDecl );
-                void previsit( ArrayType * at );
-                void previsit( PointerType * at );
-                void previsit( ExprStmt * exprStmt );
-                void previsit( AsmExpr * asmExpr );
-                void previsit( AsmStmt * asmStmt );
-                void previsit( IfStmt * ifStmt );
-                void previsit( WhileDoStmt * whileDoStmt );
-                void previsit( ForStmt * forStmt );
-                void previsit( SwitchStmt * switchStmt );
-                void previsit( CaseStmt * caseStmt );
-                void previsit( BranchStmt * branchStmt );
-                void previsit( ReturnStmt * returnStmt );
-                void previsit( ThrowStmt * throwStmt );
-                void previsit( CatchStmt * catchStmt );
-                void postvisit( CatchStmt * catchStmt );
-                void previsit( WaitForStmt * stmt );
-                void previsit( SingleInit * singleInit );
-                void previsit( ListInit * listInit );
-                void previsit( ConstructorInit * ctorInit );
-          private:
-                typedef std::list< Initializer * >::iterator InitIterator;
-                template< typename PtrType >
-                void handlePtrType( PtrType * type );
-                void fallbackInit( ConstructorInit * ctorInit );
-                Type * functionReturn = nullptr;
-                CurrentObject currentObject = nullptr;
-                bool inEnumDecl = false;
-        };
-        struct ResolveWithExprs : public WithIndexer, public WithGuards, public WithVisitorRef<ResolveWithExprs>, public WithShortCircuiting, public WithStmtsToAdd {
-                void previsit( FunctionDecl * );
-                void previsit( WithStmt * );
-                void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
-        };
-        void resolve( std::list< Declaration * > translationUnit ) {
-                PassVisitor<Resolver_old> resolver;
-                acceptAll( translationUnit, resolver );
+        }
-        void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) {
-                PassVisitor<Resolver_old> resolver( indexer );
-                maybeAccept( decl, resolver );
+        }
-        namespace {
-                struct DeleteFinder_old : public WithShortCircuiting    {
-                        DeletedExpr * delExpr = nullptr;
-                        void previsit( DeletedExpr * expr ) {
-                                if ( delExpr ) visit_children = false;
-                                else delExpr = expr;
+                        }
-                        void previsit( Expression * ) {
-                                if ( delExpr ) visit_children = false;
+                        }
-                };
+        }
-        DeletedExpr * findDeletedExpr( Expression * expr ) {
-                PassVisitor<DeleteFinder_old> finder;
-                expr->accept( finder );
-                return finder.pass.delExpr;
+        }
-        namespace {
-                struct StripCasts_old {
-                        Expression * postmutate( CastExpr * castExpr ) {
-                                if ( castExpr->isGenerated && ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, SymTab::Indexer() ) ) {
-                                        // generated cast is to the same type as its argument, so it's unnecessary -- remove it
-                                        Expression * expr = castExpr->arg;
-                                        castExpr->arg = nullptr;
-                                        std::swap( expr->env, castExpr->env );
-                                        return expr;
+                                }
-                                return castExpr;
+                        }
-                        static void strip( Expression *& expr ) {
-                                PassVisitor<StripCasts_old> stripper;
-                                expr = expr->acceptMutator( stripper );
+                        }
-                };
-                void finishExpr( Expression *& expr, const TypeEnvironment & env, TypeSubstitution * oldenv = nullptr ) {
-                        expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
-                        env.makeSubstitution( *expr->env );
-                        StripCasts_old::strip( expr ); // remove unnecessary casts that may be buried in an expression
+                }
-                void removeExtraneousCast( Expression *& expr, const SymTab::Indexer & indexer ) {
-                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                                if ( typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
-                                        // cast is to the same type as its argument, so it's unnecessary -- remove it
-                                        expr = castExpr->arg;
-                                        castExpr->arg = nullptr;
-                                        std::swap( expr->env, castExpr->env );
-                                        delete castExpr;
+                                }
+                        }
+                }
-        } // namespace
-        namespace {
-                void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{} ) {
-                        assertf( untyped, "expected a non-null expression." );
-                        // xxx - this isn't thread-safe, but should work until we parallelize the resolver
-                        static unsigned recursion_level = 0;
-                        ++recursion_level;
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
-                        --recursion_level;
-                        #if 0
-                        if ( finder.get_alternatives().size() != 1 ) {
-                                std::cerr << "untyped expr is ";
-                                untyped->print( std::cerr );
-                                std::cerr << std::endl << "alternatives are:";
-                                for ( const Alternative & alt : finder.get_alternatives() ) {
-                                        alt.print( std::cerr );
-                                } // for
-                        } // if
-                        #endif
-                        // produce filtered list of alternatives
-                        AltList candidates;
-                        for ( Alternative & alt : finder.get_alternatives() ) {
-                                if ( pred( alt ) ) {
-                                        candidates.push_back( std::move( alt ) );
+                                }
+                        }
-                        // produce invalid error if no candidates
-                        if ( candidates.empty() ) {
-                                SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
+                        }
-                        // search for cheapest candidate
-                        AltList winners;
-                        bool seen_undeleted = false;
-                        for ( unsigned i = 0; i < candidates.size(); ++i ) {
-                                int c = winners.empty() ? -1 : candidates[i].cost.compare( winners.front().cost );
-                                if ( c > 0 ) continue; // skip more expensive than winner
-                                if ( c < 0 ) {
-                                        // reset on new cheapest
-                                        seen_undeleted = ! findDeletedExpr( candidates[i].expr );
-                                        winners.clear();
-                                } else /* if ( c == 0 ) */ {
-                                        if ( findDeletedExpr( candidates[i].expr ) ) {
-                                                // skip deleted expression if already seen one equivalent-cost not
-                                                if ( seen_undeleted ) continue;
-                                        } else if ( ! seen_undeleted ) {
-                                                // replace list of equivalent-cost deleted expressions with one non-deleted
-                                                winners.clear();
-                                                seen_undeleted = true;
+                                        }
+                                }
-                                winners.emplace_back( std::move( candidates[i] ) );
+                        }
-                        // promote alternative.cvtCost to .cost
-                        // xxx - I don't know why this is done, but I'm keeping the behaviour from findMinCost
-                        for ( Alternative& winner : winners ) {
-                                winner.cost = winner.cvtCost;
+                        }
-                        // produce ambiguous errors, if applicable
-                        if ( winners.size() != 1 ) {
-                                std::ostringstream stream;
-                                stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
-                                untyped->print( stream );
-                                stream << " Alternatives are:\n";
-                                printAlts( winners, stream, 1 );
-                                SemanticError( untyped->location, stream.str() );
+                        }
-                        // single selected choice
-                        Alternative& choice = winners.front();
-                        // fail on only expression deleted
-                        if ( ! seen_undeleted ) {
-                                SemanticError( untyped->location, choice.expr, "Unique best alternative includes deleted identifier in " );
+                        }
-                        // xxx - check for ambiguous expressions
-                        // output selected choice
-                        alt = std::move( choice );
+                }
-                /// resolve `untyped` to the expression whose alternative satisfies `pred` with the lowest cost; kindStr is used for providing better error messages
-                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{}) {
-                        if ( ! untyped ) return;
-                        Alternative choice;
-                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, mode );
-                        finishExpr( choice.expr, choice.env, untyped->env );
-                        delete untyped;
-                        untyped = choice.expr;
-                        choice.expr = nullptr;
+                }
-                bool standardAlternativeFilter( const Alternative & ) {
-                        // currently don't need to filter, under normal circumstances.
-                        // in the future, this may be useful for removing deleted expressions
-                        return true;
+                }
-        } // namespace
-        // used in resolveTypeof
-        Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer ) {
-                TypeEnvironment env;
-                return resolveInVoidContext( expr, indexer, env );
+        }
-        Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer, TypeEnvironment & env ) {
-                // it's a property of the language that a cast expression has either 1 or 0 interpretations; if it has 0
-                // interpretations, an exception has already been thrown.
-                assertf( expr, "expected a non-null expression." );
-                CastExpr * untyped = new CastExpr( expr ); // cast to void
-                untyped->location = expr->location;
-                // set up and resolve expression cast to void
-                Alternative choice;
-                findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
-                CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
-                assert( castExpr );
-                env = std::move( choice.env );
-                // clean up resolved expression
-                Expression * ret = castExpr->arg;
-                castExpr->arg = nullptr;
-                // unlink the arg so that it isn't deleted twice at the end of the program
-                untyped->arg = nullptr;
-                return ret;
+        }
-        void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
-                resetTyVarRenaming();
-                TypeEnvironment env;
-                Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
-                finishExpr( newExpr, env, untyped->env );
-                delete untyped;
-                untyped = newExpr;
+        }
-        void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
-                findKindExpression( untyped, indexer, "", standardAlternativeFilter );
+        }
-        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ) {
-                assert( untyped && type );
-                // transfer location to generated cast for error purposes
-                CodeLocation location = untyped->location;
-                untyped = new CastExpr( untyped, type );
-                untyped->location = location;
-                findSingleExpression( untyped, indexer );
-                removeExtraneousCast( untyped, indexer );
+        }
-        namespace {
-                bool isIntegralType( const Alternative & alt ) {
-                        Type * type = alt.expr->result;
-                        if ( dynamic_cast< EnumInstType * >( type ) ) {
-                                return true;
-                        } else if ( BasicType * bt = dynamic_cast< BasicType * >( type ) ) {
-                                return bt->isInteger();
-                        } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
-                                return true;
-                        } else {
-                                return false;
-                        } // if
+                }
-                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
-                        findKindExpression( untyped, indexer, "condition", isIntegralType );
+                }
+        }
-        bool isStructOrUnion( const Alternative & alt ) {
-                Type * t = alt.expr->result->stripReferences();
-                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
+        }
-        void resolveWithExprs( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<ResolveWithExprs> resolver;
-                acceptAll( translationUnit, resolver );
+        }
-        void ResolveWithExprs::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) {
-                for ( Expression *& expr : withExprs )  {
-                        // only struct- and union-typed expressions are viable candidates
-                        findKindExpression( expr, indexer, "with statement", isStructOrUnion );
-                        // if with expression might be impure, create a temporary so that it is evaluated once
-                        if ( Tuples::maybeImpure( expr ) ) {
-                                static UniqueName tmpNamer( "_with_tmp_" );
-                                ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
-                                expr = new VariableExpr( tmp );
-                                newStmts.push_back( new DeclStmt( tmp ) );
-                                if ( InitTweak::isConstructable( tmp->type ) ) {
-                                        // generate ctor/dtor and resolve them
-                                        tmp->init = InitTweak::genCtorInit( tmp );
-                                        tmp->accept( *visitor );
+                                }
+                        }
+                }
+        }
-        void ResolveWithExprs::previsit( WithStmt * withStmt ) {
-                resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
+        }
-        void ResolveWithExprs::previsit( FunctionDecl * functionDecl ) {
+                {
-                        // resolve with-exprs with parameters in scope and add any newly generated declarations to the
-                        // front of the function body.
-                        auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this](){ indexer.leaveScope(); } );
-                        indexer.addFunctionType( functionDecl->type );
-                        std::list< Statement * > newStmts;
-                        resolveWithExprs( functionDecl->withExprs, newStmts );
-                        if ( functionDecl->statements ) {
-                                functionDecl->statements->kids.splice( functionDecl->statements->kids.begin(), newStmts );
-                        } else {
-                                assertf( functionDecl->withExprs.empty() && newStmts.empty(), "Function %s without a body has with-clause and/or generated with declarations.", functionDecl->name.c_str() );
+                        }
+                }
+        }
-        void Resolver_old::previsit( ObjectDecl * objectDecl ) {
-                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
-                // class-variable initContext is changed multiple time because the LHS is analysed twice.
-                // The second analysis changes initContext because of a function type can contain object
-                // declarations in the return and parameter types. So each value of initContext is
-                // retained, so the type on the first analysis is preserved and used for selecting the RHS.
-                GuardValue( currentObject );
-                currentObject = CurrentObject( objectDecl->get_type() );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
-                        // enumerator initializers should not use the enum type to initialize, since
-                        // the enum type is still incomplete at this point. Use signed int instead.
-                        // TODO: BasicType::SignedInt may not longer be true
-                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                }
+        }
-        template< typename PtrType >
-        void Resolver_old::handlePtrType( PtrType * type ) {
-                if ( type->get_dimension() ) {
-                        findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
+                }
+        }
-        void Resolver_old::previsit( ArrayType * at ) {
-                handlePtrType( at );
+        }
-        void Resolver_old::previsit( PointerType * pt ) {
-                handlePtrType( pt );
+        }
-        void Resolver_old::previsit( FunctionDecl * functionDecl ) {
-#if 0
-                std::cerr << "resolver visiting functiondecl ";
-                functionDecl->print( std::cerr );
-                std::cerr << std::endl;
-#endif
-                GuardValue( functionReturn );
-                functionReturn = ResolvExpr::extractResultType( functionDecl->type );
+        }
-        void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up
-                // later passes.
-                // xxx - it might be necessary to somehow keep the information from this environment, but I
-                // can't currently see how it's useful.
-                for ( Declaration * d : functionDecl->type->parameters ) {
-                        if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( d ) ) {
-                                if ( SingleInit * init = dynamic_cast< SingleInit * >( obj->init ) ) {
-                                        delete init->value->env;
-                                        init->value->env = nullptr;
+                                }
+                        }
+                }
+        }
-        void Resolver_old::previsit( EnumDecl * ) {
-                // in case we decide to allow nested enums
-                GuardValue( inEnumDecl );
-                inEnumDecl = true;
+        }
-        void Resolver_old::previsit( StaticAssertDecl * assertDecl ) {
-                findIntegralExpression( assertDecl->condition, indexer );
+        }
-        void Resolver_old::previsit( ExprStmt * exprStmt ) {
-                visit_children = false;
-                assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
-                findVoidExpression( exprStmt->expr, indexer );
+        }
-        void Resolver_old::previsit( AsmExpr * asmExpr ) {
-                visit_children = false;
-                findVoidExpression( asmExpr->operand, indexer );
+        }
-        void Resolver_old::previsit( AsmStmt * asmStmt ) {
-                visit_children = false;
-                acceptAll( asmStmt->get_input(), *visitor );
-                acceptAll( asmStmt->get_output(), *visitor );
+        }
-        void Resolver_old::previsit( IfStmt * ifStmt ) {
-                findIntegralExpression( ifStmt->condition, indexer );
+        }
-        void Resolver_old::previsit( WhileDoStmt * whileDoStmt ) {
-                findIntegralExpression( whileDoStmt->condition, indexer );
+        }
-        void Resolver_old::previsit( ForStmt * forStmt ) {
-                if ( forStmt->condition ) {
-                        findIntegralExpression( forStmt->condition, indexer );
-                } // if
-                if ( forStmt->increment ) {
-                        findVoidExpression( forStmt->increment, indexer );
-                } // if
+        }
-        void Resolver_old::previsit( SwitchStmt * switchStmt ) {
-                GuardValue( currentObject );
-                findIntegralExpression( switchStmt->condition, indexer );
-                currentObject = CurrentObject( switchStmt->condition->result );
+        }
-        void Resolver_old::previsit( CaseStmt * caseStmt ) {
-                if ( caseStmt->condition ) {
-                        std::list< InitAlternative > initAlts = currentObject.getOptions();
-                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
-                        // must remove cast from case statement because RangeExpr cannot be cast.
-                        Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() );
-                        findSingleExpression( newExpr, indexer );
-                        // case condition cannot have a cast in C, so it must be removed, regardless of whether it performs a conversion.
-                        // Ideally we would perform the conversion internally here.
-                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( newExpr ) ) {
-                                newExpr = castExpr->arg;
-                                castExpr->arg = nullptr;
-                                std::swap( newExpr->env, castExpr->env );
-                                delete castExpr;
+                        }
-                        caseStmt->condition = newExpr;
+                }
+        }
-        void Resolver_old::previsit( BranchStmt * branchStmt ) {
-                visit_children = false;
-                // must resolve the argument for a computed goto
-                if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
-                        if ( branchStmt->computedTarget ) {
-                                // computed goto argument is void *
-                                findSingleExpression( branchStmt->computedTarget, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), indexer );
-                        } // if
-                } // if
+        }
-        void Resolver_old::previsit( ReturnStmt * returnStmt ) {
-                visit_children = false;
-                if ( returnStmt->expr ) {
-                        findSingleExpression( returnStmt->expr, functionReturn->clone(), indexer );
-                } // if
+        }
-        void Resolver_old::previsit( ThrowStmt * throwStmt ) {
-                visit_children = false;
-                // TODO: Replace *exception type with &exception type.
-                if ( throwStmt->get_expr() ) {
-                        const StructDecl * exception_decl = indexer.lookupStruct( "__cfaehm_base_exception_t" );
-                        assert( exception_decl );
-                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, const_cast<StructDecl *>(exception_decl) ) );
-                        findSingleExpression( throwStmt->expr, exceptType, indexer );
+                }
+        }
-        void Resolver_old::previsit( CatchStmt * catchStmt ) {
-                // Until we are very sure this invarent (ifs that move between passes have then)
-                // holds, check it. This allows a check for when to decode the mangling.
-                if ( IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body ) ) {
-                        assert( ifStmt->then );
+                }
-                // Encode the catchStmt so the condition can see the declaration.
-                if ( catchStmt->cond ) {
-                        IfStmt * ifStmt = new IfStmt( catchStmt->cond, nullptr, catchStmt->body );
-                        catchStmt->cond = nullptr;
-                        catchStmt->body = ifStmt;
+                }
+        }
-        void Resolver_old::postvisit( CatchStmt * catchStmt ) {
-                // Decode the catchStmt so everything is stored properly.
-                IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body );
-                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
-                        assert( ifStmt->condition );
-                        assert( ifStmt->else_ );
-                        catchStmt->cond = ifStmt->condition;
-                        catchStmt->body = ifStmt->else_;
-                        ifStmt->condition = nullptr;
-                        ifStmt->else_ = nullptr;
-                        delete ifStmt;
+                }
+        }
         template< typename iterator_t >
         inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) {
 …
                 return it != end;
+        }
-        void Resolver_old::previsit( WaitForStmt * stmt ) {
-                visit_children = false;
-                // Resolve all clauses first
-                for( auto& clause : stmt->clauses ) {
-                        TypeEnvironment env;
-                        AlternativeFinder funcFinder( indexer, env );
-                        // Find all alternatives for a function in canonical form
-                        funcFinder.findWithAdjustment( clause.target.function );
-                        if ( funcFinder.get_alternatives().empty() ) {
-                                stringstream ss;
-                                ss << "Use of undeclared indentifier '";
-                                ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
-                                ss << "' in call to waitfor";
-                                SemanticError( stmt->location, ss.str() );
+                        }
-                        if(clause.target.arguments.empty()) {
-                                SemanticError( stmt->location, "Waitfor clause must have at least one mutex parameter");
+                        }
-                        // Find all alternatives for all arguments in canonical form
-                        std::vector< AlternativeFinder > argAlternatives;
-                        funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) );
-                        // List all combinations of arguments
-                        std::vector< AltList > possibilities;
-                        combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
-                        AltList                func_candidates;
-                        std::vector< AltList > args_candidates;
-                        // For every possible function :
-                        //      try matching the arguments to the parameters
-                        //      not the other way around because we have more arguments than parameters
-                        SemanticErrorException errors;
-                        for ( Alternative & func : funcFinder.get_alternatives() ) {
-                                try {
-                                        PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
-                                        if( !pointer ) {
-                                                SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" );
+                                        }
-                                        FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
-                                        if( !function ) {
-                                                SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" );
+                                        }
+                                        {
-                                                auto param     = function->parameters.begin();
-                                                auto param_end = function->parameters.end();
-                                                if( !advance_to_mutex( param, param_end ) ) {
-                                                        SemanticError(function, "candidate function not viable: no mutex parameters\n");
+                                                }
+                                        }
-                                        Alternative newFunc( func );
-                                        // Strip reference from function
-                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
-                                        // For all the set of arguments we have try to match it with the parameter of the current function alternative
-                                        for ( auto & argsList : possibilities ) {
-                                                try {
-                                                        // Declare data structures need for resolution
-                                                        OpenVarSet openVars;
-                                                        AssertionSet resultNeed, resultHave;
-                                                        TypeEnvironment resultEnv( func.env );
-                                                        makeUnifiableVars( function, openVars, resultNeed );
-                                                        // add all type variables as open variables now so that those not used in the parameter
-                                                        // list are still considered open.
-                                                        resultEnv.add( function->forall );
-                                                        // Load type variables from arguemnts into one shared space
-                                                        simpleCombineEnvironments( argsList.begin(), argsList.end(), resultEnv );
-                                                        // Make sure we don't widen any existing bindings
-                                                        resultEnv.forbidWidening();
-                                                        // Find any unbound type variables
-                                                        resultEnv.extractOpenVars( openVars );
-                                                        auto param     = function->parameters.begin();
-                                                        auto param_end = function->parameters.end();
-                                                        int n_mutex_param = 0;
-                                                        // For every arguments of its set, check if it matches one of the parameter
-                                                        // The order is important
-                                                        for( auto & arg : argsList ) {
-                                                                // Ignore non-mutex arguments
-                                                                if( !advance_to_mutex( param, param_end ) ) {
-                                                                        // We ran out of parameters but still have arguments
-                                                                        // this function doesn't match
-                                                                        SemanticError( function, toString("candidate function not viable: too many mutex arguments, expected ", n_mutex_param, "\n" ));
+                                                                }
-                                                                n_mutex_param++;
-                                                                // Check if the argument matches the parameter type in the current scope
-                                                                if( ! unify( arg.expr->get_result(), (*param)->get_type(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
-                                                                        // Type doesn't match
-                                                                        stringstream ss;
-                                                                        ss << "candidate function not viable: no known convertion from '";
-                                                                        (*param)->get_type()->print( ss );
-                                                                        ss << "' to '";
-                                                                        arg.expr->get_result()->print( ss );
-                                                                        ss << "' with env '";
-                                                                        resultEnv.print(ss);
-                                                                        ss << "'\n";
-                                                                        SemanticError( function, ss.str() );
+                                                                }
-                                                                param++;
+                                                        }
-                                                        // All arguments match !
-                                                        // Check if parameters are missing
-                                                        if( advance_to_mutex( param, param_end ) ) {
-                                                                do {
-                                                                        n_mutex_param++;
-                                                                        param++;
-                                                                } while( advance_to_mutex( param, param_end ) );
-                                                                // We ran out of arguments but still have parameters left
-                                                                // this function doesn't match
-                                                                SemanticError( function, toString("candidate function not viable: too few mutex arguments, expected ", n_mutex_param, "\n" ));
+                                                        }
-                                                        // All parameters match !
-                                                        // Finish the expressions to tie in the proper environments
-                                                        finishExpr( newFunc.expr, resultEnv );
-                                                        for( Alternative & alt : argsList ) {
-                                                                finishExpr( alt.expr, resultEnv );
+                                                        }
-                                                        // This is a match store it and save it for later
-                                                        func_candidates.push_back( newFunc );
-                                                        args_candidates.push_back( argsList );
+                                                }
-                                                catch( SemanticErrorException & e ) {
-                                                        errors.append( e );
+                                                }
+                                        }
+                                }
-                                catch( SemanticErrorException & e ) {
-                                        errors.append( e );
+                                }
+                        }
-                        // Make sure we got the right number of arguments
-                        if( func_candidates.empty() )    { SemanticErrorException top( stmt->location, "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
-                        if( args_candidates.empty() )    { SemanticErrorException top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
-                        if( func_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
-                        if( args_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
-                        // TODO: need to use findDeletedExpr to ensure no deleted identifiers are used.
-                        // Swap the results from the alternative with the unresolved values.
-                        // Alternatives will handle deletion on destruction
-                        std::swap( clause.target.function, func_candidates.front().expr );
-                        for( auto arg_pair : group_iterate( clause.target.arguments, args_candidates.front() ) ) {
-                                std::swap ( std::get<0>( arg_pair), std::get<1>( arg_pair).expr );
+                        }
-                        // Resolve the conditions as if it were an IfStmt
-                        // Resolve the statments normally
-                        findSingleExpression( clause.condition, this->indexer );
-                        clause.statement->accept( *visitor );
+                }
-                if( stmt->timeout.statement ) {
-                        // Resolve the timeout as an size_t for now
-                        // Resolve the conditions as if it were an IfStmt
-                        // Resolve the statments normally
-                        findSingleExpression( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
-                        findSingleExpression( stmt->timeout.condition, this->indexer );
-                        stmt->timeout.statement->accept( *visitor );
+                }
-                if( stmt->orelse.statement ) {
-                        // Resolve the conditions as if it were an IfStmt
-                        // Resolve the statments normally
-                        findSingleExpression( stmt->orelse.condition, this->indexer );
-                        stmt->orelse.statement->accept( *visitor );
+                }
+        }
-        bool isCharType( Type * t ) {
-                if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
-                        return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
-                                bt->get_kind() == BasicType::UnsignedChar;
+                }
-                return false;
+        }
-        void Resolver_old::previsit( SingleInit * singleInit ) {
-                visit_children = false;
-                // resolve initialization using the possibilities as determined by the currentObject cursor
-                Expression * newExpr = new UntypedInitExpr( singleInit->value, currentObject.getOptions() );
-                findSingleExpression( newExpr, indexer );
-                InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
-                // move cursor to the object that is actually initialized
-                currentObject.setNext( initExpr->get_designation() );
-                // discard InitExpr wrapper and retain relevant pieces
-                newExpr = initExpr->expr;
-                initExpr->expr = nullptr;
-                std::swap( initExpr->env, newExpr->env );
-                // InitExpr may have inferParams in the case where the expression specializes a function
-                // pointer, and newExpr may already have inferParams of its own, so a simple swap is not
-                // sufficient.
-                newExpr->spliceInferParams( initExpr );
-                delete initExpr;
-                // get the actual object's type (may not exactly match what comes back from the resolver
-                // due to conversions)
-                Type * initContext = currentObject.getCurrentType();
-                removeExtraneousCast( newExpr, indexer );
-                // check if actual object's type is char[]
-                if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
-                        if ( isCharType( at->get_base() ) ) {
-                                // check if the resolved type is char *
-                                if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
-                                        if ( isCharType( pt->get_base() ) ) {
-                                                if ( CastExpr * ce = dynamic_cast< CastExpr * >( newExpr ) ) {
-                                                        // strip cast if we're initializing a char[] with a char *,
-                                                        // e.g.  char x[] = "hello";
-                                                        newExpr = ce->get_arg();
-                                                        ce->set_arg( nullptr );
-                                                        std::swap( ce->env, newExpr->env );
-                                                        delete ce;
+                                                }
+                                        }
+                                }
+                        }
+                }
-                // set initializer expr to resolved express
-                singleInit->value = newExpr;
-                // move cursor to next object in preparation for next initializer
-                currentObject.increment();
+        }
-        void Resolver_old::previsit( ListInit * listInit ) {
-                visit_children = false;
-                // move cursor into brace-enclosed initializer-list
-                currentObject.enterListInit();
-                // xxx - fix this so that the list isn't copied, iterator should be used to change current
-                // element
-                std::list<Designation *> newDesignations;
-                for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
-                        // iterate designations and initializers in pairs, moving the cursor to the current
-                        // designated object and resolving the initializer against that object.
-                        Designation * des = std::get<0>(p);
-                        Initializer * init = std::get<1>(p);
-                        newDesignations.push_back( currentObject.findNext( des ) );
-                        init->accept( *visitor );
+                }
-                // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
-                listInit->get_designations() = newDesignations; // xxx - memory management
-                currentObject.exitListInit();
-                // xxx - this part has not be folded into CurrentObject yet
-                // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
-                //      Type * base = tt->get_baseType()->get_base();
-                //      if ( base ) {
-                //              // know the implementation type, so try using that as the initContext
-                //              ObjectDecl tmpObj( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, base->clone(), nullptr );
-                //              currentObject = &tmpObj;
-                //              visit( listInit );
-                //      } else {
-                //              // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
-                //              Parent::visit( listInit );
-                //      }
-                // } else {
+        }
-        // ConstructorInit - fall back on C-style initializer
-        void Resolver_old::fallbackInit( ConstructorInit * ctorInit ) {
-                // could not find valid constructor, or found an intrinsic constructor
-                // fall back on C-style initializer
-                delete ctorInit->get_ctor();
-                ctorInit->set_ctor( nullptr );
-                delete ctorInit->get_dtor();
-                ctorInit->set_dtor( nullptr );
-                maybeAccept( ctorInit->get_init(), *visitor );
+        }
-        // needs to be callable from outside the resolver, so this is a standalone function
-        void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
-                assert( ctorInit );
-                PassVisitor<Resolver_old> resolver( indexer );
-                ctorInit->accept( resolver );
+        }
-        void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
-                assert( stmtExpr );
-                PassVisitor<Resolver_old> resolver( indexer );
-                stmtExpr->accept( resolver );
-                stmtExpr->computeResult();
-                // xxx - aggregate the environments from all statements? Possibly in AlternativeFinder instead?
+        }
-        void Resolver_old::previsit( ConstructorInit * ctorInit ) {
-                visit_children = false;
-                // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
-                maybeAccept( ctorInit->ctor, *visitor );
-                maybeAccept( ctorInit->dtor, *visitor );
-                // found a constructor - can get rid of C-style initializer
-                delete ctorInit->init;
-                ctorInit->init = nullptr;
-                // intrinsic single parameter constructors and destructors do nothing. Since this was
-                // implicitly generated, there's no way for it to have side effects, so get rid of it
-                // to clean up generated code.
-                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
-                        delete ctorInit->ctor;
-                        ctorInit->ctor = nullptr;
+                }
-                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
-                        delete ctorInit->dtor;
-                        ctorInit->dtor = nullptr;
+                }
-                // xxx - todo -- what about arrays?
-                // if ( dtor == nullptr && InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
-                //      // can reduce the constructor down to a SingleInit using the
-                //      // second argument from the ctor call, since
-                //      delete ctorInit->get_ctor();
-                //      ctorInit->set_ctor( nullptr );
-                //      Expression * arg =
-                //      ctorInit->set_init( new SingleInit( arg ) );
-                // }
+        }
-        ///////////////////////////////////////////////////////////////////////////
-        //
-        // *** NEW RESOLVER ***
-        //
-        ///////////////////////////////////////////////////////////////////////////
         namespace {

src/ResolvExpr/SatisfyAssertions.cpp

-              r0030b508
+              rfc12f05
 #include "SymTab/Mangler.h"
 namespace ResolvExpr {
 // in CandidateFinder.cpp; unique ID for assertion satisfaction
 extern UniqueId globalResnSlot;
+extern ast::UniqueId globalResnSlot;
 namespace {
 …
                         if ( !expr->inferred.hasSlots() ) return expr;
                         // if ( expr->inferred.mode != ast::Expr::InferUnion::Slots ) return expr;
                         std::vector<UniqueId> missingSlots;
+                        std::vector<ast::UniqueId> missingSlots;
                         // find inferred parameters for resolution slots
                         ast::InferredParams * newInferred = new ast::InferredParams();
                         for ( UniqueId slot : expr->inferred.resnSlots() ) {
+                        for ( ast::UniqueId slot : expr->inferred.resnSlots() ) {
                                 // fail if no matching assertions found
                                 auto it = inferred.find( slot );

src/ResolvExpr/SpecCost.cc

-              r0030b508
+              rfc12f05
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
-#include "Common/PassVisitor.h"
-#include "SynTree/Declaration.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Type.h"
 namespace ResolvExpr {
-        /// Counts specializations in a type
-        class CountSpecs : public WithShortCircuiting, public WithVisitorRef<CountSpecs> {
-                int count = -1;  ///< specialization count (-1 for none)
-        public:
-                int get_count() const { return count >= 0 ? count : 0; }
-                // mark specialization of base type
-                void postvisit(PointerType*) { if ( count >= 0 ) ++count; }
-                // mark specialization of base type
-                void postvisit(ArrayType*) { if ( count >= 0 ) ++count; }
-                // mark specialization of base type
-                void postvisit(ReferenceType*) { if ( count >= 0 ) ++count; }
-                void postvisit(StructInstType*) { if ( count >= 0 ) ++count; }
-                void postvisit(UnionInstType*) { if ( count >= 0 ) ++count; }
-        private:
-                // takes minimum non-negative count over parameter/return list
-                void takeminover( int& mincount, std::list<DeclarationWithType*>& dwts ) {
-                        for ( DeclarationWithType* dwt : dwts ) {
-                                count = -1;
-                                maybeAccept( dwt->get_type(), *visitor );
-                                if ( count != -1 && count < mincount ) mincount = count;
+                        }
+                }
-        public:
-                // take minimal specialization value over ->returnVals and ->parameters
-                void previsit(FunctionType* fty) {
-                        int mincount = std::numeric_limits<int>::max();
-                        takeminover( mincount, fty->parameters );
-                        takeminover( mincount, fty->returnVals );
-                        // add another level to mincount if set
-                        count = mincount < std::numeric_limits<int>::max() ? mincount + 1 : -1;
-                        // already visited children
-                        visit_children = false;
+                }
-        private:
-                // returns minimum non-negative count + 1 over type parameters (-1 if none such)
-                int minover( std::list<Expression*>& parms ) {
-                        int mincount = std::numeric_limits<int>::max();
-                        for ( Expression* parm : parms ) {
-                                count = -1;
-                                maybeAccept( parm->result, *visitor );
-                                if ( count != -1 && count < mincount ) mincount = count;
+                        }
-                        return mincount < std::numeric_limits<int>::max() ? mincount + 1 : -1;
+                }
-        public:
-                // look for polymorphic parameters
-                void previsit(StructInstType* sty) {
-                        count = minover( sty->parameters );
+                }
-                // look for polymorphic parameters
-                void previsit(UnionInstType* uty) {
-                        count = minover( uty->parameters );
+                }
-                // note polymorphic type (which may be specialized)
-                // xxx - maybe account for open/closed type variables
-                void postvisit(TypeInstType*) { count = 0; }
-                // take minimal specialization over elements
-                // xxx - maybe don't increment, tuple flattening doesn't necessarily specialize
-                void previsit(TupleType* tty) {
-                        int mincount = std::numeric_limits<int>::max();
-                        for ( Type* ty : tty->types ) {
-                                count = -1;
-                                maybeAccept( ty, *visitor );
-                                if ( count != -1 && count < mincount ) mincount = count;
+                        }
-                        count = mincount < std::numeric_limits<int>::max() ? mincount + 1 : -1;
-                        visit_children = false;
+                }
-        };
-        /// Returns the (negated) specialization cost for a given type
-        int specCost( Type* ty ) {
-                PassVisitor<CountSpecs> counter;
-                maybeAccept( ty, *counter.pass.visitor );
-                return counter.pass.get_count();
+        }
 namespace {

src/ResolvExpr/Unify.cc

-              r0030b508
+              rfc12f05
 #include "AST/TypeEnvironment.hpp"
 #include "Common/Eval.h"            // for eval
-#include "Common/PassVisitor.h"     // for PassVisitor
 #include "CommonType.hpp"           // for commonType
 #include "FindOpenVars.h"           // for findOpenVars
 #include "SpecCost.hpp"             // for SpecCost
-#include "SynTree/LinkageSpec.h"    // for C
-#include "SynTree/Constant.h"       // for Constant
-#include "SynTree/Declaration.h"    // for TypeDecl, TypeDecl::Data, Declarati...
-#include "SynTree/Expression.h"     // for TypeExpr, Expression, ConstantExpr
-#include "SynTree/Mutator.h"        // for Mutator
-#include "SynTree/Type.h"           // for Type, TypeInstType, FunctionType
-#include "SynTree/Visitor.h"        // for Visitor
 #include "Tuples/Tuples.h"          // for isTtype
-#include "TypeEnvironment.h"        // for EqvClass, AssertionSet, OpenVarSet
 #include "typeops.h"                // for flatten, occurs
 …
+}
-namespace SymTab {
-        class Indexer;
-}  // namespace SymTab
 // #define DEBUG
 namespace ResolvExpr {
-// Template Helpers:
-template< typename Iterator1, typename Iterator2 >
-bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, std::list< Type* > &commonTypes ) {
-        for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
-                Type *commonType = 0;
-                if ( ! unify( *list1Begin, *list2Begin, env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
-                        return false;
-                } // if
-                commonTypes.push_back( commonType );
-        } // for
-        return ( list1Begin == list1End && list2Begin == list2End );
+}
-template< typename Iterator1, typename Iterator2 >
-bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
-        std::list< Type* > commonTypes;
-        if ( unifyList( list1Begin, list1End, list2Begin, list2End, env, needAssertions, haveAssertions,  openVars, indexer, commonTypes ) ) {
-                deleteAll( commonTypes );
-                return true;
-        } else {
-                return false;
-        } // if
+}
-        struct Unify_old : public WithShortCircuiting {
-                Unify_old( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
-                bool get_result() const { return result; }
-                void previsit( BaseSyntaxNode * ) { visit_children = false; }
-                void postvisit( VoidType * voidType );
-                void postvisit( BasicType * basicType );
-                void postvisit( PointerType * pointerType );
-                void postvisit( ArrayType * arrayType );
-                void postvisit( ReferenceType * refType );
-                void postvisit( FunctionType * functionType );
-                void postvisit( StructInstType * aggregateUseType );
-                void postvisit( UnionInstType * aggregateUseType );
-                void postvisit( EnumInstType * aggregateUseType );
-                void postvisit( TraitInstType * aggregateUseType );
-                void postvisit( TypeInstType * aggregateUseType );
-                void postvisit( TupleType * tupleType );
-                void postvisit( VarArgsType * varArgsType );
-                void postvisit( ZeroType * zeroType );
-                void postvisit( OneType * oneType );
-          private:
-                template< typename RefType > void handleRefType( RefType *inst, Type *other );
-                template< typename RefType > void handleGenericRefType( RefType *inst, Type *other );
-                bool result;
-                Type *type2;                            // inherited
-                TypeEnvironment &env;
-                AssertionSet &needAssertions;
-                AssertionSet &haveAssertions;
-                const OpenVarSet &openVars;
-                WidenMode widen;
-                const SymTab::Indexer &indexer;
-        };
-        /// Attempts an inexact unification of type1 and type2.
-        /// Returns false if no such unification; if the types can be unified, sets common (unless they unify exactly and have identical type qualifiers)
-        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common );
-        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer );
-        bool unifyExact(
-                const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
-                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
-                WidenMode widen );
-        bool typesCompatible( const Type * first, const Type * second, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
-                TypeEnvironment newEnv;
-                OpenVarSet openVars, closedVars; // added closedVars
-                AssertionSet needAssertions, haveAssertions;
-                Type * newFirst = first->clone(), * newSecond = second->clone();
-                env.apply( newFirst );
-                env.apply( newSecond );
-                // do we need to do this? Seems like we do, types should be able to be compatible if they
-                // have free variables that can unify
-                findOpenVars( newFirst, openVars, closedVars, needAssertions, haveAssertions, false );
-                findOpenVars( newSecond, openVars, closedVars, needAssertions, haveAssertions, true );
-                bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                delete newFirst;
-                delete newSecond;
-                return result;
+        }
         bool typesCompatible(
 …
                 return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden() );
+        }
-        bool typesCompatibleIgnoreQualifiers( const Type * first, const Type * second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                TypeEnvironment newEnv;
-                OpenVarSet openVars;
-                AssertionSet needAssertions, haveAssertions;
-                Type *newFirst = first->clone(), *newSecond = second->clone();
-                env.apply( newFirst );
-                env.apply( newSecond );
-                newFirst->get_qualifiers() = Type::Qualifiers();
-                newSecond->get_qualifiers() = Type::Qualifiers();
-                bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                delete newFirst;
-                delete newSecond;
-                return result;
+        }
 …
                         subSecond,
                         newEnv, need, have, open, noWiden() );
+        }
-        bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
-                OpenVarSet closedVars;
-                findOpenVars( type1, openVars, closedVars, needAssertions, haveAssertions, false );
-                findOpenVars( type2, openVars, closedVars, needAssertions, haveAssertions, true );
-                Type *commonType = 0;
-                if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType ) ) {
-                        if ( commonType ) {
-                                delete commonType;
-                        } // if
-                        return true;
-                } else {
-                        return false;
-                } // if
+        }
-        bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, Type *&commonType ) {
-                OpenVarSet closedVars;
-                findOpenVars( type1, openVars, closedVars, needAssertions, haveAssertions, false );
-                findOpenVars( type2, openVars, closedVars, needAssertions, haveAssertions, true );
-                return unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType );
+        }
-        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer ) {
-#ifdef DEBUG
-                TypeEnvironment debugEnv( env );
-#endif
-                if ( type1->get_qualifiers() != type2->get_qualifiers() ) {
-                        return false;
+                }
-                bool result;
-                TypeInstType *var1 = dynamic_cast< TypeInstType* >( type1 );
-                TypeInstType *var2 = dynamic_cast< TypeInstType* >( type2 );
-                OpenVarSet::const_iterator entry1, entry2;
-                if ( var1 ) {
-                        entry1 = openVars.find( var1->get_name() );
-                } // if
-                if ( var2 ) {
-                        entry2 = openVars.find( var2->get_name() );
-                } // if
-                bool isopen1 = var1 && ( entry1 != openVars.end() );
-                bool isopen2 = var2 && ( entry2 != openVars.end() );
-                if ( isopen1 && isopen2 ) {
-                        if ( entry1->second.kind != entry2->second.kind ) {
-                                result = false;
-                        } else {
-                                result = env.bindVarToVar(
-                                        var1, var2, TypeDecl::Data{ entry1->second, entry2->second }, needAssertions,
-                                        haveAssertions, openVars, widen, indexer );
+                        }
-                } else if ( isopen1 ) {
-                        result = env.bindVar( var1, type2, entry1->second, needAssertions, haveAssertions, openVars, widen, indexer );
-                } else if ( isopen2 ) { // TODO: swap widen values in call, since type positions are flipped?
-                        result = env.bindVar( var2, type1, entry2->second, needAssertions, haveAssertions, openVars, widen, indexer );
-                } else {
-                        PassVisitor<Unify_old> comparator( type2, env, needAssertions, haveAssertions, openVars, widen, indexer );
-                        type1->accept( comparator );
-                        result = comparator.pass.get_result();
-                } // if
-#ifdef DEBUG
-                std::cerr << "============ unifyExact" << std::endl;
-                std::cerr << "type1 is ";
-                type1->print( std::cerr );
-                std::cerr << std::endl << "type2 is ";
-                type2->print( std::cerr );
-                std::cerr << std::endl << "openVars are ";
-                printOpenVarSet( openVars, std::cerr, 8 );
-                std::cerr << std::endl << "input env is " << std::endl;
-                debugEnv.print( std::cerr, 8 );
-                std::cerr << std::endl << "result env is " << std::endl;
-                env.print( std::cerr, 8 );
-                std::cerr << "result is " << result << std::endl;
-#endif
-                return result;
+        }
-        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
-                return unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+        }
-        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common ) {
-                Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
-                type1->get_qualifiers() = Type::Qualifiers();
-                type2->get_qualifiers() = Type::Qualifiers();
-                bool result;
-#ifdef DEBUG
-                std::cerr << "unifyInexact type 1 is ";
-                type1->print( std::cerr );
-                std::cerr << " type 2 is ";
-                type2->print( std::cerr );
-                std::cerr << std::endl;
-#endif
-                if ( ! unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, widen, indexer ) ) {
-#ifdef DEBUG
-                        std::cerr << "unifyInexact: no exact unification found" << std::endl;
-#endif
-                        if ( ( common = commonType( type1, type2, widen.first, widen.second, indexer, env, openVars ) ) ) {
-                                common->tq = tq1.unify( tq2 );
-#ifdef DEBUG
-                                std::cerr << "unifyInexact: common type is ";
-                                common->print( std::cerr );
-                                std::cerr << std::endl;
-#endif
-                                result = true;
-                        } else {
-#ifdef DEBUG
-                                std::cerr << "unifyInexact: no common type found" << std::endl;
-#endif
-                                result = false;
-                        } // if
-                } else {
-                        if ( tq1 != tq2 ) {
-                                if ( ( tq1 > tq2 || widen.first ) && ( tq2 > tq1 || widen.second ) ) {
-                                        common = type1->clone();
-                                        common->tq = tq1.unify( tq2 );
-                                        result = true;
-                                } else {
-                                        result = false;
-                                } // if
-                        } else {
-                                common = type1->clone();
-                                common->tq = tq1.unify( tq2 );
-                                result = true;
-                        } // if
-                } // if
-                type1->get_qualifiers() = tq1;
-                type2->get_qualifiers() = tq2;
-                return result;
+        }
-        Unify_old::Unify_old( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer )
-                : result( false ), type2( type2 ), env( env ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), openVars( openVars ), widen( widen ), indexer( indexer ) {
+        }
-        void Unify_old::postvisit( __attribute__((unused)) VoidType *voidType) {
-                result = dynamic_cast< VoidType* >( type2 );
+        }
-        void Unify_old::postvisit(BasicType *basicType) {
-                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
-                        result = basicType->get_kind() == otherBasic->get_kind();
-                } // if
+        }
-        void markAssertionSet( AssertionSet &assertions, DeclarationWithType *assert ) {
-                AssertionSet::iterator i = assertions.find( assert );
-                if ( i != assertions.end() ) {
-                        i->second.isUsed = true;
-                } // if
+        }
-        void markAssertions( AssertionSet &assertion1, AssertionSet &assertion2, Type *type ) {
-                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
-                        for ( std::list< DeclarationWithType* >::const_iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
-                                markAssertionSet( assertion1, *assert );
-                                markAssertionSet( assertion2, *assert );
-                        } // for
-                } // for
+        }
-        void Unify_old::postvisit(PointerType *pointerType) {
-                if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
-                        result = unifyExact( pointerType->get_base(), otherPointer->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                        markAssertions( haveAssertions, needAssertions, pointerType );
-                        markAssertions( haveAssertions, needAssertions, otherPointer );
-                } // if
+        }
-        void Unify_old::postvisit(ReferenceType *refType) {
-                if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
-                        result = unifyExact( refType->get_base(), otherRef->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                        markAssertions( haveAssertions, needAssertions, refType );
-                        markAssertions( haveAssertions, needAssertions, otherRef );
-                } // if
+        }
-        void Unify_old::postvisit(ArrayType *arrayType) {
-                ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 );
-                // to unify, array types must both be VLA or both not VLA
-                // and must both have a dimension expression or not have a dimension
-                if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() ) {
-                        if ( ! arrayType->get_isVarLen() && ! otherArray->get_isVarLen() &&
-                                arrayType->get_dimension() != 0 && otherArray->get_dimension() != 0 ) {
-                                ConstantExpr * ce1 = dynamic_cast< ConstantExpr * >( arrayType->get_dimension() );
-                                ConstantExpr * ce2 = dynamic_cast< ConstantExpr * >( otherArray->get_dimension() );
-                                // see C11 Reference Manual 6.7.6.2.6
-                                // two array types with size specifiers that are integer constant expressions are
-                                // compatible if both size specifiers have the same constant value
-                                if ( ce1 && ce2 ) {
-                                        Constant * c1 = ce1->get_constant();
-                                        Constant * c2 = ce2->get_constant();
-                                        if ( c1->get_value() != c2->get_value() ) {
-                                                // does not unify if the dimension is different
-                                                return;
+                                        }
+                                }
+                        }
-                        result = unifyExact( arrayType->get_base(), otherArray->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                } // if
+        }
-        template< typename Iterator, typename Func >
-        std::unique_ptr<Type> combineTypes( Iterator begin, Iterator end, Func & toType ) {
-                std::list< Type * > types;
-                for ( ; begin != end; ++begin ) {
-                        // it's guaranteed that a ttype variable will be bound to a flat tuple, so ensure that this results in a flat tuple
-                        flatten( toType( *begin ), back_inserter( types ) );
+                }
-                return std::unique_ptr<Type>( new TupleType( Type::Qualifiers(), types ) );
+        }
-        template< typename Iterator1, typename Iterator2 >
-        bool unifyTypeList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
-                auto get_type = [](DeclarationWithType * dwt){ return dwt->get_type(); };
-                for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
-                        Type * t1 = (*list1Begin)->get_type();
-                        Type * t2 = (*list2Begin)->get_type();
-                        bool isTtype1 = Tuples::isTtype( t1 );
-                        bool isTtype2 = Tuples::isTtype( t2 );
-                        // xxx - assumes ttype must be last parameter
-                        // xxx - there may be a nice way to refactor this, but be careful because the argument positioning might matter in some cases.
-                        if ( isTtype1 && ! isTtype2 ) {
-                                // combine all of the things in list2, then unify
-                                return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                        } else if ( isTtype2 && ! isTtype1 ) {
-                                // combine all of the things in list1, then unify
-                                return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                        } else if ( ! unifyExact( t1, t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) {
-                                return false;
-                        } // if
-                } // for
-                // may get to the end of one argument list before the end of the other. This is only okay when the other is a ttype
-                if ( list1Begin != list1End ) {
-                        // try unifying empty tuple type with ttype
-                        Type * t1 = (*list1Begin)->get_type();
-                        if ( Tuples::isTtype( t1 ) ) {
-                                return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                        } else return false;
-                } else if ( list2Begin != list2End ) {
-                        // try unifying empty tuple type with ttype
-                        Type * t2 = (*list2Begin)->get_type();
-                        if ( Tuples::isTtype( t2 ) ) {
-                                return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                        } else return false;
-                } else {
-                        return true;
-                } // if
+        }
-        /// Finds ttypes and replaces them with their expansion, if known.
-        /// This needs to be done so that satisfying ttype assertions is easier.
-        /// If this isn't done then argument lists can have wildly different
-        /// size and structure, when they should be compatible.
-        struct TtypeExpander_old : public WithShortCircuiting {
-                TypeEnvironment & tenv;
-                TtypeExpander_old( TypeEnvironment & tenv ) : tenv( tenv ) {}
-                void premutate( TypeInstType * ) { visit_children = false; }
-                Type * postmutate( TypeInstType * typeInst ) {
-                        if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) {
-                                // expand ttype parameter into its actual type
-                                if ( eqvClass->data.kind == TypeDecl::Ttype && eqvClass->type ) {
-                                        delete typeInst;
-                                        return eqvClass->type->clone();
+                                }
+                        }
-                        return typeInst;
+                }
-        };
-        /// flattens a list of declarations, so that each tuple type has a single declaration.
-        /// makes use of TtypeExpander to ensure ttypes are flat as well.
-        void flattenList( std::list< DeclarationWithType * > src, std::list< DeclarationWithType * > & dst, TypeEnvironment & env ) {
-                dst.clear();
-                for ( DeclarationWithType * dcl : src ) {
-                        PassVisitor<TtypeExpander_old> expander( env );
-                        dcl->acceptMutator( expander );
-                        std::list< Type * > types;
-                        flatten( dcl->get_type(), back_inserter( types ) );
-                        for ( Type * t : types ) {
-                                // outermost const, volatile, _Atomic qualifiers in parameters should not play a role in the unification of function types, since they do not determine whether a function is callable.
-                                // Note: MUST consider at least mutex qualifier, since functions can be overloaded on outermost mutex and a mutex function has different requirements than a non-mutex function.
-                                t->get_qualifiers() -= Type::Qualifiers(Type::Const | Type::Volatile | Type::Atomic);
-                                dst.push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::C, nullptr, t, nullptr ) );
+                        }
-                        delete dcl;
+                }
+        }
-        void Unify_old::postvisit(FunctionType *functionType) {
-                FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 );
-                if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) {
-                        // flatten the parameter lists for both functions so that tuple structure
-                        // doesn't affect unification. Must be a clone so that the types don't change.
-                        std::unique_ptr<FunctionType> flatFunc( functionType->clone() );
-                        std::unique_ptr<FunctionType> flatOther( otherFunction->clone() );
-                        flattenList( flatFunc->get_parameters(), flatFunc->get_parameters(), env );
-                        flattenList( flatOther->get_parameters(), flatOther->get_parameters(), env );
-                        // sizes don't have to match if ttypes are involved; need to be more precise wrt where the ttype is to prevent errors
-                        if (
-                                        (flatFunc->parameters.size() == flatOther->parameters.size() &&
-                                                flatFunc->returnVals.size() == flatOther->returnVals.size())
-                                        || flatFunc->isTtype()
-                                        || flatOther->isTtype()
-                        ) {
-                                if ( unifyTypeList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
-                                        if ( unifyTypeList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
-                                                // the original types must be used in mark assertions, since pointer comparisons are used
-                                                markAssertions( haveAssertions, needAssertions, functionType );
-                                                markAssertions( haveAssertions, needAssertions, otherFunction );
-                                                result = true;
-                                        } // if
-                                } // if
-                        } // if
-                } // if
+        }
-        template< typename RefType >
-        void Unify_old::handleRefType( RefType *inst, Type *other ) {
-                // check that other type is compatible and named the same
-                RefType *otherStruct = dynamic_cast< RefType* >( other );
-                result = otherStruct && inst->name == otherStruct->name;
+        }
-        template< typename RefType >
-        void Unify_old::handleGenericRefType( RefType *inst, Type *other ) {
-                // Check that other type is compatible and named the same
-                handleRefType( inst, other );
-                if ( ! result ) return;
-                // Check that parameters of types unify, if any
-                std::list< Expression* > params = inst->parameters;
-                std::list< Expression* > otherParams = ((RefType*)other)->parameters;
-                std::list< Expression* >::const_iterator it = params.begin(), jt = otherParams.begin();
-                for ( ; it != params.end() && jt != otherParams.end(); ++it, ++jt ) {
-                        TypeExpr *param = dynamic_cast< TypeExpr* >(*it);
-                        assertf(param, "Aggregate parameters should be type expressions");
-                        TypeExpr *otherParam = dynamic_cast< TypeExpr* >(*jt);
-                        assertf(otherParam, "Aggregate parameters should be type expressions");
-                        Type* paramTy = param->get_type();
-                        Type* otherParamTy = otherParam->get_type();
-                        bool tupleParam = Tuples::isTtype( paramTy );
-                        bool otherTupleParam = Tuples::isTtype( otherParamTy );
-                        if ( tupleParam && otherTupleParam ) {
-                                ++it; ++jt;  // skip ttype parameters for break
-                        } else if ( tupleParam ) {
-                                // bundle other parameters into tuple to match
-                                std::list< Type * > binderTypes;
-                                do {
-                                        binderTypes.push_back( otherParam->get_type()->clone() );
-                                        ++jt;
-                                        if ( jt == otherParams.end() ) break;
-                                        otherParam = dynamic_cast< TypeExpr* >(*jt);
-                                        assertf(otherParam, "Aggregate parameters should be type expressions");
-                                } while (true);
-                                otherParamTy = new TupleType{ paramTy->get_qualifiers(), binderTypes };
-                                ++it;  // skip ttype parameter for break
-                        } else if ( otherTupleParam ) {
-                                // bundle parameters into tuple to match other
-                                std::list< Type * > binderTypes;
-                                do {
-                                        binderTypes.push_back( param->get_type()->clone() );
-                                        ++it;
-                                        if ( it == params.end() ) break;
-                                        param = dynamic_cast< TypeExpr* >(*it);
-                                        assertf(param, "Aggregate parameters should be type expressions");
-                                } while (true);
-                                paramTy = new TupleType{ otherParamTy->get_qualifiers(), binderTypes };
-                                ++jt;  // skip ttype parameter for break
+                        }
-                        if ( ! unifyExact( paramTy, otherParamTy, env, needAssertions, haveAssertions, openVars, WidenMode(false, false), indexer ) ) {
-                                result = false;
-                                return;
+                        }
-                        // ttype parameter should be last
-                        if ( tupleParam || otherTupleParam ) break;
+                }
-                result = ( it == params.end() && jt == otherParams.end() );
+        }
-        void Unify_old::postvisit(StructInstType *structInst) {
-                handleGenericRefType( structInst, type2 );
+        }
-        void Unify_old::postvisit(UnionInstType *unionInst) {
-                handleGenericRefType( unionInst, type2 );
+        }
-        void Unify_old::postvisit(EnumInstType *enumInst) {
-                handleRefType( enumInst, type2 );
+        }
-        void Unify_old::postvisit(TraitInstType *contextInst) {
-                handleRefType( contextInst, type2 );
+        }
-        void Unify_old::postvisit(TypeInstType *typeInst) {
-                assert( openVars.find( typeInst->get_name() ) == openVars.end() );
-                TypeInstType *otherInst = dynamic_cast< TypeInstType* >( type2 );
-                if ( otherInst && typeInst->get_name() == otherInst->get_name() ) {
-                        result = true;
-///   } else {
-///     NamedTypeDecl *nt = indexer.lookupType( typeInst->get_name() );
-///     if ( nt ) {
-///       TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
-///       assert( type );
-///       if ( type->get_base() ) {
-///         result = unifyExact( type->get_base(), typeInst, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-///       }
-///     }
-                } // if
+        }
-        template< typename Iterator1, typename Iterator2 >
-        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
-                auto get_type = [](Type * t) { return t; };
-                for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
-                        Type * t1 = *list1Begin;
-                        Type * t2 = *list2Begin;
-                        bool isTtype1 = Tuples::isTtype( t1 );
-                        bool isTtype2 = Tuples::isTtype( t2 );
-                        // xxx - assumes ttype must be last parameter
-                        // xxx - there may be a nice way to refactor this, but be careful because the argument positioning might matter in some cases.
-                        if ( isTtype1 && ! isTtype2 ) {
-                                // combine all of the things in list2, then unify
-                                return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                        } else if ( isTtype2 && ! isTtype1 ) {
-                                // combine all of the things in list1, then unify
-                                return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                        } else if ( ! unifyExact( t1, t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) {
-                                return false;
-                        } // if
-                } // for
-                if ( list1Begin != list1End ) {
-                        // try unifying empty tuple type with ttype
-                        Type * t1 = *list1Begin;
-                        if ( Tuples::isTtype( t1 ) ) {
-                                return unifyExact( t1, combineTypes( list2Begin, list2End, get_type ).get(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                        } else return false;
-                } else if ( list2Begin != list2End ) {
-                        // try unifying empty tuple type with ttype
-                        Type * t2 = *list2Begin;
-                        if ( Tuples::isTtype( t2 ) ) {
-                                return unifyExact( combineTypes( list1Begin, list1End, get_type ).get(), t2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
-                        } else return false;
-                } else {
-                        return true;
-                } // if
+        }
-        void Unify_old::postvisit(TupleType *tupleType) {
-                if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) {
-                        std::unique_ptr<TupleType> flat1( tupleType->clone() );
-                        std::unique_ptr<TupleType> flat2( otherTuple->clone() );
-                        std::list<Type *> types1, types2;
-                        PassVisitor<TtypeExpander_old> expander( env );
-                        flat1->acceptMutator( expander );
-                        flat2->acceptMutator( expander );
-                        flatten( flat1.get(), back_inserter( types1 ) );
-                        flatten( flat2.get(), back_inserter( types2 ) );
-                        result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, indexer );
-                } // if
+        }
-        void Unify_old::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) {
-                result = dynamic_cast< VarArgsType* >( type2 );
+        }
-        void Unify_old::postvisit( __attribute__((unused)) ZeroType *zeroType ) {
-                result = dynamic_cast< ZeroType* >( type2 );
+        }
-        void Unify_old::postvisit( __attribute__((unused)) OneType *oneType ) {
-                result = dynamic_cast< OneType* >( type2 );
+        }
-        Type * extractResultType( FunctionType * function ) {
-                if ( function->get_returnVals().size() == 0 ) {
-                        return new VoidType( Type::Qualifiers() );
-                } else if ( function->get_returnVals().size() == 1 ) {
-                        return function->get_returnVals().front()->get_type()->clone();
-                } else {
-                        std::list< Type * > types;
-                        for ( DeclarationWithType * decl : function->get_returnVals() ) {
-                                types.push_back( decl->get_type()->clone() );
-                        } // for
-                        return new TupleType( Type::Qualifiers(), types );
+                }
+        }

src/ResolvExpr/Unify.h

-              r0030b508
+              rfc12f05
 #include "AST/Node.hpp"             // for ptr
 #include "AST/TypeEnvironment.hpp"  // for TypeEnvironment, AssertionSet, OpenVarSet
-#include "Common/utility.h"       // for deleteAll
-#include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Data
-#include "TypeEnvironment.h"      // for AssertionSet, OpenVarSet
 #include "WidenMode.h"              // for WidenMode
-class Type;
-class TypeInstType;
-namespace SymTab {
-        class Indexer;
+}
 namespace ast {
 …
 namespace ResolvExpr {
-bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
-bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, Type *&commonType );
-bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
-bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common );
-bool typesCompatible( const Type *, const Type *, const SymTab::Indexer & indexer, const TypeEnvironment & env );
-bool typesCompatibleIgnoreQualifiers( const Type *, const Type *, const SymTab::Indexer & indexer, const TypeEnvironment & env );
-inline bool typesCompatible( const Type * t1, const Type * t2, const SymTab::Indexer & indexer ) {
-        TypeEnvironment env;
-        return typesCompatible( t1, t2, indexer, env );
+}
-inline bool typesCompatibleIgnoreQualifiers( const Type * t1, const Type * t2, const SymTab::Indexer & indexer ) {
-        TypeEnvironment env;
-        return typesCompatibleIgnoreQualifiers( t1, t2, indexer, env );
+}
 bool unify(
 …
         const ast::TypeEnvironment & env = {} );
-/// Creates the type represented by the list of returnVals in a FunctionType.
-/// The caller owns the return value.
-Type * extractResultType( FunctionType * functionType );
 /// Creates or extracts the type represented by returns in a `FunctionType`.
 ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func );

src/ResolvExpr/module.mk

-              r0030b508
+              rfc12f05
       ResolvExpr/AdjustExprType.cc \
       ResolvExpr/AdjustExprType.hpp \
-      ResolvExpr/Alternative.cc \
-      ResolvExpr/AlternativeFinder.cc \
-      ResolvExpr/AlternativeFinder.h \
-      ResolvExpr/Alternative.h \
       ResolvExpr/Candidate.cpp \
       ResolvExpr/CandidateFinder.cpp \
 …
       ResolvExpr/CurrentObject.cc \
       ResolvExpr/CurrentObject.h \
-      ResolvExpr/ExplodedActual.cc \
-      ResolvExpr/ExplodedActual.h \
       ResolvExpr/ExplodedArg.cpp \
       ResolvExpr/ExplodedArg.hpp \
       ResolvExpr/FindOpenVars.cc \
       ResolvExpr/FindOpenVars.h \
-      ResolvExpr/Occurs.cc \
       ResolvExpr/PolyCost.cc \
       ResolvExpr/PolyCost.hpp \
 …
       ResolvExpr/RenameVars.cc \
       ResolvExpr/RenameVars.h \
-      ResolvExpr/ResolveAssertions.cc \
-      ResolvExpr/ResolveAssertions.h \
       ResolvExpr/Resolver.cc \
       ResolvExpr/Resolver.h \
 …
       ResolvExpr/SpecCost.cc \
       ResolvExpr/SpecCost.hpp \
-      ResolvExpr/TypeEnvironment.cc \
-      ResolvExpr/TypeEnvironment.h \
       ResolvExpr/typeops.h \
       ResolvExpr/Unify.cc \
 …
 SRC += $(SRC_RESOLVEXPR) \
-        ResolvExpr/AlternativePrinter.cc \
-        ResolvExpr/AlternativePrinter.h \
         ResolvExpr/CandidatePrinter.cpp \
         ResolvExpr/CandidatePrinter.hpp \

src/ResolvExpr/typeops.h

-              r0030b508
+              rfc12f05
 #include "AST/Type.hpp"
-#include "SynTree/Type.h"
 namespace SymTab {
 …
                         std::copy( i.begin(), i.end(), inserter );
                         *out++ = result;
+                }
+        }
-        // in Occurs.cc
-        bool occurs( const Type * type, const std::string & varName, const TypeEnvironment & env );
-        // new AST version in TypeEnvironment.cpp (only place it was used in old AST)
-        template<typename Iter>
-        bool occursIn( Type* ty, Iter begin, Iter end, const TypeEnvironment & env ) {
-                while ( begin != end ) {
-                        if ( occurs( ty, *begin, env ) ) return true;
-                        ++begin;
+                }
-                return false;
+        }
-        /// flatten tuple type into list of types
-        template< typename OutputIterator >
-        void flatten( Type * type, OutputIterator out ) {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
-                        for ( Type * t : tupleType->get_types() ) {
-                                flatten( t, out );
+                        }
-                } else {
-                        *out++ = type->clone();
+                }
+        }
 …
                 return tupleFromTypes( tys.begin(), tys.end() );
+        }
-        // in TypeEnvironment.cc
-        bool isFtype( const Type * type );
 } // namespace ResolvExpr

src/SymTab/Demangle.cc

-              r0030b508
+              rfc12f05
 // Author           : Rob Schluntz
 // Created On       : Thu Jul 19 12:52:41 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan 11 21:28:27 2021
 // Update Count     : 11
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Nov  6 15:59:00 2023
+// Update Count     : 12
 //
 …
 #include <sstream>
+#include "AST/Pass.hpp"
+#include "AST/Type.hpp"
 #include "CodeGen/GenType.h"
 #include "Common/PassVisitor.h"
+#include "CodeGen/OperatorTable.h"
 #include "Common/utility.h"                                                             // isPrefix
 #include "Mangler.h"
-#include "SynTree/Type.h"
-#include "SynTree/Declaration.h"
 #define DEBUG
 …
 #endif
+namespace Mangle {
 namespace {
+        struct GenType : public WithVisitorRef<GenType>, public WithShortCircuiting {
+                std::string typeString;
+                GenType( const std::string &typeString );
+                void previsit( BaseSyntaxNode * );
+                void postvisit( BaseSyntaxNode * );
+                void postvisit( FunctionType * funcType );
+                void postvisit( VoidType * voidType );
+                void postvisit( BasicType * basicType );
+                void postvisit( PointerType * pointerType );
+                void postvisit( ArrayType * arrayType );
+                void postvisit( ReferenceType * refType );
+                void postvisit( StructInstType * structInst );
+                void postvisit( UnionInstType * unionInst );
+                void postvisit( EnumInstType * enumInst );
+                void postvisit( TypeInstType * typeInst );
+                void postvisit( TupleType  * tupleType );
+                void postvisit( VarArgsType * varArgsType );
+                void postvisit( ZeroType * zeroType );
+                void postvisit( OneType * oneType );
+                void postvisit( GlobalScopeType * globalType );
+                void postvisit( QualifiedType * qualType );
+          private:
+                void handleQualifiers( Type *type );
+                std::string handleGeneric( ReferenceToType * refType );
+                void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
+        };
+  std::string genDemangleType( Type * type, const std::string & baseString ) {
+                PassVisitor<GenType> gt( baseString );
+                assert( type );
+                type->accept( gt );
+                return gt.pass.typeString;
+  }
+        GenType::GenType( const std::string &typeString ) : typeString( typeString ) {}
+        // *** BaseSyntaxNode
+        void GenType::previsit( BaseSyntaxNode * ) {
+                // turn off automatic recursion for all nodes, to allow each visitor to
+                // precisely control the order in which its children are visited.
+                visit_children = false;
+        }
+        void GenType::postvisit( BaseSyntaxNode * node ) {
+                std::stringstream ss;
+                node->print( ss );
+                assertf( false, "Unhandled node reached in GenType: %s", ss.str().c_str() );
+        }
+        void GenType::postvisit( VoidType * voidType ) {
+                typeString = "void " + typeString;
+                handleQualifiers( voidType );
+        }
+        void GenType::postvisit( BasicType * basicType ) {
+                BasicType::Kind kind = basicType->kind;
+                assert( 0 <= kind && kind < BasicType::NUMBER_OF_BASIC_TYPES );
+                typeString = std::string( BasicType::typeNames[kind] ) + " " + typeString;
+                handleQualifiers( basicType );
+        }
+        void GenType::genArray( const Type::Qualifiers & qualifiers, Type * base, Expression *dimension, bool isVarLen, bool ) {
+                std::ostringstream os;
+                if ( typeString != "" ) {
+                        if ( typeString[ 0 ] == '*' ) {
+                                os << "(" << typeString << ")";
+                        } else {
+                                os << typeString;
+                        } // if
+                } // if
+                os << "[";
+                if ( qualifiers.is_const ) {
+                        os << "const ";
+                } // if
+                if ( qualifiers.is_volatile ) {
+                        os << "volatile ";
+                } // if
+                if ( qualifiers.is_restrict ) {
+                        os << "__restrict ";
+                } // if
+                if ( qualifiers.is_atomic ) {
+                        os << "_Atomic ";
+                } // if
+                if ( dimension != 0 ) {
+                        // TODO: ???
+                        // PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        // dimension->accept( cg );
+                } else if ( isVarLen ) {
+                        // no dimension expression on a VLA means it came in with the * token
+                        os << "*";
+                } // if
+                os << "]";
+                typeString = os.str();
+                base->accept( *visitor );
+        }
+        void GenType::postvisit( PointerType * pointerType ) {
+                assert( pointerType->base != 0);
+                if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->dimension ) {
+                        assert(false);
+                        genArray( pointerType->get_qualifiers(), pointerType->base, pointerType->dimension, pointerType->get_isVarLen(), pointerType->get_isStatic() );
+                } else {
+                        handleQualifiers( pointerType );
+                        if ( typeString[ 0 ] == '?' ) {
+                                typeString = "* " + typeString;
+                        } else {
+                                typeString = "*" + typeString;
+                        } // if
+                        pointerType->base->accept( *visitor );
+                } // if
+        }
+        void GenType::postvisit( ArrayType * arrayType ) {
+                genArray( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->get_isVarLen(), arrayType->get_isStatic() );
+        }
+        void GenType::postvisit( ReferenceType * refType ) {
+                assert( false );
+                assert( refType->base != 0);
+                handleQualifiers( refType );
+                typeString = "&" + typeString;
+                refType->base->accept( *visitor );
+        }
+        void GenType::postvisit( FunctionType * funcType ) {
+                std::ostringstream os;
+                if ( typeString != "" ) {
+                        if ( typeString[0] == '*' ) {
+                                os << "(" << typeString << ")";
+                        } else {
+                                os << typeString;
+                        } // if
+                } // if
+                /************* parameters ***************/
+                const std::list<DeclarationWithType *> &pars = funcType->parameters;
+                if ( pars.empty() ) {
+                        if ( funcType->get_isVarArgs() ) {
+                                os << "()";
+                        } else {
+                                os << "(void)";
+                        } // if
+                } else {
+                        os << "(" ;
+                        unsigned int i = 0;
+                        for (DeclarationWithType * p : pars) {
+                                os << genDemangleType( p->get_type(), "" );
+                                if (++i != pars.size()) os << ", ";
+                        }
+                        if ( funcType->get_isVarArgs() ) {
+                                os << ", ...";
+                        } // if
+                        os << ")";
+                } // if
+                typeString = os.str();
+                if ( funcType->returnVals.size() == 0 ) {
+                        typeString += ": void";
+                } else {
+                        typeString += ": " + genDemangleType(funcType->returnVals.front()->get_type(), "");
+                } // if
+                // add forall
+                if( ! funcType->forall.empty() ) {
+                        std::ostringstream os;
+                        os << "forall(";
+                        unsigned int i = 0;
+                        for ( auto td : funcType->forall ) {
+                                os << td->typeString() << " " << td->name;
+                                if (! td->assertions.empty()) {
+                                        os << " | { ";
+                                        unsigned int j = 0;
+                                        for (DeclarationWithType * assert : td->assertions) {
+                                                os << genDemangleType(assert->get_type(), assert->name);
+                                                if (++j != td->assertions.size()) os << ", ";
+                                        }
+                                        os << "}";
+                                }
+                                if (++i != funcType->forall.size()) os << ", ";
+                        }
+                        os << ")";
+                        typeString = typeString + " -> " + os.str();
+struct Demangler {
+private:
+        std::string str;
+        size_t index = 0;
+        using Parser = std::function<ast::Type * ( ast::CV::Qualifiers )>;
+        std::vector<std::pair<std::string, Parser>> parsers;
+public:
+        Demangler( const std::string & str );
+        bool done() const { return str.size() <= index; }
+        char cur() const { assert( !done() ); return str[index]; }
+        bool expect( char ch ) { return str[index++] == ch; }
+        bool isPrefix( const std::string & pref );
+        bool extractNumber( size_t & out );
+        bool extractName( std::string & out );
+        bool stripMangleName( std::string & name );
+        ast::Type * parseFunction( ast::CV::Qualifiers tq );
+        ast::Type * parseTuple( ast::CV::Qualifiers tq );
+        ast::Type * parsePointer( ast::CV::Qualifiers tq );
+        ast::Type * parseArray( ast::CV::Qualifiers tq );
+        ast::Type * parseStruct( ast::CV::Qualifiers tq );
+        ast::Type * parseUnion( ast::CV::Qualifiers tq );
+        ast::Type * parseEnum( ast::CV::Qualifiers tq );
+        ast::Type * parseType( ast::CV::Qualifiers tq );
+        ast::Type * parseZero( ast::CV::Qualifiers tq );
+        ast::Type * parseOne( ast::CV::Qualifiers tq );
+        ast::Type * parseType();
+        bool parse( std::string & name, ast::Type *& type );
+};
+Demangler::Demangler(const std::string & str) : str(str) {
+        for (size_t k = 0; k < ast::BasicType::NUMBER_OF_BASIC_TYPES; ++k) {
+                parsers.emplace_back(Encoding::basicTypes[k], [k]( ast::CV::Qualifiers tq ) {
+                        PRINT( std::cerr << "basic type: " << k << std::endl; )
+                        return new ast::BasicType( (ast::BasicType::Kind)k, tq );
+                });
+        }
+        for (size_t k = 0; k < ast::TypeDecl::NUMBER_OF_KINDS; ++k) {
+                static const std::string typeVariableNames[] = { "DT", "DST", "OT", "FT", "TT", "ALT", };
+                static_assert(
+                        sizeof(typeVariableNames)/sizeof(typeVariableNames[0]) == ast::TypeDecl::NUMBER_OF_KINDS,
+                        "Each type variable kind should have a demangle name prefix"
+                );
+                parsers.emplace_back(Encoding::typeVariables[k], [k, this]( ast::CV::Qualifiers tq ) -> ast::TypeInstType * {
+                        PRINT( std::cerr << "type variable type: " << k << std::endl; )
+                        size_t N;
+                        if (!extractNumber(N)) return nullptr;
+                        return new ast::TypeInstType(
+                                toString(typeVariableNames[k], N),
+                                (ast::TypeDecl::Kind)k,
+                                tq );
+                });
+        }
+        parsers.emplace_back(Encoding::void_t, [this]( ast::CV::Qualifiers tq ) { return new ast::VoidType(tq); });
+        parsers.emplace_back(Encoding::function, [this]( ast::CV::Qualifiers tq ) { return parseFunction(tq); });
+        parsers.emplace_back(Encoding::pointer, [this]( ast::CV::Qualifiers tq ) { return parsePointer(tq); });
+        parsers.emplace_back(Encoding::array, [this]( ast::CV::Qualifiers tq ) { return parseArray(tq); });
+        parsers.emplace_back(Encoding::tuple, [this]( ast::CV::Qualifiers tq ) { return parseTuple(tq); });
+        parsers.emplace_back(Encoding::struct_t, [this]( ast::CV::Qualifiers tq ) { return parseStruct(tq); });
+        parsers.emplace_back(Encoding::union_t, [this]( ast::CV::Qualifiers tq ) { return parseUnion(tq); });
+        parsers.emplace_back(Encoding::enum_t, [this]( ast::CV::Qualifiers tq ) { return parseEnum(tq); });
+        parsers.emplace_back(Encoding::type, [this]( ast::CV::Qualifiers tq ) { return parseType(tq); });
+        parsers.emplace_back(Encoding::zero, []( ast::CV::Qualifiers tq ) { return new ast::ZeroType(tq); });
+        parsers.emplace_back(Encoding::one, []( ast::CV::Qualifiers tq ) { return new ast::OneType(tq); });
+}
+bool Demangler::extractNumber( size_t & out ) {
+        std::stringstream numss;
+        if ( str.size() <= index ) return false;
+        while ( isdigit( str[index] ) ) {
+                numss << str[index];
+                ++index;
+                if ( str.size() == index ) break;
+        }
+        if ( !(numss >> out) ) return false;
+        PRINT( std::cerr << "extractNumber success: " << out << std::endl; )
+        return true;
+}
+bool Demangler::extractName( std::string & out ) {
+        size_t len;
+        if ( !extractNumber(len) ) return false;
+        if ( str.size() < index + len ) return false;
+        out = str.substr( index, len );
+        index += len;
+        PRINT( std::cerr << "extractName success: " << out << std::endl; )
+        return true;
+}
+bool Demangler::isPrefix( const std::string & pref ) {
+        // Wraps the utility isPrefix function.
+        if ( ::isPrefix( str, pref, index ) ) {
+                index += pref.size();
+                return true;
+        }
+        return false;
+}
+// strips __NAME__cfa__TYPE_N, where N is [0-9]+: returns str is a match is found, returns empty string otherwise
+bool Demangler::stripMangleName( std::string & name ) {
+        PRINT( std::cerr << "====== " << str.size() << " " << str << std::endl; )
+        if (str.size() < 2+Encoding::manglePrefix.size()) return false; // +2 for at least _1 suffix
+        if ( !isPrefix(Encoding::manglePrefix) || !isdigit(str.back() ) ) return false;
+        if (!extractName(name)) return false;
+        // Find bounds for type.
+        PRINT( std::cerr << index << " " << str.size() << std::endl; )
+        PRINT( std::cerr << "[");
+        while (isdigit(str.back())) {
+                PRINT(std::cerr << ".");
+                str.pop_back();
+                if (str.size() <= index) return false;
+        }
+        PRINT( std::cerr << "]" << std::endl );
+        if (str.back() != '_') return false;
+        str.pop_back();
+        PRINT( std::cerr << str.size() << " " << name << " " << str.substr(index) << std::endl; )
+        return index < str.size();
+}
+ast::Type * Demangler::parseFunction( ast::CV::Qualifiers tq ) {
+        PRINT( std::cerr << "function..." << std::endl; )
+        if ( done() ) return nullptr;
+        ast::FunctionType * ftype = new ast::FunctionType( ast::FixedArgs, tq );
+        std::unique_ptr<ast::Type> manager( ftype );
+        ast::Type * retVal = parseType();
+        if ( !retVal ) return nullptr;
+        PRINT( std::cerr << "with return type: " << retVal << std::endl; )
+        ftype->returns.emplace_back( retVal );
+        if ( done() || !expect('_') ) return nullptr;
+        while ( !done() ) {
+                PRINT( std::cerr << "got ch: " << cur() << std::endl; )
+                if ( cur() == '_' ) return manager.release();
+                ast::Type * param = parseType();
+                if ( !param ) return nullptr;
+                PRINT( std::cerr << "with parameter : " << param << std::endl; )
+                ftype->params.emplace_back( param );
+        }
+        return nullptr;
+}
+ast::Type * Demangler::parseTuple( ast::CV::Qualifiers tq ) {
+        PRINT( std::cerr << "tuple..." << std::endl; )
+        std::vector<ast::ptr<ast::Type>> types;
+        size_t ncomponents;
+        if ( !extractNumber(ncomponents) ) return nullptr;
+        for ( size_t i = 0; i < ncomponents; ++i ) {
+                if ( done() ) return nullptr;
+                PRINT( std::cerr << "got ch: " << cur() << std::endl; )
+                ast::Type * t = parseType();
+                if ( !t ) return nullptr;
+                PRINT( std::cerr << "with type : " << t << std::endl; )
+                types.push_back( t );
+        }
+        return new ast::TupleType( std::move( types ), tq );
+}
+ast::Type * Demangler::parsePointer( ast::CV::Qualifiers tq ) {
+        PRINT( std::cerr << "pointer..." << std::endl; )
+        ast::Type * t = parseType();
+        if ( !t ) return nullptr;
+        return new ast::PointerType( t, tq );
+}
+ast::Type * Demangler::parseArray( ast::CV::Qualifiers tq ) {
+        PRINT( std::cerr << "array..." << std::endl; )
+        size_t length;
+        if ( !extractNumber(length) ) return nullptr;
+        ast::Type * t = parseType();
+        if ( !t ) return nullptr;
+        return new ast::ArrayType(
+                t,
+                ast::ConstantExpr::from_ulong( CodeLocation(), length ),
+                ast::FixedLen,
+                ast::DynamicDim,
+                tq );
+}
+ast::Type * Demangler::parseStruct( ast::CV::Qualifiers tq ) {
+        PRINT( std::cerr << "struct..." << std::endl; )
+        std::string name;
+        if ( !extractName(name) ) return nullptr;
+        return new ast::StructInstType( name, tq );
+}
+ast::Type * Demangler::parseUnion( ast::CV::Qualifiers tq ) {
+        PRINT( std::cerr << "union..." << std::endl; )
+        std::string name;
+        if ( !extractName(name) ) return nullptr;
+        return new ast::UnionInstType( name, tq );
+}
+ast::Type * Demangler::parseEnum( ast::CV::Qualifiers tq ) {
+        PRINT( std::cerr << "enum..." << std::endl; )
+        std::string name;
+        if ( !extractName(name) ) return nullptr;
+        return new ast::EnumInstType( name, tq );
+}
+ast::Type * Demangler::parseType( ast::CV::Qualifiers tq ) {
+        PRINT( std::cerr << "type..." << std::endl; )
+        std::string name;
+        if ( !extractName(name) ) return nullptr;
+        PRINT( std::cerr << "typename..." << name << std::endl; )
+        return new ast::TypeInstType( name, ast::TypeDecl::Dtype, tq );
+}
+ast::Type * Demangler::parseType() {
+        if (done()) return nullptr;
+        if (isPrefix(Encoding::forall)) {
+                PRINT( std::cerr << "polymorphic with..." << std::endl; )
+                size_t dcount, fcount, vcount, acount;
+                if ( !extractNumber(dcount) ) return nullptr;
+                PRINT( std::cerr << dcount << " dtypes" << std::endl; )
+                if ( !expect('_') ) return nullptr;
+                if ( !extractNumber(fcount) ) return nullptr;
+                PRINT( std::cerr << fcount << " ftypes" << std::endl; )
+                if ( !expect('_')) return nullptr;
+                if ( !extractNumber(vcount)) return nullptr;
+                PRINT( std::cerr << vcount << " ttypes" << std::endl; )
+                if ( !expect('_') ) return nullptr;
+                if ( !extractNumber(acount) ) return nullptr;
+                PRINT( std::cerr << acount << " assertions" << std::endl; )
+                if ( !expect('_') ) return nullptr;
+                for ( size_t i = 0 ; i < acount ; ++i ) {
+                        // TODO: need to recursively parse assertions, but for now just return nullptr so that
+                        // demangler does not crash if there are assertions
+                        return nullptr;
+                }
+        }
+        std::string GenType::handleGeneric( ReferenceToType * refType ) {
+                if ( ! refType->parameters.empty() ) {
+                        std::ostringstream os;
+                        // TODO: ???
+                        // PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
+                        os << "(";
+                        // cg.pass.genCommaList( refType->parameters.begin(), refType->parameters.end() );
+                        os << ") ";
+                        return os.str();
+                }
+                return "";
+        }
+        void GenType::postvisit( StructInstType * structInst )  {
+                typeString = "struct " + structInst->name + handleGeneric( structInst ) + " " + typeString;
+                handleQualifiers( structInst );
+        }
+        void GenType::postvisit( UnionInstType * unionInst ) {
+                typeString = "union " + unionInst->name + handleGeneric( unionInst ) + " " + typeString;
+                handleQualifiers( unionInst );
+        }
+        void GenType::postvisit( EnumInstType * enumInst ) {
+                typeString = "enum " + enumInst->name + " " + typeString;
+                handleQualifiers( enumInst );
+        }
+        void GenType::postvisit( TypeInstType * typeInst ) {
+                typeString = typeInst->name + " " + typeString;
+                handleQualifiers( typeInst );
+        }
+        void GenType::postvisit( TupleType * tupleType ) {
+                unsigned int i = 0;
+                std::ostringstream os;
+                os << "[";
+                for ( Type * t : *tupleType ) {
+                        i++;
+                        os << genDemangleType( t, "" ) << (i == tupleType->size() ? "" : ", ");
+                }
+                os << "] ";
+                typeString = os.str() + typeString;
+        }
+        void GenType::postvisit( VarArgsType * varArgsType ) {
+                typeString = "__builtin_va_list " + typeString;
+                handleQualifiers( varArgsType );
+        }
+        void GenType::postvisit( ZeroType * zeroType ) {
+                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
+                typeString = "zero_t " + typeString;
+                handleQualifiers( zeroType );
+        }
+        void GenType::postvisit( OneType * oneType ) {
+                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
+                typeString = "one_t " + typeString;
+                handleQualifiers( oneType );
+        }
+        void GenType::postvisit( GlobalScopeType * globalType ) {
+                handleQualifiers( globalType );
+        }
+        void GenType::postvisit( QualifiedType * qualType ) {
+                std::ostringstream os;
+                os << genDemangleType( qualType->parent, "" ) << "." << genDemangleType( qualType->child, "" ) << typeString;
+                typeString = os.str();
+                handleQualifiers( qualType );
+        }
+        void GenType::handleQualifiers( Type * type ) {
+                if ( type->get_const() ) {
+                        typeString = "const " + typeString;
+                } // if
+                if ( type->get_volatile() ) {
+                        typeString = "volatile " + typeString;
+                } // if
+                if ( type->get_restrict() ) {
+                        typeString = "__restrict " + typeString;
+                } // if
+                if ( type->get_atomic() ) {
+                        typeString = "_Atomic " + typeString;
+                } // if
+        }
+}
+namespace SymTab {
+        namespace Mangler {
+                namespace {
+                        struct StringView {
+                        private:
+                                std::string str;
+                                size_t idx = 0;
+                                // typedef Type * (StringView::*parser)(Type::Qualifiers);
+                                typedef std::function<Type * (Type::Qualifiers)> parser;
+                                std::vector<std::pair<std::string, parser>> parsers;
+                        public:
+                                StringView(const std::string & str);
+                                bool done() const { return idx >= str.size(); }
+                                char cur() const { assert(! done()); return str[idx]; }
+                                bool expect(char ch) { return str[idx++] == ch; }
+                                void next(size_t inc = 1) { idx += inc; }
+                                /// determines if `pref` is a prefix of `str`
+                                bool isPrefix(const std::string & pref);
+                                bool extractNumber(size_t & out);
+                                bool extractName(std::string & out);
+                                bool stripMangleName(std::string & name);
+                                Type * parseFunction(Type::Qualifiers tq);
+                                Type * parseTuple(Type::Qualifiers tq);
+                                Type * parseVoid(Type::Qualifiers tq);
+                                Type * parsePointer(Type::Qualifiers tq);
+                                Type * parseArray(Type::Qualifiers tq);
+                                Type * parseStruct(Type::Qualifiers tq);
+                                Type * parseUnion(Type::Qualifiers tq);
+                                Type * parseEnum(Type::Qualifiers tq);
+                                Type * parseType(Type::Qualifiers tq);
+                                Type * parseType();
+                                bool parse(std::string & name, Type *& type);
+                        };
+                        StringView::StringView(const std::string & str) : str(str) {
+                                // basic types
+                                for (size_t k = 0; k < BasicType::NUMBER_OF_BASIC_TYPES; ++k) {
+                                        parsers.emplace_back(Encoding::basicTypes[k], [k](Type::Qualifiers tq) {
+                                                PRINT( std::cerr << "basic type: " << k << std::endl; )
+                                                return new BasicType(tq, (BasicType::Kind)k);
+                                        });
+                                }
+                                // type variable types
+                                for (size_t k = 0; k < TypeDecl::NUMBER_OF_KINDS; ++k) {
+                                        static const std::string typeVariableNames[] = { "DT", "DST", "OT", "FT", "TT", "ALT", };
+                                        static_assert(
+                                                sizeof(typeVariableNames)/sizeof(typeVariableNames[0]) == TypeDecl::NUMBER_OF_KINDS,
+                                                "Each type variable kind should have a demangle name prefix"
+                                        );
+                                        parsers.emplace_back(Encoding::typeVariables[k], [k, this](Type::Qualifiers tq) -> TypeInstType * {
+                                                PRINT( std::cerr << "type variable type: " << k << std::endl; )
+                                                size_t N;
+                                                if (! extractNumber(N)) return nullptr;
+                                                return new TypeInstType(tq, toString(typeVariableNames[k], N), (TypeDecl::Kind)k != TypeDecl::Ftype);
+                                        });
+                                }
+                                // everything else
+                                parsers.emplace_back(Encoding::void_t, [this](Type::Qualifiers tq) { return parseVoid(tq); });
+                                parsers.emplace_back(Encoding::function, [this](Type::Qualifiers tq) { return parseFunction(tq); });
+                                parsers.emplace_back(Encoding::pointer, [this](Type::Qualifiers tq) { return parsePointer(tq); });
+                                parsers.emplace_back(Encoding::array, [this](Type::Qualifiers tq) { return parseArray(tq); });
+                                parsers.emplace_back(Encoding::tuple, [this](Type::Qualifiers tq) { return parseTuple(tq); });
+                                parsers.emplace_back(Encoding::struct_t, [this](Type::Qualifiers tq) { return parseStruct(tq); });
+                                parsers.emplace_back(Encoding::union_t, [this](Type::Qualifiers tq) { return parseUnion(tq); });
+                                parsers.emplace_back(Encoding::enum_t, [this](Type::Qualifiers tq) { return parseEnum(tq); });
+                                parsers.emplace_back(Encoding::type, [this](Type::Qualifiers tq) { return parseType(tq); });
+                                parsers.emplace_back(Encoding::zero, [](Type::Qualifiers tq) { return new ZeroType(tq); });
+                                parsers.emplace_back(Encoding::one, [](Type::Qualifiers tq) { return new OneType(tq); });
+                        }
+                        bool StringView::extractNumber(size_t & out) {
+                                std::stringstream numss;
+                                if (idx >= str.size()) return false;
+                                while (isdigit(str[idx])) {
+                                        numss << str[idx];
+                                        ++idx;
+                                        if (idx == str.size()) break;
+                                }
+                                if (! (numss >> out)) return false;
+                                PRINT( std::cerr << "extractNumber success: " << out << std::endl; )
+                                return true;
+                        }
+                        bool StringView::extractName(std::string & out) {
+                                size_t len;
+                                if (! extractNumber(len)) return false;
+                                if (idx+len > str.size()) return false;
+                                out = str.substr(idx, len);
+                                idx += len;
+                                PRINT( std::cerr << "extractName success: " << out << std::endl; )
+                                return true;
+                        }
+                        bool StringView::isPrefix(const std::string & pref) {
+                                // if ( pref.size() > str.size()-idx ) return false;
+                                // auto its = std::mismatch( pref.begin(), pref.end(), std::next(str.begin(), idx) );
+                                // if (its.first == pref.end()) {
+                                //      idx += pref.size();
+                                //      return true;
+                                // }
+                                // This update is untested because there are no tests for this code.
+                                if ( ::isPrefix( str, pref, idx ) ) {
+                                        idx += pref.size();
+                                        return true;
+                                }
+                                return false;
+                        }
+                        // strips __NAME__cfa__TYPE_N, where N is [0-9]+: returns str is a match is found, returns empty string otherwise
+                        bool StringView::stripMangleName(std::string & name) {
+                                PRINT( std::cerr << "====== " << str.size() << " " << str << std::endl; )
+                                if (str.size() < 2+Encoding::manglePrefix.size()) return false; // +2 for at least _1 suffix
+                                if ( ! isPrefix(Encoding::manglePrefix) || ! isdigit(str.back() ) ) return false;
+                                // get name
+                                if (! extractName(name)) return false;
+                                // find bounds for type
+                                PRINT( std::cerr << idx << " " << str.size() << std::endl; )
+                                PRINT( std::cerr << "[");
+                                while (isdigit(str.back())) {
+                                        PRINT(std::cerr << ".");
+                                        str.pop_back();
+                                        if (str.size() <= idx) return false;
+                                }
+                                PRINT( std::cerr << "]" << std::endl );
+                                if (str.back() != '_') return false;
+                                str.pop_back();
+                                PRINT( std::cerr << str.size() << " " << name << " " << str.substr(idx) << std::endl; )
+                                return str.size() > idx;
+                        }
+                        Type * StringView::parseFunction(Type::Qualifiers tq) {
+                                PRINT( std::cerr << "function..." << std::endl; )
+                                if (done()) return nullptr;
+                                FunctionType * ftype = new FunctionType( tq, false );
+                                std::unique_ptr<Type> manager(ftype);
+                                Type * retVal = parseType();
+                                if (! retVal) return nullptr;
+                                PRINT( std::cerr << "with return type: " << retVal << std::endl; )
+                                ftype->returnVals.push_back(ObjectDecl::newObject("", retVal, nullptr));
+                                if (done() || ! expect('_')) return nullptr;
+                                while (! done()) {
+                                        PRINT( std::cerr << "got ch: " << cur() << std::endl; )
+                                        if (cur() == '_') return manager.release();
+                                        Type * param = parseType();
+                                        if (! param) return nullptr;
+                                        PRINT( std::cerr << "with parameter : " << param << std::endl; )
+                                        ftype->parameters.push_back(ObjectDecl::newObject("", param, nullptr));
+                                }
+                                return nullptr;
+                        }
+                        Type * StringView::parseTuple(Type::Qualifiers tq) {
+                                PRINT( std::cerr << "tuple..." << std::endl; )
+                                std::list< Type * > types;
+                                size_t ncomponents;
+                                if (! extractNumber(ncomponents)) return nullptr;
+                                for (size_t i = 0; i < ncomponents; ++i) {
+                                        // TODO: delete all on return
+                                        if (done()) return nullptr;
+                                        PRINT( std::cerr << "got ch: " << cur() << std::endl; )
+                                        Type * t = parseType();
+                                        if (! t) return nullptr;
+                                        PRINT( std::cerr << "with type : " << t << std::endl; )
+                                        types.push_back(t);
+                                }
+                                return new TupleType( tq, types );
+                        }
+                        Type * StringView::parseVoid(Type::Qualifiers tq) {
+                                return new VoidType( tq );
+                        }
+                        Type * StringView::parsePointer(Type::Qualifiers tq) {
+                                PRINT( std::cerr << "pointer..." << std::endl; )
+                                Type * t = parseType();
+                                if (! t) return nullptr;
+                                return new PointerType( tq, t );
+                        }
+                        Type * StringView::parseArray(Type::Qualifiers tq) {
+                                PRINT( std::cerr << "array..." << std::endl; )
+                                size_t length;
+                                if (! extractNumber(length)) return nullptr;
+                                Type * t = parseType();
+                                if (! t) return nullptr;
+                                return new ArrayType( tq, t, new ConstantExpr( Constant::from_ulong(length) ), false, false );
+                        }
+                        Type * StringView::parseStruct(Type::Qualifiers tq) {
+                                PRINT( std::cerr << "struct..." << std::endl; )
+                                std::string name;
+                                if (! extractName(name)) return nullptr;
+                                return new StructInstType(tq, name);
+                        }
+                        Type * StringView::parseUnion(Type::Qualifiers tq) {
+                                PRINT( std::cerr << "union..." << std::endl; )
+                                std::string name;
+                                if (! extractName(name)) return nullptr;
+                                return new UnionInstType(tq, name);
+                        }
+                        Type * StringView::parseEnum(Type::Qualifiers tq) {
+                                PRINT( std::cerr << "enum..." << std::endl; )
+                                std::string name;
+                                if (! extractName(name)) return nullptr;
+                                return new EnumInstType(tq, name);
+                        }
+                        Type * StringView::parseType(Type::Qualifiers tq) {
+                                PRINT( std::cerr << "type..." << std::endl; )
+                                std::string name;
+                                if (! extractName(name)) return nullptr;
+                                PRINT( std::cerr << "typename..." << name << std::endl; )
+                                return new TypeInstType(tq, name, false);
+                        }
+                        Type * StringView::parseType() {
+                                if (done()) return nullptr;
+                                std::list<TypeDecl *> forall;
+                                if (isPrefix(Encoding::forall)) {
+                                        PRINT( std::cerr << "polymorphic with..." << std::endl; )
+                                        size_t dcount, fcount, vcount, acount;
+                                        if (! extractNumber(dcount)) return nullptr;
+                                        PRINT( std::cerr << dcount << " dtypes" << std::endl; )
+                                        if (! expect('_')) return nullptr;
+                                        if (! extractNumber(fcount)) return nullptr;
+                                        PRINT( std::cerr << fcount << " ftypes" << std::endl; )
+                                        if (! expect('_')) return nullptr;
+                                        if (! extractNumber(vcount)) return nullptr;
+                                        PRINT( std::cerr << vcount << " ttypes" << std::endl; )
+                                        if (! expect('_')) return nullptr;
+                                        if (! extractNumber(acount)) return nullptr;
+                                        PRINT( std::cerr << acount << " assertions" << std::endl; )
+                                        if (! expect('_')) return nullptr;
+                                        for (size_t i = 0; i < acount; ++i) {
+                                                // TODO: need to recursively parse assertions, but for now just return nullptr so that
+                                                // demangler does not crash if there are assertions
+                                                return nullptr;
+                                        }
+                                        if (! expect('_')) return nullptr;
+                                }
+                                // qualifiers
+                                Type::Qualifiers tq;
+                                while (true) {
+                                        auto qual = std::find_if(Encoding::qualifiers.begin(), Encoding::qualifiers.end(), [this](decltype(Encoding::qualifiers)::value_type val) {
+                                                return isPrefix(val.second);
+                                        });
+                                        if (qual == Encoding::qualifiers.end()) break;
+                                        tq |= qual->first;
+                                }
+                                // find the correct type parser and use it
+                                auto iter = std::find_if(parsers.begin(), parsers.end(), [this](std::pair<std::string, parser> & p) {
+                                        return isPrefix(p.first);
+                                });
+                                assertf(iter != parsers.end(), "Unhandled type letter: %c at index: %zd", cur(), idx);
+                                Type * ret = iter->second(tq);
+                                if (! ret) return nullptr;
+                                ret->forall = std::move(forall);
+                                return ret;
+                        }
+                        bool StringView::parse(std::string & name, Type *& type) {
+                                if (! stripMangleName(name)) return false;
+                                PRINT( std::cerr << "stripped name: " << name << std::endl; )
+                                Type * t = parseType();
+                                if (! t) return false;
+                                type = t;
+                                return true;
+                        }
+                        std::string demangle(const std::string & mangleName) {
+                                SymTab::Mangler::StringView view(mangleName);
+                                std::string name;
+                                Type * type = nullptr;
+                                if (! view.parse(name, type)) return mangleName;
+                                std::unique_ptr<Type> manager(type);
+                                return genDemangleType(type, name);
+                        }
+                } // namespace
+        } // namespace Mangler
+} // namespace SymTab
+                if ( !expect('_') ) return nullptr;
+        }
+        ast::CV::Qualifiers tq;
+        while (true) {
+                auto qual = std::find_if(Encoding::qualifiers.begin(), Encoding::qualifiers.end(), [this](decltype(Encoding::qualifiers)::value_type val) {
+                        return isPrefix(val.second);
+                });
+                if (qual == Encoding::qualifiers.end()) break;
+                tq |= qual->first;
+        }
+        // Find the correct type parser and then apply it.
+        auto iter = std::find_if(parsers.begin(), parsers.end(), [this](std::pair<std::string, Parser> & p) {
+                return isPrefix(p.first);
+        });
+        assertf(iter != parsers.end(), "Unhandled type letter: %c at index: %zd", cur(), index);
+        ast::Type * ret = iter->second(tq);
+        if ( !ret ) return nullptr;
+        return ret;
+}
+bool Demangler::parse( std::string & name, ast::Type *& type) {
+        if ( !stripMangleName(name) ) return false;
+        PRINT( std::cerr << "stripped name: " << name << std::endl; )
+        ast::Type * t = parseType();
+        if ( !t ) return false;
+        type = t;
+        return true;
+}
+std::string demangle( const std::string & mangleName ) {
+        using namespace CodeGen;
+        Demangler demangler( mangleName );
+        std::string name;
+        ast::Type * type = nullptr;
+        if ( !demangler.parse( name, type ) ) return mangleName;
+        ast::readonly<ast::Type> roType = type;
+        if ( auto info = operatorLookupByOutput( name ) ) name = info->inputName;
+        return genType( type, name, Options( false, false, false, false ) );
+}
+} // namespace
+} // namespace Mangle
 extern "C" {
         char * cforall_demangle(const char * mangleName, int option __attribute__((unused))) {
                 const std::string & demangleName = SymTab::Mangler::demangle(mangleName);
+                const std::string & demangleName = Mangle::demangle(mangleName);
                 return strdup(demangleName.c_str());
+        }

src/SymTab/Demangle.h

-              r0030b508
+              rfc12f05
 // Created On       : Fri May 13 10:11:00 2022
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri May 13 10:30:00 2022
 // Update Count     : 0
+// Last Modified On : Mon Nov  6 15:48:00 2023
+// Update Count     : 1
 //
 …
 extern "C" {
+        /// Main interface to the demangler as a utility.
+        /// Caller must free the returned string.
         char * cforall_demangle(const char *, int);
+}

src/SymTab/FixFunction.cc

-              r0030b508
+              rfc12f05
 #include "AST/Type.hpp"
 #include "Common/utility.h"       // for copy
-#include "SynTree/Declaration.h"  // for FunctionDecl, ObjectDecl, Declarati...
-#include "SynTree/Expression.h"   // for Expression
-#include "SynTree/Type.h"         // for ArrayType, PointerType, Type, Basic...
 namespace SymTab {
-        class FixFunction_old : public WithShortCircuiting {
-                typedef Mutator Parent;
-          public:
-                FixFunction_old() : isVoid( false ) {}
-                void premutate(FunctionDecl *functionDecl);
-                DeclarationWithType* postmutate(FunctionDecl *functionDecl);
-                Type * postmutate(ArrayType * arrayType);
-                void premutate(ArrayType * arrayType);
-                void premutate(VoidType * voidType);
-                void premutate(BasicType * basicType);
-                void premutate(PointerType * pointerType);
-                void premutate(StructInstType * aggregateUseType);
-                void premutate(UnionInstType * aggregateUseType);
-                void premutate(EnumInstType * aggregateUseType);
-                void premutate(TraitInstType * aggregateUseType);
-                void premutate(TypeInstType * aggregateUseType);
-                void premutate(TupleType * tupleType);
-                void premutate(VarArgsType * varArgsType);
-                void premutate(ZeroType * zeroType);
-                void premutate(OneType * oneType);
-                bool isVoid;
-        };
-        DeclarationWithType * FixFunction_old::postmutate(FunctionDecl *functionDecl) {
-                // can't delete function type because it may contain assertions, so transfer ownership to new object
-                ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
-                pointer->location = functionDecl->location;
-                functionDecl->attributes.clear();
-                functionDecl->type = nullptr;
-                delete functionDecl;
-                return pointer;
+        }
-        // xxx - this passes on void[], e.g.
-        //   void foo(void [10]);
-        // does not cause an error
-        Type * FixFunction_old::postmutate(ArrayType *arrayType) {
-                // need to recursively mutate the base type in order for multi-dimensional arrays to work.
-                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
-                pointerType->location = arrayType->location;
-                arrayType->base = nullptr;
-                arrayType->dimension = nullptr;
-                delete arrayType;
-                return pointerType;
+        }
-        void FixFunction_old::premutate(VoidType *) {
-                isVoid = true;
+        }
-        void FixFunction_old::premutate(FunctionDecl *) { visit_children = false; }
-        void FixFunction_old::premutate(ArrayType *) { visit_children = false; }
-        void FixFunction_old::premutate(BasicType *) { visit_children = false; }
-        void FixFunction_old::premutate(PointerType *) { visit_children = false; }
-        void FixFunction_old::premutate(StructInstType *) { visit_children = false; }
-        void FixFunction_old::premutate(UnionInstType *) { visit_children = false; }
-        void FixFunction_old::premutate(EnumInstType *) { visit_children = false; }
-        void FixFunction_old::premutate(TraitInstType *) { visit_children = false; }
-        void FixFunction_old::premutate(TypeInstType *) { visit_children = false; }
-        void FixFunction_old::premutate(TupleType *) { visit_children = false; }
-        void FixFunction_old::premutate(VarArgsType *) { visit_children = false; }
-        void FixFunction_old::premutate(ZeroType *) { visit_children = false; }
-        void FixFunction_old::premutate(OneType *) { visit_children = false; }
-        bool fixFunction( DeclarationWithType *& dwt ) {
-                PassVisitor<FixFunction_old> fixer;
-                dwt = dwt->acceptMutator( fixer );
-                return fixer.pass.isVoid;
+        }
 namespace {

src/SymTab/FixFunction.h

-              r0030b508
+              rfc12f05
 #pragma once
-#include "Common/PassVisitor.h" // for PassVisitor
-#include "SynTree/SynTree.h"    // for Types
 namespace ast {
         class DeclWithType;
 …
 namespace SymTab {
-        /// Replaces function and array types by equivalent pointer types. Returns true if type is
-        /// void
-        bool fixFunction( DeclarationWithType *& );
         /// Returns declaration with function and array types replaced by equivalent pointer types.
         /// Sets isVoid to true if type is void

src/SymTab/Mangler.cc

-              r0030b508
+              rfc12f05
 #include <string>                        // for string, char_traits, operator<<
+#include "AST/Pass.hpp"
 #include "CodeGen/OperatorTable.h"       // for OperatorInfo, operatorLookup
-#include "Common/PassVisitor.h"
 #include "Common/ToString.hpp"           // for toCString
 #include "Common/SemanticError.h"        // for SemanticError
-#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
-#include "SynTree/LinkageSpec.h"         // for Spec, isOverridable, AutoGen, Int...
-#include "SynTree/Declaration.h"         // for TypeDecl, DeclarationWithType
-#include "SynTree/Expression.h"          // for TypeExpr, Expression, operator<<
-#include "SynTree/Type.h"                // for Type, ReferenceToType, Type::Fora...
-#include "AST/Pass.hpp"
-namespace SymTab {
-        namespace Mangler {
-                namespace {
-                        /// Mangles names to a unique C identifier
-                        struct Mangler_old : public WithShortCircuiting, public WithVisitorRef<Mangler_old>, public WithGuards {
-                                Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
-                                Mangler_old( const Mangler_old & ) = delete;
-                                void previsit( const BaseSyntaxNode * ) { visit_children = false; }
-                                void postvisit( const ObjectDecl * declaration );
-                                void postvisit( const FunctionDecl * declaration );
-                                void postvisit( const TypeDecl * declaration );
-                                void postvisit( const VoidType * voidType );
-                                void postvisit( const BasicType * basicType );
-                                void postvisit( const PointerType * pointerType );
-                                void postvisit( const ArrayType * arrayType );
-                                void postvisit( const ReferenceType * refType );
-                                void postvisit( const FunctionType * functionType );
-                                void postvisit( const StructInstType * aggregateUseType );
-                                void postvisit( const UnionInstType * aggregateUseType );
-                                void postvisit( const EnumInstType * aggregateUseType );
-                                void postvisit( const TypeInstType * aggregateUseType );
-                                void postvisit( const TraitInstType * inst );
-                                void postvisit( const TupleType * tupleType );
-                                void postvisit( const VarArgsType * varArgsType );
-                                void postvisit( const ZeroType * zeroType );
-                                void postvisit( const OneType * oneType );
-                                void postvisit( const QualifiedType * qualType );
-                                std::string get_mangleName() { return mangleName; }
-                          private:
-                                std::string mangleName;         ///< Mangled name being constructed
-                                typedef std::map< std::string, std::pair< int, int > > VarMapType;
-                                VarMapType varNums;             ///< Map of type variables to indices
-                                int nextVarNum;                 ///< Next type variable index
-                                bool isTopLevel;                ///< Is the Mangler at the top level
-                                bool mangleOverridable;         ///< Specially mangle overridable built-in methods
-                                bool typeMode;                  ///< Produce a unique mangled name for a type
-                                bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
-                                bool inFunctionType = false;    ///< Include type qualifiers if false.
-                                bool inQualifiedType = false;   ///< Add start/end delimiters around qualified type
-                          public:
-                                Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
-                                        int nextVarNum, const VarMapType& varNums );
-                          private:
-                                void mangleDecl( const DeclarationWithType * declaration );
-                                void mangleRef( const ReferenceToType * refType, std::string prefix );
-                                void printQualifiers( const Type *type );
-                        }; // Mangler_old
-                } // namespace
-                std::string mangle( const BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
-                        PassVisitor<Mangler_old> mangler( mangleOverridable, typeMode, mangleGenericParams );
-                        maybeAccept( decl, mangler );
-                        return mangler.pass.get_mangleName();
+                }
-                std::string mangleType( const Type * ty ) {
-                        PassVisitor<Mangler_old> mangler( false, true, true );
-                        maybeAccept( ty, mangler );
-                        return mangler.pass.get_mangleName();
+                }
-                std::string mangleConcrete( const Type * ty ) {
-                        PassVisitor<Mangler_old> mangler( false, false, false );
-                        maybeAccept( ty, mangler );
-                        return mangler.pass.get_mangleName();
+                }
-                namespace {
-                        Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
-                                : nextVarNum( 0 ), isTopLevel( true ),
-                                mangleOverridable( mangleOverridable ), typeMode( typeMode ),
-                                mangleGenericParams( mangleGenericParams ) {}
-                        Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
-                                int nextVarNum, const VarMapType& varNums )
-                                : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
-                                mangleOverridable( mangleOverridable ), typeMode( typeMode ),
-                                mangleGenericParams( mangleGenericParams ) {}
-                        void Mangler_old::mangleDecl( const DeclarationWithType * declaration ) {
-                                bool wasTopLevel = isTopLevel;
-                                if ( isTopLevel ) {
-                                        varNums.clear();
-                                        nextVarNum = 0;
-                                        isTopLevel = false;
-                                } // if
-                                mangleName += Encoding::manglePrefix;
-                                const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( declaration->get_name() );
-                                if ( opInfo ) {
-                                        mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName;
-                                } else {
-                                        mangleName += std::to_string( declaration->name.size() ) + declaration->name;
-                                } // if
-                                maybeAccept( declaration->get_type(), *visitor );
-                                if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
-                                        // want to be able to override autogenerated and intrinsic routines,
-                                        // so they need a different name mangling
-                                        if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
-                                                mangleName += Encoding::autogen;
-                                        } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
-                                                mangleName += Encoding::intrinsic;
-                                        } else {
-                                                // if we add another kind of overridable function, this has to change
-                                                assert( false && "unknown overrideable linkage" );
-                                        } // if
+                                }
-                                isTopLevel = wasTopLevel;
+                        }
-                        void Mangler_old::postvisit( const ObjectDecl * declaration ) {
-                                mangleDecl( declaration );
+                        }
-                        void Mangler_old::postvisit( const FunctionDecl * declaration ) {
-                                mangleDecl( declaration );
+                        }
-                        void Mangler_old::postvisit( const VoidType * voidType ) {
-                                printQualifiers( voidType );
-                                mangleName += Encoding::void_t;
+                        }
-                        void Mangler_old::postvisit( const BasicType * basicType ) {
-                                printQualifiers( basicType );
-                                assertf( basicType->kind < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
-                                mangleName += Encoding::basicTypes[ basicType->kind ];
+                        }
-                        void Mangler_old::postvisit( const PointerType * pointerType ) {
-                                printQualifiers( pointerType );
-                                // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
-                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName += Encoding::pointer;
-                                maybeAccept( pointerType->base, *visitor );
+                        }
-                        void Mangler_old::postvisit( const ArrayType * arrayType ) {
-                                // TODO: encode dimension
-                                printQualifiers( arrayType );
-                                mangleName += Encoding::array + "0";
-                                maybeAccept( arrayType->base, *visitor );
+                        }
-                        void Mangler_old::postvisit( const ReferenceType * refType ) {
-                                // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
-                                // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
-                                // by pretending every reference type is a function parameter.
-                                GuardValue( inFunctionType );
-                                inFunctionType = true;
-                                printQualifiers( refType );
-                                maybeAccept( refType->base, *visitor );
+                        }
-                        namespace {
-                                inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
-                                        std::list< Type* > ret;
-                                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
-                                                                        std::mem_fun( &DeclarationWithType::get_type ) );
-                                        return ret;
+                                }
+                        }
-                        void Mangler_old::postvisit( const FunctionType * functionType ) {
-                                printQualifiers( functionType );
-                                mangleName += Encoding::function;
-                                // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
-                                // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
-                                // void (*)(const int) and void (*)(int) are the same type, but void (*)(const int *) and void (*)(int *) are different
-                                GuardValue( inFunctionType );
-                                inFunctionType = true;
-                                std::list< Type* > returnTypes = getTypes( functionType->returnVals );
-                                if (returnTypes.empty()) mangleName += Encoding::void_t;
-                                else acceptAll( returnTypes, *visitor );
-                                mangleName += "_";
-                                std::list< Type* > paramTypes = getTypes( functionType->parameters );
-                                acceptAll( paramTypes, *visitor );
-                                mangleName += "_";
+                        }
-                        void Mangler_old::mangleRef( const ReferenceToType * refType, std::string prefix ) {
-                                printQualifiers( refType );
-                                mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
-                                if ( mangleGenericParams ) {
-                                        const std::list< Expression* > & params = refType->parameters;
-                                        if ( ! params.empty() ) {
-                                                mangleName += "_";
-                                                for ( const Expression * param : params ) {
-                                                        const TypeExpr * paramType = dynamic_cast< const TypeExpr * >( param );
-                                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
-                                                        maybeAccept( paramType->type, *visitor );
+                                                }
-                                                mangleName += "_";
+                                        }
+                                }
+                        }
-                        void Mangler_old::postvisit( const StructInstType * aggregateUseType ) {
-                                mangleRef( aggregateUseType, Encoding::struct_t );
+                        }
-                        void Mangler_old::postvisit( const UnionInstType * aggregateUseType ) {
-                                mangleRef( aggregateUseType, Encoding::union_t );
+                        }
-                        void Mangler_old::postvisit( const EnumInstType * aggregateUseType ) {
-                                mangleRef( aggregateUseType, Encoding::enum_t );
+                        }
-                        void Mangler_old::postvisit( const TypeInstType * typeInst ) {
-                                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
-                                if ( varNum == varNums.end() ) {
-                                        mangleRef( typeInst, Encoding::type );
-                                } else {
-                                        printQualifiers( typeInst );
-                                        // Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
-                                        //   forall(dtype T) void f(T);
-                                        //   forall(dtype S) void f(S);
-                                        // are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
-                                        // are first found and prefixing with the appropriate encoding for the type class.
-                                        assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
-                                        mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
-                                } // if
+                        }
-                        void Mangler_old::postvisit( const TraitInstType * inst ) {
-                                printQualifiers( inst );
-                                mangleName += std::to_string( inst->name.size() ) + inst->name;
+                        }
-                        void Mangler_old::postvisit( const TupleType * tupleType ) {
-                                printQualifiers( tupleType );
-                                mangleName += Encoding::tuple + std::to_string( tupleType->types.size() );
-                                acceptAll( tupleType->types, *visitor );
+                        }
-                        void Mangler_old::postvisit( const VarArgsType * varArgsType ) {
-                                printQualifiers( varArgsType );
-                                static const std::string vargs = "__builtin_va_list";
-                                mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs;
+                        }
-                        void Mangler_old::postvisit( const ZeroType * ) {
-                                mangleName += Encoding::zero;
+                        }
-                        void Mangler_old::postvisit( const OneType * ) {
-                                mangleName += Encoding::one;
+                        }
-                        void Mangler_old::postvisit( const QualifiedType * qualType ) {
-                                bool inqual = inQualifiedType;
-                                if (! inqual ) {
-                                        // N marks the start of a qualified type
-                                        inQualifiedType = true;
-                                        mangleName += Encoding::qualifiedTypeStart;
+                                }
-                                maybeAccept( qualType->parent, *visitor );
-                                maybeAccept( qualType->child, *visitor );
-                                if ( ! inqual ) {
-                                        // E marks the end of a qualified type
-                                        inQualifiedType = false;
-                                        mangleName += Encoding::qualifiedTypeEnd;
+                                }
+                        }
-                        void Mangler_old::postvisit( const TypeDecl * decl ) {
-                                // TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
-                                // fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
-                                // Note: The current scheme may already work correctly for this case, I have not thought about this deeply
-                                // and the case has not yet come up in practice. Alternatively, if not then this code can be removed
-                                // aside from the assert false.
-                                assertf( false, "Mangler_old should not visit typedecl: %s", toCString(decl));
-                                assertf( decl->kind < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
-                                mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
+                        }
-                        __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
-                                for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
-                                        os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
-                                } // for
+                        }
-                        void Mangler_old::printQualifiers( const Type * type ) {
-                                // skip if not including qualifiers
-                                if ( typeMode ) return;
-                                if ( ! type->forall.empty() ) {
-                                        std::list< std::string > assertionNames;
-                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
-                                        mangleName += Encoding::forall;
-                                        for ( const TypeDecl * i : type->forall ) {
-                                                switch ( i->kind ) {
-                                                  case TypeDecl::Dtype:
-                                                        dcount++;
-                                                        break;
-                                                  case TypeDecl::Ftype:
-                                                        fcount++;
-                                                        break;
-                                                  case TypeDecl::Ttype:
-                                                        vcount++;
-                                                        break;
-                                                  default:
-                                                        assertf( false, "unimplemented kind for type variable %s", SymTab::Mangler::Encoding::typeVariables[i->kind].c_str() );
-                                                } // switch
-                                                varNums[ i->name ] = std::make_pair( nextVarNum, (int)i->kind );
-                                                for ( const DeclarationWithType * assert : i->assertions ) {
-                                                        PassVisitor<Mangler_old> sub_mangler(
-                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
-                                                        assert->accept( sub_mangler );
-                                                        assertionNames.push_back( sub_mangler.pass.get_mangleName() );
-                                                        acount++;
-                                                } // for
-                                        } // for
-                                        mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
-                                        for(const auto & a : assertionNames) mangleName += a;
-//                                      std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
-                                        mangleName += "_";
-                                } // if
-                                if ( ! inFunctionType ) {
-                                        // these qualifiers do not distinguish the outermost type of a function parameter
-                                        if ( type->get_const() ) {
-                                                mangleName += Encoding::qualifiers.at(Type::Const);
-                                        } // if
-                                        if ( type->get_volatile() ) {
-                                                mangleName += Encoding::qualifiers.at(Type::Volatile);
-                                        } // if
-                                        // Removed due to restrict not affecting function compatibility in GCC
-                                        // if ( type->get_isRestrict() ) {
-                                        //      mangleName += "E";
-                                        // } // if
-                                        if ( type->get_atomic() ) {
-                                                mangleName += Encoding::qualifiers.at(Type::Atomic);
-                                        } // if
+                                }
-                                if ( type->get_mutex() ) {
-                                        mangleName += Encoding::qualifiers.at(Type::Mutex);
-                                } // if
-                                if ( inFunctionType ) {
-                                        // turn off inFunctionType so that types can be differentiated for nested qualifiers
-                                        GuardValue( inFunctionType );
-                                        inFunctionType = false;
+                                }
+                        }
-                } // namespace
-        } // namespace Mangler
-} // namespace SymTab
 namespace Mangle {
 …
                                 mangleName += std::to_string( decl->name.size() ) + decl->name;
                         } // if
                         maybeAccept( decl->get_type(), *visitor );
+                        decl->get_type()->accept( *visitor );
                         if ( mangleOverridable && decl->linkage.is_overrideable ) {
                                 // want to be able to override autogenerated and intrinsic routines,
 …
                         printQualifiers( arrayType );
                         mangleName += Encoding::array + "0";
                         maybeAccept( arrayType->base.get(), *visitor );
+                        arrayType->base->accept( *visitor );
+                }
 …
                         inFunctionType = true;
                         printQualifiers( refType );
                         maybeAccept( refType->base.get(), *visitor );
+                        refType->base->accept( *visitor );
+                }
 …
                                         auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
                                         assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
                                         maybeAccept( paramType->type.get(), *visitor );
+                                        paramType->type->accept( *visitor );
+                                }
                                 mangleName += "_";
 …
                                 // are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
                                 // are first found and prefixing with the appropriate encoding for the type class.
                                 assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
+                                assertf( varNum->second.second < ast::TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
                                 mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
                         } // if
 …
                 void Mangler_new::postvisit( const ast::QualifiedType * qualType ) {
                         bool inqual = inQualifiedType;
                         if (! inqual ) {
+                        if ( !inqual ) {
                                 // N marks the start of a qualified type
                                 inQualifiedType = true;
                                 mangleName += Encoding::qualifiedTypeStart;
+                        }
                         maybeAccept( qualType->parent.get(), *visitor );
                         maybeAccept( qualType->child.get(), *visitor );
                         if ( ! inqual ) {
+                        qualType->parent->accept( *visitor );
+                        qualType->child->accept( *visitor );
+                        if ( !inqual ) {
                                 // E marks the end of a qualified type
                                 inQualifiedType = false;
 …
                                 // these qualifiers do not distinguish the outermost type of a function parameter
                                 if ( type->is_const() ) {
                                         mangleName += Encoding::qualifiers.at(Type::Const);
+                                        mangleName += Encoding::qualifiers.at( ast::CV::Const );
                                 } // if
                                 if ( type->is_volatile() ) {
                                         mangleName += Encoding::qualifiers.at(Type::Volatile);
+                                        mangleName += Encoding::qualifiers.at( ast::CV::Volatile );
                                 } // if
                                 // Removed due to restrict not affecting function compatibility in GCC
 …
                                 // } // if
                                 if ( type->is_atomic() ) {
                                         mangleName += Encoding::qualifiers.at(Type::Atomic);
+                                        mangleName += Encoding::qualifiers.at( ast::CV::Atomic );
                                 } // if
+                        }
                         if ( type->is_mutex() ) {
                                 mangleName += Encoding::qualifiers.at(Type::Mutex);
+                                mangleName += Encoding::qualifiers.at( ast::CV::Mutex );
                         } // if
                         if ( inFunctionType ) {

src/SymTab/Mangler.h

-              r0030b508
+              rfc12f05
 #include "AST/Bitfield.hpp"
-#include "SynTree/SynTree.h"  // for Types
-#include "SynTree/Visitor.h"  // for Visitor, maybeAccept
 // https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
 …
         class Node;
+}
-namespace ResolvExpr {
-        class TypeEnvironment;
+}
 namespace SymTab {
         namespace Mangler {
-                /// Mangle syntax tree object; primary interface to clients
-                std::string mangle( const BaseSyntaxNode * decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
-                /// Mangle a type name; secondary interface
-                std::string mangleType( const Type * ty );
-                /// Mangle ignoring generic type parameters
-                std::string mangleConcrete( const Type * ty );
                 namespace Encoding {
                         extern const std::string manglePrefix;

src/SymTab/ManglerCommon.cc

-              r0030b508
+              rfc12f05
 #include "Mangler.h"
+#include "SynTree/Type.h"
+#include "SynTree/Declaration.h"
+#include "AST/Decl.hpp"
+#include "AST/Type.hpp"
 namespace SymTab {
 …
                         //   - "Di" char32_t
                         //   - "Ds" char16_t
                         const std::string basicTypes[BasicType::NUMBER_OF_BASIC_TYPES] = {
+                        const std::string basicTypes[ast::BasicType::NUMBER_OF_BASIC_TYPES] = {
                                 "b",        // _Bool
                                 "c",        // char
 …
                         // GENERATED END
                         static_assert(
                                 sizeof(basicTypes)/sizeof(basicTypes[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
+                                sizeof(basicTypes)/sizeof(basicTypes[0]) == ast::BasicType::NUMBER_OF_BASIC_TYPES,
                                 "Each basic type kind should have a corresponding mangler letter"
                         );
                         const std::map<int, std::string> qualifiers = {
                                 { Type::Const, "K" },
                                 { Type::Volatile, "V" },
                                 { Type::Atomic, "DA" }, // A is array, so need something unique for atmoic. For now, go with multiletter DA
                                 { Type::Mutex, "X" },
+                                { ast::CV::Const, "K" },
+                                { ast::CV::Volatile, "V" },
+                                { ast::CV::Atomic, "DA" }, // A is array, so need something unique for atmoic. For now, go with multiletter DA
+                                { ast::CV::Mutex, "X" },
                         };
 …
                         };
                         static_assert(
                                 sizeof(typeVariables) / sizeof(typeVariables[0]) == TypeDecl::NUMBER_OF_KINDS,
+                                sizeof(typeVariables) / sizeof(typeVariables[0]) == ast::TypeDecl::NUMBER_OF_KINDS,
                                 "Each type variable kind should have a corresponding mangler prefix"
                         );

src/SymTab/demangler.cc

-              r0030b508
+              rfc12f05
 #include <iostream>
 #include <fstream>
-using namespace std;
 void f(const std::string & mangleName) {
+void demangleAndPrint(const std::string & mangleName) {
         char * demangleName = cforall_demangle(mangleName.c_str(), 0);
         cout << mangleName << " => " << std::flush << demangleName << endl;
+        std::cout << mangleName << " => " << demangleName << std::endl;
         free(demangleName);
+}
+int main() {
+        ifstream in("in-demangle.txt");
+int main(int argc, char * argv[]) {
+        char const * fileName = (1 < argc) ? argv[1] : "in-demangle.txt";
+        std::ifstream in(fileName);
         std::string line;
+        while (getline(in, line)) {
+                if (line.empty()) { cout << "=================================" << endl; continue; }
+                else if (line[0] == '#') continue;
+                f(line);
+        while (std::getline(in, line)) {
+                if (line.empty()) {
+                        std::cout << "=================================" << std::endl;
+                } else if (line[0] == '#') {
+                        continue;
+                } else {
+                        demangleAndPrint(line);
+                }
+        }
+}

src/SymTab/module.mk

-              r0030b508
+              rfc12f05
 SRC_SYMTAB = \
-        SymTab/Autogen.cc \
-        SymTab/Autogen.h \
         SymTab/FixFunction.cc \
         SymTab/FixFunction.h \
         SymTab/GenImplicitCall.cpp \
         SymTab/GenImplicitCall.hpp \
-        SymTab/Indexer.cc \
-        SymTab/Indexer.h \
         SymTab/Mangler.cc \
         SymTab/ManglerCommon.cc \
+        SymTab/Mangler.h \
+        SymTab/ValidateType.cc \
+        SymTab/ValidateType.h
+        SymTab/Mangler.h
+SRC += $(SRC_SYMTAB) \
+        SymTab/Validate.cc \
+        SymTab/Validate.h
+SRC += $(SRC_SYMTAB)
 SRCDEMANGLE += $(SRC_SYMTAB) \

src/Tuples/Explode.cc

-              r0030b508
+              rfc12f05
 #include "Explode.h"
-#include <list>                  // for list
 #include "AST/Pass.hpp"          // for Pass
-#include "SynTree/Mutator.h"     // for Mutator
-#include "Common/PassVisitor.h"  // for PassVisitor
 namespace Tuples {
-        namespace {
-                // remove one level of reference from a reference type -- may be useful elsewhere.
-                Type * getReferenceBase( Type * t ) {
-                        if ( ReferenceType * refType = dynamic_cast<ReferenceType *>( t ) ) {
-                                return refType->get_base();
-                        } else {
-                                // for the moment, I want to know immediately if a non-reference type is ever passed in here.
-                                assertf( false, "getReferenceBase for non-ref: %s", toString( refType ).c_str() );
-                                return nullptr;
+                        }
+                }
-                struct CastExploder {
-                        bool castAdded = false;
-                        bool foundUniqueExpr = false;
-                        Expression * applyCast( Expression * expr, bool first = true ) {
-                                if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ){
-                                        foundUniqueExpr = true;
-                                        std::list< Expression * > exprs;
-                                        for ( Expression *& expr : tupleExpr->get_exprs() ) {
-                                                // move cast into tuple exprs
-                                                exprs.push_back( applyCast( expr, false ) );
+                                        }
-                                        // want the top-level expression to be cast to reference type, but not nested
-                                        // tuple expressions
-                                        if ( first ) {
-                                                castAdded = true;
-                                                Expression * tupleExpr = new TupleExpr( exprs );
-                                                return new CastExpr( tupleExpr, new ReferenceType( Type::Qualifiers(), tupleExpr->result->clone() ) );
-                                        } else {
-                                                return new TupleExpr( exprs );
+                                        }
+                                }
-                                if ( dynamic_cast<ReferenceType*>( expr->result ) ) {
-                                        // don't need to cast reference type to another reference type
-                                        return expr->clone();
-                                } else {
-                                        // anything else should be cast to reference as normal
-                                        castAdded = true;
-                                        return new CastExpr( expr->clone(), new ReferenceType( Type::Qualifiers(), expr->result->clone() ) );
+                                }
+                        }
-                        Expression * postmutate( UniqueExpr * uniqueExpr ) {
-                                // move cast into unique expr so that the unique expr has type T& rather than
-                                // type T. In particular, this transformation helps with generating the
-                                // correct code for reference-cast member tuple expressions, since the result
-                                // should now be a tuple of references rather than a reference to a tuple.
-                                // Still, this code is a bit awkward, and could use some improvement.
-                                UniqueExpr * newUniqueExpr = new UniqueExpr( applyCast( uniqueExpr->get_expr() ), uniqueExpr->get_id() );
-                                delete uniqueExpr;
-                                if ( castAdded ) {
-                                        // if a cast was added by applyCast, then unique expr now has one more layer of reference
-                                        // than it had coming into this function. To ensure types still match correctly, need to cast
-                                        //  to reference base so that outer expressions are still correct.
-                                        castAdded = false;
-                                        Type * toType = getReferenceBase( newUniqueExpr->result );
-                                        return new CastExpr( newUniqueExpr, toType->clone() );
+                                }
-                                return newUniqueExpr;
+                        }
-                        Expression * postmutate( TupleIndexExpr * tupleExpr ) {
-                                // tuple index expr needs to be rebuilt to ensure that the type of the
-                                // field is consistent with the type of the tuple expr, since the field
-                                // may have changed from type T to T&.
-                                Expression * expr = tupleExpr->get_tuple();
-                                tupleExpr->set_tuple( nullptr );
-                                TupleIndexExpr * ret = new TupleIndexExpr( expr, tupleExpr->get_index() );
-                                delete tupleExpr;
-                                return ret;
+                        }
-                };
-        } // namespace
-        Expression * distributeReference( Expression * expr ) {
-                PassVisitor<CastExploder> exploder;
-                expr = expr->acceptMutator( exploder );
-                if ( ! exploder.pass.foundUniqueExpr ) {
-                        // if a UniqueExpr was found, then the cast has already been added inside the UniqueExpr as appropriate
-                        expr = new CastExpr( expr, new ReferenceType( Type::Qualifiers(), expr->result->clone() ) );
+                }
-                return expr;
+        }
 namespace {

src/Tuples/Explode.h

-              r0030b508
+              rfc12f05
 #include "AST/Expr.hpp"
-#include "ResolvExpr/Alternative.h"     // for Alternative, AltList
 #include "ResolvExpr/Candidate.hpp"     // for Candidate, CandidateList
-#include "ResolvExpr/ExplodedActual.h"  // for ExplodedActual
 #include "ResolvExpr/ExplodedArg.hpp"   // for ExplodedArg
-#include "SynTree/Expression.h"         // for Expression, UniqueExpr, AddressExpr
-#include "SynTree/Type.h"               // for TupleType, Type
 #include "Tuples.h"                     // for maybeImpure
 …
+}
-namespace SymTab {
-class Indexer;
-}  // namespace SymTab
 namespace Tuples {
-        Expression * distributeReference( Expression * );
-        static inline CastExpr * isReferenceCast( Expression * expr ) {
-                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                        if ( dynamic_cast< ReferenceType * >( castExpr->result ) ) {
-                                return castExpr;
+                        }
+                }
-                return nullptr;
+        }
-        /// Append alternative to an OutputIterator of Alternatives
-        template<typename OutputIterator>
-        void append( OutputIterator out, Expression* expr, const ResolvExpr::TypeEnvironment& env,
-                        const ResolvExpr::OpenVarSet& openVars, const ResolvExpr::AssertionList& need,
-                        const ResolvExpr::Cost& cost, const ResolvExpr::Cost& cvtCost ) {
-                *out++ = ResolvExpr::Alternative{ expr, env, openVars, need, cost, cvtCost };
+        }
-        /// Append alternative to an ExplodedActual
-        static inline void append( ResolvExpr::ExplodedActual& ea, Expression* expr,
-                        const ResolvExpr::TypeEnvironment&, const ResolvExpr::OpenVarSet&,
-                        const ResolvExpr::AssertionList&, const ResolvExpr::Cost&, const ResolvExpr::Cost& ) {
-                ea.exprs.emplace_back( expr );
-                /// xxx -- merge environment, openVars, need, cost?
+        }
-        /// helper function used by explode
-        template< typename Output >
-        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt,
-                        const SymTab::Indexer & indexer, Output&& out, bool isTupleAssign ) {
-                if ( isTupleAssign ) {
-                        // tuple assignment needs CastExprs to be recursively exploded to easily get at all of the components
-                        if ( CastExpr * castExpr = isReferenceCast( expr ) ) {
-                                ResolvExpr::AltList alts;
-                                explodeUnique(
-                                        castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
-                                for ( ResolvExpr::Alternative & alt : alts ) {
-                                        // distribute reference cast over all components
-                                        append( std::forward<Output>(out), distributeReference( alt.release_expr() ),
-                                                alt.env, alt.openVars, alt.need, alt.cost, alt.cvtCost );
+                                }
-                                // in tuple assignment, still need to handle the other cases, but only if not already handled here (don't want to output too many alternatives)
-                                return;
+                        }
+                }
-                Type * res = expr->get_result()->stripReferences();
-                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
-                        if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ) {
-                                // can open tuple expr and dump its exploded components
-                                for ( Expression * expr : tupleExpr->get_exprs() ) {
-                                        explodeUnique( expr, alt, indexer, std::forward<Output>(out), isTupleAssign );
+                                }
-                        } else {
-                                // tuple type, but not tuple expr - recursively index into its components.
-                                // if expr type is reference, convert to value type
-                                Expression * arg = expr->clone();
-                                if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
-                                        // expressions which may contain side effects require a single unique instance of the expression.
-                                        arg = new UniqueExpr( arg );
+                                }
-                                // cast reference to value type to facilitate further explosion
-                                if ( dynamic_cast<ReferenceType *>( arg->get_result() ) ) {
-                                        arg = new CastExpr( arg, tupleType->clone() );
+                                }
-                                for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
-                                        TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
-                                        explodeUnique( idx, alt, indexer, std::forward<Output>(out), isTupleAssign );
-                                        delete idx;
+                                }
-                                delete arg;
+                        }
-                } else {
-                        // atomic (non-tuple) type - output a clone of the expression in a new alternative
-                        append( std::forward<Output>(out), expr->clone(), alt.env, alt.openVars, alt.need,
-                                alt.cost, alt.cvtCost );
+                }
+        }
-        /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
-        template< typename Output >
-        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer,
-                        Output&& out, bool isTupleAssign = false ) {
-                explodeUnique( alt.expr, alt, indexer, std::forward<Output>(out), isTupleAssign );
+        }
-        // explode list of alternatives
-        template< typename AltIterator, typename Output >
-        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer,
-                        Output&& out, bool isTupleAssign = false ) {
-                for ( ; altBegin != altEnd; ++altBegin ) {
-                        explode( *altBegin, indexer, std::forward<Output>(out), isTupleAssign );
+                }
+        }
-        template< typename Output >
-        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, Output&& out,
-                        bool isTupleAssign = false ) {
-                explode( alts.begin(), alts.end(), indexer, std::forward<Output>(out), isTupleAssign );
+        }
 const ast::Expr * distributeReference( const ast::Expr * );

src/Tuples/TupleAssignment.cc

-              r0030b508
+              rfc12f05
 #include "AST/TypeEnvironment.hpp"
 #include "CodeGen/OperatorTable.h"
-#include "Common/PassVisitor.h"
 #include "Common/UniqueName.h"             // for UniqueName
 #include "Common/utility.h"                // for splice, zipWith
 …
 #include "InitTweak/GenInit.h"             // for genCtorInit
 #include "InitTweak/InitTweak.h"           // for getPointerBase, isAssignment
-#include "ResolvExpr/Alternative.h"        // for AltList, Alternative
-#include "ResolvExpr/AlternativeFinder.h"  // for AlternativeFinder, simpleC...
 #include "ResolvExpr/Cost.h"               // for Cost
 #include "ResolvExpr/Resolver.h"           // for resolveCtorInit
-#include "ResolvExpr/TypeEnvironment.h"    // for TypeEnvironment
 #include "ResolvExpr/typeops.h"            // for combos
-#include "SynTree/LinkageSpec.h"           // for Cforall
-#include "SynTree/Declaration.h"           // for ObjectDecl
-#include "SynTree/Expression.h"            // for Expression, CastExpr, Name...
-#include "SynTree/Initializer.h"           // for ConstructorInit, SingleInit
-#include "SynTree/Statement.h"             // for ExprStmt
-#include "SynTree/Type.h"                  // for Type, Type::Qualifiers
-#include "SynTree/TypeSubstitution.h"      // for TypeSubstitution
-#include "SynTree/Visitor.h"               // for Visitor
 #if 0
 …
 namespace Tuples {
-        class TupleAssignSpotter_old {
-          public:
-                // dispatcher for Tuple (multiple and mass) assignment operations
-                TupleAssignSpotter_old( ResolvExpr::AlternativeFinder & );
-                void spot( UntypedExpr * expr, std::vector<ResolvExpr::AlternativeFinder> &args );
-          private:
-                void match();
-                struct Matcher {
-                  public:
-                        Matcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs,
-                                const ResolvExpr::AltList& rhs );
-                        virtual ~Matcher() {}
-                        virtual void match( std::list< Expression * > &out ) = 0;
-                        ObjectDecl * newObject( UniqueName & namer, Expression * expr );
-                        void combineState( const ResolvExpr::Alternative& alt ) {
-                                compositeEnv.simpleCombine( alt.env );
-                                ResolvExpr::mergeOpenVars( openVars, alt.openVars );
-                                cloneAll( alt.need, need );
+                        }
-                        void combineState( const ResolvExpr::AltList& alts ) {
-                                for ( const ResolvExpr::Alternative& alt : alts ) { combineState( alt ); }
+                        }
-                        ResolvExpr::AltList lhs, rhs;
-                        TupleAssignSpotter_old &spotter;
-                        ResolvExpr::Cost baseCost;
-                        std::list< ObjectDecl * > tmpDecls;
-                        ResolvExpr::TypeEnvironment compositeEnv;
-                        ResolvExpr::OpenVarSet openVars;
-                        ResolvExpr::AssertionSet need;
-                };
-                struct MassAssignMatcher : public Matcher {
-                  public:
-                        MassAssignMatcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs,
-                                const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
-                        virtual void match( std::list< Expression * > &out );
-                };
-                struct MultipleAssignMatcher : public Matcher {
-                  public:
-                        MultipleAssignMatcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs,
-                                const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
-                        virtual void match( std::list< Expression * > &out );
-                };
-                ResolvExpr::AlternativeFinder &currentFinder;
-                std::string fname;
-                std::unique_ptr< Matcher > matcher;
-        };
-        /// true if expr is an expression of tuple type
-        bool isTuple( Expression *expr ) {
-                if ( ! expr ) return false;
-                assert( expr->result );
-                return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
+        }
-        template< typename AltIter >
-        bool isMultAssign( AltIter begin, AltIter end ) {
-                // multiple assignment if more than one alternative in the range or if
-                // the alternative is a tuple
-                if ( begin == end ) return false;
-                if ( isTuple( begin->expr ) ) return true;
-                return ++begin != end;
+        }
-        bool refToTuple( Expression *expr ) {
-                assert( expr->get_result() );
-                // also check for function returning tuple of reference types
-                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                        return refToTuple( castExpr->get_arg() );
-                } else {
-                        return isTuple( expr );
+                }
-                return false;
+        }
-        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr,
-                                std::vector<ResolvExpr::AlternativeFinder> &args ) {
-                TupleAssignSpotter_old spotter( currentFinder );
-                spotter.spot( expr, args );
+        }
-        TupleAssignSpotter_old::TupleAssignSpotter_old( ResolvExpr::AlternativeFinder &f )
-                : currentFinder(f) {}
-        void TupleAssignSpotter_old::spot( UntypedExpr * expr,
-                        std::vector<ResolvExpr::AlternativeFinder> &args ) {
-                if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
-                        if ( CodeGen::isCtorDtorAssign( op->get_name() ) ) {
-                                fname = op->get_name();
-                                // AlternativeFinder will naturally handle this case case, if it's legal
-                                if ( args.size() == 0 ) return;
-                                // if an assignment only takes 1 argument, that's odd, but maybe someone wrote
-                                // the function, in which case AlternativeFinder will handle it normally
-                                if ( args.size() == 1 && CodeGen::isAssignment( fname ) ) return;
-                                // look over all possible left-hand-sides
-                                for ( ResolvExpr::Alternative& lhsAlt : args[0] ) {
-                                        // skip non-tuple LHS
-                                        if ( ! refToTuple(lhsAlt.expr) ) continue;
-                                        // explode is aware of casts - ensure every LHS expression is sent into explode
-                                        // with a reference cast
-                                        // xxx - this seems to change the alternatives before the normal
-                                        //  AlternativeFinder flow; maybe this is desired?
-                                        if ( ! dynamic_cast<CastExpr*>( lhsAlt.expr ) ) {
-                                                lhsAlt.expr = new CastExpr( lhsAlt.expr,
-                                                                new ReferenceType( Type::Qualifiers(),
-                                                                        lhsAlt.expr->result->clone() ) );
+                                        }
-                                        // explode the LHS so that each field of a tuple-valued-expr is assigned
-                                        ResolvExpr::AltList lhs;
-                                        explode( lhsAlt, currentFinder.get_indexer(), back_inserter(lhs), true );
-                                        for ( ResolvExpr::Alternative& alt : lhs ) {
-                                                // each LHS value must be a reference - some come in with a cast expression,
-                                                // if not just cast to reference here
-                                                if ( ! dynamic_cast<ReferenceType*>( alt.expr->get_result() ) ) {
-                                                        alt.expr = new CastExpr( alt.expr,
-                                                                new ReferenceType( Type::Qualifiers(),
-                                                                        alt.expr->get_result()->clone() ) );
+                                                }
+                                        }
-                                        if ( args.size() == 1 ) {
-                                                // mass default-initialization/destruction
-                                                ResolvExpr::AltList rhs{};
-                                                matcher.reset( new MassAssignMatcher( *this, lhs, rhs ) );
-                                                match();
-                                        } else if ( args.size() > 2 ) {
-                                                // expand all possible RHS possibilities
-                                                // TODO build iterative version of this instead of using combos
-                                                std::vector< ResolvExpr::AltList > rhsAlts;
-                                                combos( std::next(args.begin(), 1), args.end(),
-                                                        std::back_inserter( rhsAlts ) );
-                                                for ( const ResolvExpr::AltList& rhsAlt : rhsAlts ) {
-                                                        // multiple assignment
-                                                        ResolvExpr::AltList rhs;
-                                                        explode( rhsAlt, currentFinder.get_indexer(),
-                                                                std::back_inserter(rhs), true );
-                                                        matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
-                                                        match();
+                                                }
-                                        } else {
-                                                for ( const ResolvExpr::Alternative& rhsAlt : args[1] ) {
-                                                        ResolvExpr::AltList rhs;
-                                                        if ( isTuple(rhsAlt.expr) ) {
-                                                                // multiple assignment
-                                                                explode( rhsAlt, currentFinder.get_indexer(),
-                                                                        std::back_inserter(rhs), true );
-                                                                matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
-                                                        } else {
-                                                                // mass assignment
-                                                                rhs.push_back( rhsAlt );
-                                                                matcher.reset( new MassAssignMatcher( *this, lhs, rhs ) );
+                                                        }
-                                                        match();
+                                                }
+                                        }
+                                }
+                        }
+                }
+        }
-        void TupleAssignSpotter_old::match() {
-                assert ( matcher != 0 );
-                std::list< Expression * > new_assigns;
-                matcher->match( new_assigns );
-                if ( ! matcher->lhs.empty() || ! matcher->rhs.empty() ) {
-                        // if both lhs and rhs are empty then this is the empty tuple case, wherein it's okay for new_assigns to be empty.
-                        // if not the empty tuple case, return early so that no new alternatives are generated.
-                        if ( new_assigns.empty() ) return;
+                }
-                ResolvExpr::AltList current;
-                // now resolve new assignments
-                for ( std::list< Expression * >::iterator i = new_assigns.begin();
-                                i != new_assigns.end(); ++i ) {
-                        PRINT(
-                                std::cerr << "== resolving tuple assign ==" << std::endl;
-                                std::cerr << *i << std::endl;
+                        )
-                        ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(),
-                                matcher->compositeEnv };
-                        try {
-                                finder.findWithAdjustment(*i);
-                        } catch (...) {
-                                return; // no match should not mean failure, it just means this particular tuple assignment isn't valid
+                        }
-                        // prune expressions that don't coincide with
-                        ResolvExpr::AltList alts = finder.get_alternatives();
-                        assert( alts.size() == 1 );
-                        assert( alts.front().expr != 0 );
-                        current.push_back( alts.front() );
+                }
-                // extract expressions from the assignment alternatives to produce a list of assignments
-                // that together form a single alternative
-                std::list< Expression *> solved_assigns;
-                for ( ResolvExpr::Alternative & alt : current ) {
-                        solved_assigns.push_back( alt.expr->clone() );
-                        matcher->combineState( alt );
+                }
-                // xxx -- was push_front
-                currentFinder.get_alternatives().push_back( ResolvExpr::Alternative{
-                        new TupleAssignExpr{ solved_assigns, matcher->tmpDecls }, matcher->compositeEnv,
-                        matcher->openVars,
-                        ResolvExpr::AssertionList( matcher->need.begin(), matcher->need.end() ),
-                        ResolvExpr::sumCost( current ) + matcher->baseCost } );
+        }
-        TupleAssignSpotter_old::Matcher::Matcher( TupleAssignSpotter_old &spotter,
-                const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs )
-        : lhs(lhs), rhs(rhs), spotter(spotter),
-          baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ) {
-                combineState( lhs );
-                combineState( rhs );
+        }
-        UntypedExpr * createFunc( const std::string &fname, ObjectDecl *left, ObjectDecl *right ) {
-                assert( left );
-                std::list< Expression * > args;
-                args.push_back( new VariableExpr( left ) );
-                // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
-                if ( right ) args.push_back( new VariableExpr( right ) );
-                if ( left->type->referenceDepth() > 1 && CodeGen::isConstructor( fname ) ) {
-                        args.front() = new AddressExpr( args.front() );
-                        if ( right ) args.back() = new AddressExpr( args.back() );
-                        return new UntypedExpr( new NameExpr( "?=?" ), args );
-                } else {
-                        return new UntypedExpr( new NameExpr( fname ), args );
+                }
+        }
-        // removes environments from subexpressions within statement exprs, which could throw off later passes like those in Box which rely on PolyMutator, and adds the bindings to the compositeEnv
-        // xxx - maybe this should happen in alternative finder for every StmtExpr?
-        struct EnvRemover {
-                void previsit( ExprStmt * stmt ) {
-                        assert( compositeEnv );
-                        if ( stmt->expr->env ) {
-                                compositeEnv->add( *stmt->expr->env );
-                                delete stmt->expr->env;
-                                stmt->expr->env = nullptr;
+                        }
+                }
-                ResolvExpr::TypeEnvironment * compositeEnv = nullptr;
-        };
-        ObjectDecl * TupleAssignSpotter_old::Matcher::newObject( UniqueName & namer, Expression * expr ) {
-                assert( expr->result && ! expr->get_result()->isVoid() );
-                ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->result->clone(), new SingleInit( expr->clone() ) );
-                // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
-                if ( ! dynamic_cast< ReferenceType * >( expr->result ) ) {
-                        ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
-                        ret->init = ctorInit;
-                        ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
-                        PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs
-                        rm.pass.compositeEnv = &compositeEnv;
-                        ctorInit->accept( rm );
+                }
-                PRINT( std::cerr << "new object: " << ret << std::endl; )
-                return ret;
+        }
-        void TupleAssignSpotter_old::MassAssignMatcher::match( std::list< Expression * > &out ) {
-                static UniqueName lhsNamer( "__massassign_L" );
-                static UniqueName rhsNamer( "__massassign_R" );
-                // empty tuple case falls into this matcher, hence the second part of the assert
-                assert( (! lhs.empty() && rhs.size() <= 1) || (lhs.empty() && rhs.empty()) );
-                // xxx - may need to split this up into multiple declarations, because potential conversion to references
-                //  probably should not reference local variable - see MultipleAssignMatcher::match
-                ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
-                for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
-                        // create a temporary object for each value in the lhs and create a call involving the rhs
-                        ObjectDecl * ltmp = newObject( lhsNamer, lhsAlt.expr );
-                        out.push_back( createFunc( spotter.fname, ltmp, rtmp ) );
-                        tmpDecls.push_back( ltmp );
+                }
-                if ( rtmp ) tmpDecls.push_back( rtmp );
+        }
-        void TupleAssignSpotter_old::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
-                static UniqueName lhsNamer( "__multassign_L" );
-                static UniqueName rhsNamer( "__multassign_R" );
-                if ( lhs.size() == rhs.size() ) {
-                        // produce a new temporary object for each value in the lhs and rhs and pairwise create the calls
-                        std::list< ObjectDecl * > ltmp;
-                        std::list< ObjectDecl * > rtmp;
-                        for ( auto p : group_iterate( lhs, rhs ) ) {
-                                ResolvExpr::Alternative & lhsAlt = std::get<0>(p);
-                                ResolvExpr::Alternative & rhsAlt = std::get<1>(p);
-                                // convert RHS to LHS type minus one reference -- important for the case where LHS is && and RHS is lvalue, etc.
-                                ReferenceType * lhsType = strict_dynamic_cast<ReferenceType *>( lhsAlt.expr->result );
-                                rhsAlt.expr = new CastExpr( rhsAlt.expr, lhsType->base->clone() );
-                                ObjectDecl * lobj = newObject( lhsNamer, lhsAlt.expr );
-                                ObjectDecl * robj = newObject( rhsNamer, rhsAlt.expr );
-                                out.push_back( createFunc(spotter.fname, lobj, robj) );
-                                ltmp.push_back( lobj );
-                                rtmp.push_back( robj );
-                                // resolve the cast expression so that rhsAlt return type is bound by the cast type as needed, and transfer the resulting environment
-                                ResolvExpr::AlternativeFinder finder{ spotter.currentFinder.get_indexer(), compositeEnv };
-                                finder.findWithAdjustment( rhsAlt.expr );
-                                assert( finder.get_alternatives().size() == 1 );
-                                compositeEnv = std::move( finder.get_alternatives().front().env );
+                        }
-                        tmpDecls.splice( tmpDecls.end(), ltmp );
-                        tmpDecls.splice( tmpDecls.end(), rtmp );
+                }
+        }
 namespace {

src/Tuples/TupleExpansion.cc

-              r0030b508
+              rfc12f05
 #include "AST/Node.hpp"
 #include "AST/Type.hpp"
-#include "Common/PassVisitor.h"   // for PassVisitor, WithDeclsToAdd, WithGu...
 #include "Common/ScopedMap.h"     // for ScopedMap
 #include "Common/utility.h"       // for CodeLocation
 #include "InitTweak/InitTweak.h"  // for getFunction
-#include "SynTree/LinkageSpec.h"  // for Spec, C, Intrinsic
-#include "SynTree/Constant.h"     // for Constant
-#include "SynTree/Declaration.h"  // for StructDecl, DeclarationWithType
-#include "SynTree/Expression.h"   // for UntypedMemberExpr, Expression, Uniq...
-#include "SynTree/Label.h"        // for operator==, Label
-#include "SynTree/Mutator.h"      // for Mutator
-#include "SynTree/Type.h"         // for Type, Type::Qualifiers, TupleType
-#include "SynTree/Visitor.h"      // for Visitor
 #include "Tuples.h"
+class CompoundStmt;
+class TypeSubstitution;
+namespace Tuples {
-namespace Tuples {
-        namespace {
-                struct MemberTupleExpander final : public WithShortCircuiting, public WithVisitorRef<MemberTupleExpander> {
-                        void premutate( UntypedMemberExpr * ) { visit_children = false; }
-                        Expression * postmutate( UntypedMemberExpr * memberExpr );
-                };
-                struct UniqueExprExpander final : public WithDeclsToAdd {
-                        Expression * postmutate( UniqueExpr * unqExpr );
-                        std::map< int, Expression * > decls; // not vector, because order added may not be increasing order
-                        ~UniqueExprExpander() {
-                                for ( std::pair<const int, Expression *> & p : decls ) {
-                                        delete p.second;
+                                }
+                        }
-                };
-                struct TupleAssignExpander {
-                        Expression * postmutate( TupleAssignExpr * tupleExpr );
-                };
-                struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithConstTypeSubstitution {
-                        Type * postmutate( TupleType * tupleType );
-                        void premutate( CompoundStmt * ) {
-                                GuardScope( typeMap );
+                        }
-                  private:
-                        ScopedMap< int, StructDecl * > typeMap;
-                };
-                struct TupleIndexExpander {
-                        Expression * postmutate( TupleIndexExpr * tupleExpr );
-                };
-                struct TupleExprExpander final {
-                        Expression * postmutate( TupleExpr * tupleExpr );
-                };
+        }
-        void expandMemberTuples( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<MemberTupleExpander> expander;
-                mutateAll( translationUnit, expander );
+        }
-        void expandUniqueExpr( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<UniqueExprExpander> unqExpander;
-                mutateAll( translationUnit, unqExpander );
+        }
-        void expandTuples( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<TupleAssignExpander> assnExpander;
-                mutateAll( translationUnit, assnExpander );
-                PassVisitor<TupleTypeReplacer> replacer;
-                mutateAll( translationUnit, replacer );
-                PassVisitor<TupleIndexExpander> idxExpander;
-                mutateAll( translationUnit, idxExpander );
-                PassVisitor<TupleExprExpander> exprExpander;
-                mutateAll( translationUnit, exprExpander );
+        }
-        namespace {
-                /// given a expression representing the member and an expression representing the aggregate,
-                /// reconstructs a flattened UntypedMemberExpr with the right precedence
-                Expression * reconstructMemberExpr( Expression * member, Expression * aggr, CodeLocation & loc ) {
-                        if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( member ) ) {
-                                // construct a new UntypedMemberExpr with the correct structure , and recursively
-                                // expand that member expression.
-                                PassVisitor<MemberTupleExpander> expander;
-                                UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->aggregate, aggr->clone() );
-                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member, inner );
-                                inner->location = newMemberExpr->location = loc;
-                                memberExpr->member = nullptr;
-                                memberExpr->aggregate = nullptr;
-                                delete memberExpr;
-                                return newMemberExpr->acceptMutator( expander );
-                        } else {
-                                // not a member expression, so there is nothing to do but attach and return
-                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( member, aggr->clone() );
-                                newMemberExpr->location = loc;
-                                return newMemberExpr;
+                        }
+                }
+        }
-        Expression * MemberTupleExpander::postmutate( UntypedMemberExpr * memberExpr ) {
-                if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->member ) ) {
-                        Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor );
-                        // aggregate expressions which might be impure must be wrapped in unique expressions
-                        if ( Tuples::maybeImpureIgnoreUnique( memberExpr->aggregate ) ) aggr = new UniqueExpr( aggr );
-                        for ( Expression *& expr : tupleExpr->exprs ) {
-                                expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
-                                expr->location = memberExpr->location;
+                        }
-                        delete aggr;
-                        tupleExpr->location = memberExpr->location;
-                        return tupleExpr;
-                } else {
-                        // there may be a tuple expr buried in the aggregate
-                        // xxx - this is a memory leak
-                        UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member->clone(), memberExpr->aggregate->acceptMutator( *visitor ) );
-                        newMemberExpr->location = memberExpr->location;
-                        return newMemberExpr;
+                }
+        }
-        Expression * UniqueExprExpander::postmutate( UniqueExpr * unqExpr ) {
-                const int id = unqExpr->get_id();
-                // on first time visiting a unique expr with a particular ID, generate the expression that replaces all UniqueExprs with that ID,
-                // and lookup on subsequent hits. This ensures that all unique exprs with the same ID reference the same variable.
-                if ( ! decls.count( id ) ) {
-                        Expression * assignUnq;
-                        Expression * var = unqExpr->get_var();
-                        if ( unqExpr->get_object() ) {
-                                // an object was generated to represent this unique expression -- it should be added to the list of declarations now
-                                declsToAddBefore.push_back( unqExpr->get_object() );
-                                unqExpr->set_object( nullptr );
-                                // steal the expr from the unqExpr
-                                assignUnq = UntypedExpr::createAssign( unqExpr->get_var()->clone(), unqExpr->get_expr() );
-                                unqExpr->set_expr( nullptr );
-                        } else {
-                                // steal the already generated assignment to var from the unqExpr - this has been generated by FixInit
-                                Expression * expr = unqExpr->get_expr();
-                                CommaExpr * commaExpr = strict_dynamic_cast< CommaExpr * >( expr );
-                                assignUnq = commaExpr->get_arg1();
-                                commaExpr->set_arg1( nullptr );
+                        }
-                        ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ),
-                                                                                                        new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) );
-                        declsToAddBefore.push_back( finished );
-                        // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
-                        // This pattern ensures that each unique expression is evaluated once, regardless of evaluation order of the generated C code.
-                        Expression * assignFinished = UntypedExpr::createAssign( new VariableExpr(finished), new ConstantExpr( Constant::from_int( 1 ) ) );
-                        ConditionalExpr * condExpr = new ConditionalExpr( new VariableExpr( finished ), var->clone(),
-                                new CommaExpr( new CommaExpr( assignUnq, assignFinished ), var->clone() ) );
-                        condExpr->set_result( var->get_result()->clone() );
-                        condExpr->set_env( maybeClone( unqExpr->get_env() ) );
-                        decls[id] = condExpr;
+                }
-                delete unqExpr;
-                return decls[id]->clone();
+        }
-        Expression * TupleAssignExpander::postmutate( TupleAssignExpr * assnExpr ) {
-                StmtExpr * ret = assnExpr->get_stmtExpr();
-                assnExpr->set_stmtExpr( nullptr );
-                // move env to StmtExpr
-                ret->set_env( assnExpr->get_env() );
-                assnExpr->set_env( nullptr );
-                delete assnExpr;
-                return ret;
+        }
-        Type * TupleTypeReplacer::postmutate( TupleType * tupleType ) {
-                unsigned tupleSize = tupleType->size();
-                if ( ! typeMap.count( tupleSize ) ) {
-                        // generate struct type to replace tuple type based on the number of components in the tuple
-                        StructDecl * decl = new StructDecl( toString( "_tuple", tupleSize, "_" ) );
-                        decl->location = tupleType->location;
-                        decl->set_body( true );
-                        for ( size_t i = 0; i < tupleSize; ++i ) {
-                                TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", tupleSize, "_", i ), Type::StorageClasses(), nullptr, TypeDecl::Dtype, true );
-                                decl->get_members().push_back( new ObjectDecl( toString("field_", i ), Type::StorageClasses(), LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) );
-                                decl->get_parameters().push_back( tyParam );
+                        }
-                        if ( tupleSize == 0 ) {
-                                // empty structs are not standard C. Add a dummy field to empty tuples to silence warnings when a compound literal Tuple0 is created.
-                                decl->get_members().push_back( new ObjectDecl( "dummy", Type::StorageClasses(), LinkageSpec::C, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
+                        }
-                        typeMap[tupleSize] = decl;
-                        declsToAddBefore.push_back( decl );
+                }
-                Type::Qualifiers qualifiers = tupleType->get_qualifiers();
-                StructDecl * decl = typeMap[tupleSize];
-                StructInstType * newType = new StructInstType( qualifiers, decl );
-                for ( auto p : group_iterate( tupleType->get_types(), decl->get_parameters() ) ) {
-                        Type * t = std::get<0>(p);
-                        newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
+                }
-                delete tupleType;
-                return newType;
+        }
-        Expression * TupleIndexExpander::postmutate( TupleIndexExpr * tupleExpr ) {
-                Expression * tuple = tupleExpr->tuple;
-                assert( tuple );
-                tupleExpr->tuple = nullptr;
-                unsigned int idx = tupleExpr->index;
-                TypeSubstitution * env = tupleExpr->env;
-                tupleExpr->env = nullptr;
-                delete tupleExpr;
-                if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * > ( tuple ) ) {
-                        if ( ! maybeImpureIgnoreUnique( tupleExpr ) ) {
-                                // optimization: definitely pure tuple expr => can reduce to the only relevant component.
-                                assert( tupleExpr->exprs.size() > idx );
-                                Expression *& expr = *std::next(tupleExpr->exprs.begin(), idx);
-                                Expression * ret = expr;
-                                ret->env = env;
-                                expr = nullptr; // remove from list so it can safely be deleted
-                                delete tupleExpr;
-                                return ret;
+                        }
+                }
-                StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->result );
-                StructDecl * structDecl = type->baseStruct;
-                assert( structDecl->members.size() > idx );
-                Declaration * member = *std::next(structDecl->members.begin(), idx);
-                MemberExpr * memExpr = new MemberExpr( strict_dynamic_cast< DeclarationWithType * >( member ), tuple );
-                memExpr->env = env;
-                return memExpr;
+        }
-        Expression * replaceTupleExpr( Type * result, const std::list< Expression * > & exprs, TypeSubstitution * env ) {
-                if ( result->isVoid() ) {
-                        // void result - don't need to produce a value for cascading - just output a chain of comma exprs
-                        assert( ! exprs.empty() );
-                        std::list< Expression * >::const_iterator iter = exprs.begin();
-                        Expression * expr = new CastExpr( *iter++ );
-                        for ( ; iter != exprs.end(); ++iter ) {
-                                expr = new CommaExpr( expr, new CastExpr( *iter ) );
+                        }
-                        expr->set_env( env );
-                        return expr;
-                } else {
-                        // typed tuple expression - produce a compound literal which performs each of the expressions
-                        // as a distinct part of its initializer - the produced compound literal may be used as part of
-                        // another expression
-                        std::list< Initializer * > inits;
-                        for ( Expression * expr : exprs ) {
-                                inits.push_back( new SingleInit( expr ) );
+                        }
-                        Expression * expr = new CompoundLiteralExpr( result, new ListInit( inits ) );
-                        expr->set_env( env );
-                        return expr;
+                }
+        }
-        Expression * TupleExprExpander::postmutate( TupleExpr * tupleExpr ) {
-                Type * result = tupleExpr->get_result();
-                std::list< Expression * > exprs = tupleExpr->get_exprs();
-                assert( result );
-                TypeSubstitution * env = tupleExpr->get_env();
-                // remove data from shell and delete it
-                tupleExpr->set_result( nullptr );
-                tupleExpr->get_exprs().clear();
-                tupleExpr->set_env( nullptr );
-                delete tupleExpr;
-                return replaceTupleExpr( result, exprs, env );
+        }
-        Type * makeTupleType( const std::list< Expression * > & exprs ) {
-                // produce the TupleType which aggregates the types of the exprs
-                std::list< Type * > types;
-                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic | Type::Mutex );
-                for ( Expression * expr : exprs ) {
-                        assert( expr->get_result() );
-                        if ( expr->get_result()->isVoid() ) {
-                                // if the type of any expr is void, the type of the entire tuple is void
-                                return new VoidType( Type::Qualifiers() );
+                        }
-                        Type * type = expr->get_result()->clone();
-                        types.push_back( type );
-                        // the qualifiers on the tuple type are the qualifiers that exist on all component types
-                        qualifiers &= type->get_qualifiers();
-                } // for
-                if ( exprs.empty() ) qualifiers = Type::Qualifiers();
-                return new TupleType( qualifiers, types );
+        }
         const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs ) {
                 // produce the TupleType which aggregates the types of the exprs
 …
+        }
-        TypeInstType * isTtype( Type * type ) {
-                if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( inst->get_baseType() && inst->get_baseType()->get_kind() == TypeDecl::Ttype ) {
-                                return inst;
+                        }
+                }
-                return nullptr;
+        }
-        const TypeInstType * isTtype( const Type * type ) {
-                if ( const TypeInstType * inst = dynamic_cast< const TypeInstType * >( type ) ) {
-                        if ( inst->baseType && inst->baseType->kind == TypeDecl::Ttype ) {
-                                return inst;
+                        }
+                }
-                return nullptr;
+        }
         const ast::TypeInstType * isTtype( const ast::Type * type ) {
                 if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {

src/Tuples/Tuples.cc

-              r0030b508
+              rfc12f05
 #include "AST/Inspect.hpp"
 #include "AST/LinkageSpec.hpp"
-#include "Common/PassVisitor.h"
 #include "InitTweak/InitTweak.h"
 …
 namespace {
-        /// Checks if impurity (read: side-effects) may exist in a piece of code.
-        /// Currently gives a very crude approximation, wherein any function
-        /// call expression means the code may be impure.
-        struct ImpurityDetector_old : public WithShortCircuiting {
-                bool const ignoreUnique;
-                bool maybeImpure;
-                ImpurityDetector_old( bool ignoreUnique ) :
-                        ignoreUnique( ignoreUnique ), maybeImpure( false )
-                {}
-                void previsit( const ApplicationExpr * appExpr ) {
-                        visit_children = false;
-                        if ( const DeclarationWithType * function =
-                                        InitTweak::getFunction( appExpr ) ) {
-                                if ( function->linkage == LinkageSpec::Intrinsic ) {
-                                        if ( function->name == "*?" || function->name == "?[?]" ) {
-                                                // intrinsic dereference, subscript are pure,
-                                                // but need to recursively look for impurity
-                                                visit_children = true;
-                                                return;
+                                        }
+                                }
+                        }
-                        maybeImpure = true;
+                }
-                void previsit( const UntypedExpr * ) {
-                        maybeImpure = true;
-                        visit_children = false;
+                }
-                void previsit( const UniqueExpr * ) {
-                        if ( ignoreUnique ) {
-                                // bottom out at unique expression.
-                                // The existence of a unique expression doesn't change the purity of an expression.
-                                // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
-                                visit_children = false;
-                                return;
+                        }
+                }
-        };
-        bool detectImpurity( const Expression * expr, bool ignoreUnique ) {
-                PassVisitor<ImpurityDetector_old> detector( ignoreUnique );
-                expr->accept( detector );
-                return detector.pass.maybeImpure;
+        }
         /// Determines if impurity (read: side-effects) may exist in a piece of code. Currently gives
 …
+}
-bool maybeImpure( const Expression * expr ) {
-        return detectImpurity( expr, false );
+}
-bool maybeImpureIgnoreUnique( const Expression * expr ) {
-        return detectImpurity( expr, true );
+}
 } // namespace Tuples

src/Tuples/Tuples.h

-              r0030b508
+              rfc12f05
 #include "AST/Fwd.hpp"
 #include "AST/Node.hpp"
-#include "SynTree/Expression.h"
-#include "SynTree/Declaration.h"
-#include "SynTree/Type.h"
-#include "ResolvExpr/AlternativeFinder.h"
 #include "ResolvExpr/CandidateFinder.hpp"
 namespace Tuples {
         // TupleAssignment.cc
-        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign,
-                std::vector< ResolvExpr::AlternativeFinder >& args );
         void handleTupleAssignment(
                 ResolvExpr::CandidateFinder & finder, const ast::UntypedExpr * assign,
 …
         // TupleExpansion.cc
         /// expands z.[a, b.[x, y], c] into [z.a, z.b.x, z.b.y, z.c], inserting UniqueExprs as appropriate
-        void expandMemberTuples( std::list< Declaration * > & translationUnit );
         void expandMemberTuples( ast::TranslationUnit & translationUnit );
         /// replaces tuple-related elements, such as TupleType, TupleExpr, TupleAssignExpr, etc.
-        void expandTuples( std::list< Declaration * > & translationUnit );
         void expandTuples( ast::TranslationUnit & translaionUnit );
         /// replaces UniqueExprs with a temporary variable and one call
-        void expandUniqueExpr( std::list< Declaration * > & translationUnit );
         void expandUniqueExpr( ast::TranslationUnit & translationUnit );
         /// returns VoidType if any of the expressions have Voidtype, otherwise TupleType of the Expression result types
-        Type * makeTupleType( const std::list< Expression * > & exprs );
         const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs );
         /// returns a TypeInstType if `type` is a ttype, nullptr otherwise
-        TypeInstType * isTtype( Type * type );
-        const TypeInstType * isTtype( const Type * type );
         const ast::TypeInstType * isTtype( const ast::Type * type );
         /// returns true if the expression may contain side-effects.
-        bool maybeImpure( const Expression * expr );
         bool maybeImpure( const ast::Expr * expr );
         /// Returns true if the expression may contain side-effect,
         /// ignoring the presence of unique expressions.
-        bool maybeImpureIgnoreUnique( const Expression * expr );
         bool maybeImpureIgnoreUnique( const ast::Expr * expr );
 } // namespace Tuples

src/Validate/FindSpecialDecls.h

-              r0030b508
+              rfc12f05
 #pragma once
-#include <list>  // for list
-class Declaration;
-class FunctionDecl;
-class StructDecl;
-class Type;
 namespace ast {
         class TranslationUnit;
 …
 namespace Validate {
-        /// size_t type - set when size_t typedef is seen. Useful in a few places,
-        /// such as in determining array dimension type
-        extern Type * SizeType;
-        /// intrinsic dereference operator for unqualified types - set when *? function is seen in FindSpecialDeclarations.
-        /// Useful for creating dereference ApplicationExprs without a full resolver pass.
-        extern FunctionDecl * dereferenceOperator;
-        /// special built-in functions and data structures necessary for destructor generation
-        extern StructDecl * dtorStruct;
-        extern FunctionDecl * dtorStructDestroy;
-        /// find and remember some of the special declarations that are useful for generating code, so that they do not have to be discovered multiple times.
-        void findSpecialDecls( std::list< Declaration * > & translationUnit );
 /// Find and remember some of the special declarations that are useful for

src/Validate/FixReturnTypes.cpp

r0030b508	rfc12f05
19	19	#include "AST/Pass.hpp"
20	20	#include "AST/Type.hpp"
21		#include "CodeGen/CodeGenerator.h"
	21	#include "CodeGen/CodeGeneratorNew.hpp"
22	22	#include "ResolvExpr/Unify.h"
23	23

src/Validate/module.mk

-              r0030b508
+              rfc12f05
 SRC_VALIDATE = \
-        Validate/FindSpecialDecls.cc \
         Validate/FindSpecialDecls.h
 …
         Validate/GenericParameter.cpp \
         Validate/GenericParameter.hpp \
-        Validate/HandleAttributes.cc \
-        Validate/HandleAttributes.h \
         Validate/HoistStruct.cpp \
         Validate/HoistStruct.hpp \

src/Virtual/ExpandCasts.cc

-              r0030b508
+              rfc12f05
 #include "AST/Expr.hpp"
 #include "AST/Pass.hpp"
-#include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/ScopedMap.h"      // for ScopedMap
 #include "Common/SemanticError.h"  // for SemanticError
 #include "SymTab/Mangler.h"        // for mangleType
-#include "SynTree/Declaration.h"   // for ObjectDecl, StructDecl, FunctionDecl
-#include "SynTree/Expression.h"    // for VirtualCastExpr, CastExpr, Address...
-#include "SynTree/Mutator.h"       // for mutateAll
-#include "SynTree/Type.h"          // for Type, PointerType, StructInstType
-#include "SynTree/Visitor.h"       // for acceptAll
 namespace Virtual {
 …
+}
-bool is_type_id_object( const ObjectDecl * objectDecl ) {
-        const std::string & objectName = objectDecl->name;
-        return is_prefix( "__cfatid_", objectName );
+}
 bool is_type_id_object( const ast::ObjectDecl * decl ) {
         return is_prefix( "__cfatid_", decl->name );
 …
         /// Maps virtual table types the instance for that type.
-        class VirtualTableMap final {
-                ScopedMap<std::string, ObjectDecl *> vtable_instances;
-        public:
-                void enterScope() {
-                        vtable_instances.beginScope();
+                }
-                void leaveScope() {
-                        vtable_instances.endScope();
+                }
-                ObjectDecl * insert( ObjectDecl * vtableDecl ) {
-                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableDecl->type );
-                        ObjectDecl *& value = vtable_instances[ mangledName ];
-                        if ( value ) {
-                                if ( vtableDecl->storageClasses.is_extern ) {
-                                        return nullptr;
-                                } else if ( ! value->storageClasses.is_extern ) {
-                                        return value;
+                                }
+                        }
-                        value = vtableDecl;
-                        return nullptr;
+                }
-                ObjectDecl * lookup( const Type * vtableType ) {
-                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableType );
-                        const auto it = vtable_instances.find( mangledName );
-                        return ( vtable_instances.end() == it ) ? nullptr : it->second;
+                }
-        };
-        class VirtualCastCore {
-                CastExpr * cast_to_type_id( Expression * expr, int level_of_indirection ) {
-                        Type * type = new StructInstType(
-                                Type::Qualifiers( Type::Const ), pvt_decl );
-                        for (int i = 0 ; i < level_of_indirection ; ++i) {
-                                type = new PointerType( noQualifiers, type );
+                        }
-                        return new CastExpr( expr, type );
+                }
-        public:
-                VirtualCastCore() :
-                        indexer(), vcast_decl( nullptr ), pvt_decl( nullptr )
-                {}
-                void premutate( FunctionDecl * functionDecl );
-                void premutate( StructDecl * structDecl );
-                void premutate( ObjectDecl * objectDecl );
-                Expression * postmutate( VirtualCastExpr * castExpr );
-                VirtualTableMap indexer;
-        private:
-                FunctionDecl *vcast_decl;
-                StructDecl *pvt_decl;
-        };
-        void VirtualCastCore::premutate( FunctionDecl * functionDecl ) {
-                if ( (! vcast_decl) &&
-                     functionDecl->get_name() == "__cfavir_virtual_cast" ) {
-                        vcast_decl = functionDecl;
+                }
+        }
-        void VirtualCastCore::premutate( StructDecl * structDecl ) {
-                if ( pvt_decl || ! structDecl->has_body() ) {
-                        return;
-                } else if ( structDecl->get_name() == "__cfavir_type_info" ) {
-                        pvt_decl = structDecl;
+                }
+        }
-        void VirtualCastCore::premutate( ObjectDecl * objectDecl ) {
-                if ( is_type_id_object( objectDecl ) ) {
-                        // Multiple definitions should be fine because of linkonce.
-                        indexer.insert( objectDecl );
+                }
+        }
-        /// Better error locations for generated casts.
-        CodeLocation castLocation( const VirtualCastExpr * castExpr ) {
-                if ( castExpr->location.isSet() ) {
-                        return castExpr->location;
-                } else if ( castExpr->arg->location.isSet() ) {
-                        return castExpr->arg->location;
-                } else if ( castExpr->result->location.isSet() ) {
-                        return castExpr->result->location;
-                } else {
-                        return CodeLocation();
+                }
+        }
-        [[noreturn]] void castError( const VirtualCastExpr * castExpr, std::string const & message ) {
-                SemanticError( castLocation( castExpr ), message );
+        }
-        /// Get the base type from a pointer or reference.
-        const Type * getBaseType( const Type * type ) {
-                if ( auto target = dynamic_cast<const PointerType *>( type ) ) {
-                        return target->base;
-                } else if ( auto target = dynamic_cast<const ReferenceType *>( type ) ) {
-                        return target->base;
-                } else {
-                        return nullptr;
+                }
+        }
-        /* Attempt to follow the "head" field of the structure to get the...
-         * Returns nullptr on error, otherwise owner must free returned node.
-         */
-        StructInstType * followHeadPointerType(
-                        const StructInstType * oldType,
-                        const std::string& fieldName,
-                        const CodeLocation& errorLocation ) {
-                // First section of the function is all about trying to fill this variable in.
-                StructInstType * newType = nullptr;
+                {
-                        const StructDecl * oldDecl = oldType->baseStruct;
-                        assert( oldDecl );
-                        // Helper function for throwing semantic errors.
-                        auto throwError = [&fieldName, &errorLocation, &oldDecl](const std::string& message) {
-                                const std::string& context = "While following head pointer of " +
-                                        oldDecl->name + " named '" + fieldName + "': ";
-                                SemanticError( errorLocation, context + message );
-                        };
-                        if ( oldDecl->members.empty() ) {
-                                throwError( "Type has no fields." );
+                        }
-                        const Declaration * memberDecl = oldDecl->members.front();
-                        assert( memberDecl );
-                        const ObjectDecl * fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
-                        assert( fieldDecl );
-                        if ( fieldName != fieldDecl->name ) {
-                                throwError( "Head field did not have expected name." );
+                        }
-                        const Type * fieldType = fieldDecl->type;
-                        if ( nullptr == fieldType ) {
-                                throwError( "Could not get head field." );
+                        }
-                        const PointerType * ptrType = dynamic_cast<const PointerType *>( fieldType );
-                        if ( nullptr == ptrType ) {
-                                throwError( "First field is not a pointer type." );
+                        }
-                        assert( ptrType->base );
-                        newType = dynamic_cast<StructInstType *>( ptrType->base );
-                        if ( nullptr == newType ) {
-                                throwError( "First field does not point to a structure type." );
+                        }
+                }
-                // Now we can look into copying it.
-                newType = newType->clone();
-                if ( ! oldType->parameters.empty() ) {
-                        deleteAll( newType->parameters );
-                        newType->parameters.clear();
-                        cloneAll( oldType->parameters, newType->parameters );
+                }
-                return newType;
+        }
-        /// Get the type-id type from a virtual type.
-        StructInstType * getTypeIdType( const Type * type, const CodeLocation& errorLocation ) {
-                const StructInstType * typeInst = dynamic_cast<const StructInstType *>( type );
-                if ( nullptr == typeInst ) {
-                        return nullptr;
+                }
-                StructInstType * tableInst =
-                        followHeadPointerType( typeInst, "virtual_table", errorLocation );
-                if ( nullptr == tableInst ) {
-                        return nullptr;
+                }
-                StructInstType * typeIdInst =
-                        followHeadPointerType( tableInst, "__cfavir_typeid", errorLocation );
-                delete tableInst;
-                return typeIdInst;
+        }
-        Expression * VirtualCastCore::postmutate( VirtualCastExpr * castExpr ) {
-                assertf( castExpr->result, "Virtual Cast target not found before expansion." );
-                assert( vcast_decl );
-                assert( pvt_decl );
-                const Type * base_type = getBaseType( castExpr->result );
-                if ( nullptr == base_type ) {
-                        castError( castExpr, "Virtual cast target must be a pointer or reference type." );
+                }
-                const Type * type_id_type = getTypeIdType( base_type, castLocation( castExpr ) );
-                if ( nullptr == type_id_type ) {
-                        castError( castExpr, "Ill formed virtual cast target type." );
+                }
-                ObjectDecl * type_id = indexer.lookup( type_id_type );
-                delete type_id_type;
-                if ( nullptr == type_id ) {
-                        castError( castExpr, "Virtual cast does not target a virtual type." );
+                }
-                Expression * result = new CastExpr(
-                        new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
-                                cast_to_type_id( new AddressExpr( new VariableExpr( type_id ) ), 1 ),
-                                cast_to_type_id( castExpr->get_arg(), 2 ),
-                        } ),
-                        castExpr->get_result()->clone()
-                );
-                castExpr->set_arg( nullptr );
-                castExpr->set_result( nullptr );
-                delete castExpr;
-                return result;
+        }
 /// Better error locations for generated casts.
 …
 } // namespace
-void expandCasts( std::list< Declaration * > & translationUnit ) {
-        PassVisitor<VirtualCastCore> translator;
-        mutateAll( translationUnit, translator );
+}
 void expandCasts( ast::TranslationUnit & translationUnit ) {
         ast::Pass<ExpandCastsCore>::run( translationUnit );

src/Virtual/Tables.cc

-              r0030b508
+              rfc12f05
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
-#include <SynTree/Attribute.h>
-#include <SynTree/Declaration.h>
-#include <SynTree/Expression.h>
-#include <SynTree/Statement.h>
-#include <SynTree/Type.h>
 namespace Virtual {
 …
         return 17 < name.size() && '_' == name[0] &&
                 std::string("_vtable_instance") == name.substr(1, name.size() - 17);
+}
-static ObjectDecl * makeVtableDeclaration(
-                std::string const & name,
-                StructInstType * type, Initializer * init ) {
-        Type::StorageClasses storage = noStorageClasses;
-        if ( nullptr == init ) {
-                storage.is_extern = true;
+        }
-        return new ObjectDecl(
-                name,
-                storage,
-                LinkageSpec::Cforall,
-                nullptr,
-                type,
-                init
-        );
+}
 …
+}
-ObjectDecl * makeVtableForward( std::string const & name, StructInstType * type ) {
-        assert( type );
-        return makeVtableDeclaration( name, type, nullptr );
+}
 ast::ObjectDecl * makeVtableForward(
                 CodeLocation const & location, std::string const & name,
 …
         assert( vtableType );
         return makeVtableDeclaration( location, name, vtableType, nullptr );
+}
-ObjectDecl * makeVtableInstance(
-                std::string const & name, StructInstType * vtableType,
-                Type * objectType, Initializer * init ) {
-        assert( vtableType );
-        assert( objectType );
-        StructDecl * vtableStruct = vtableType->baseStruct;
-        // Build the initialization
-        if ( nullptr == init ) {
-                std::list< Initializer * > inits;
-                // This is going to have to be run before the resolver to connect expressions.
-                for ( auto field : vtableStruct->members ) {
-                        if ( std::string( "parent" ) == field->name ) {
-                                // This will not work with polymorphic state.
-                                auto oField = strict_dynamic_cast< ObjectDecl * >( field );
-                                auto fieldType = strict_dynamic_cast< PointerType * >( oField->type );
-                                auto parentType = strict_dynamic_cast< StructInstType * >( fieldType->base );
-                                std::string const & parentInstance = instanceName( parentType->name );
-                                inits.push_back(
-                                                new SingleInit( new AddressExpr( new NameExpr( parentInstance ) ) ) );
-                        } else if ( std::string( "__cfavir_typeid" ) == field->name ) {
-                                std::string const & baseType = baseTypeName( vtableType->name );
-                                std::string const & typeId = typeIdName( baseType );
-                                inits.push_back( new SingleInit( new AddressExpr( new NameExpr( typeId ) ) ) );
-                        } else if ( std::string( "size" ) == field->name ) {
-                                inits.push_back( new SingleInit( new SizeofExpr( objectType->clone() ) ) );
-                        } else if ( std::string( "align" ) == field->name ) {
-                                inits.push_back( new SingleInit( new AlignofExpr( objectType->clone() ) ) );
-                        } else {
-                                inits.push_back( new SingleInit( new NameExpr( field->name ) ) );
+                        }
+                }
-                init = new ListInit( inits );
-        // This should initialize everything except the parent pointer, the
-        // size-of and align-of fields. These should be inserted.
-        } else {
-                assert(false);
+        }
-        return makeVtableDeclaration( name, vtableType, init );
+}
 …
+}
-FunctionDecl * makeGetExceptionForward(
-                Type * vtableType, Type * exceptType ) {
-        assert( vtableType );
-        assert( exceptType );
-        FunctionType * type = new FunctionType( noQualifiers, false );
-        vtableType->tq.is_const = true;
-        type->returnVals.push_back( new ObjectDecl(
-                "_retvalue",
-                noStorageClasses,
-                LinkageSpec::Cforall,
-                nullptr,
-                new ReferenceType( noQualifiers, vtableType ),
-                nullptr,
-                { new Attribute("unused") }
-        ) );
-        type->parameters.push_back( new ObjectDecl(
-                "__unused",
-                noStorageClasses,
-                LinkageSpec::Cforall,
-                nullptr,
-                new PointerType( noQualifiers, exceptType ),
-                nullptr,
-                { new Attribute("unused") }
-        ) );
-        return new FunctionDecl(
-                functionName,
-                noStorageClasses,
-                LinkageSpec::Cforall,
-                type,
-                nullptr
-        );
+}
 ast::FunctionDecl * makeGetExceptionForward(
                 CodeLocation const & location,
 …
+}
-FunctionDecl * makeGetExceptionFunction(
-                ObjectDecl * vtableInstance, Type * exceptType ) {
-        assert( vtableInstance );
-        assert( exceptType );
-        FunctionDecl * func = makeGetExceptionForward(
-                vtableInstance->type->clone(), exceptType );
-        func->statements = new CompoundStmt( {
-                new ReturnStmt( new VariableExpr( vtableInstance ) ),
-        } );
-        return func;
+}
 ast::FunctionDecl * makeGetExceptionFunction(
                 CodeLocation const & location,
 …
         } );
         return func;
+}
-ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType ) {
-        assert( typeIdType );
-        StructInstType * type = typeIdType->clone();
-        type->tq.is_const = true;
-        std::string const & typeid_name = typeIdTypeToInstance( typeIdType->name );
-        return new ObjectDecl(
-                typeid_name,
-                noStorageClasses,
-                LinkageSpec::Cforall,
-                /* bitfieldWidth */ nullptr,
-                type,
-                new ListInit( { new SingleInit(
-                        new AddressExpr( new NameExpr( "__cfatid_exception_t" ) )
-                        ) } ),
-                { new Attribute( "cfa_linkonce", {} ) },
-                noFuncSpecifiers
-        );
+}

src/Virtual/Tables.h

-              r0030b508
+              rfc12f05
 #include <string>
 #include "AST/Fwd.hpp"
-class Declaration;
-class Expression;
-class FunctionDecl;
-class Initializer;
-class ObjectDecl;
-class StructDecl;
-class StructInstType;
-class Type;
 namespace Virtual {
 …
 bool isVTableInstanceName( std::string const & name );
-ObjectDecl * makeVtableForward(
-        std::string const & name, StructInstType * vtableType );
 /* Create a forward declaration of a vtable of the given type.
  * vtableType node is consumed.
 …
         ast::StructInstType const * vtableType );
-ObjectDecl * makeVtableInstance(
-        std::string const & name,
-        StructInstType * vtableType, Type * objectType,
-        Initializer * init = nullptr );
 /* Create an initialized definition of a vtable.
  * vtableType and init (if provided) nodes are consumed.
 …
 // Some special code for how exceptions interact with virtual tables.
+FunctionDecl * makeGetExceptionForward( Type * vtableType, Type * exceptType );
 /* Create a forward declaration of the exception virtual function
  * linking the vtableType to the exceptType. Both nodes are consumed.
 …
         ast::Type const * exceptType );
-FunctionDecl * makeGetExceptionFunction(
-        ObjectDecl * vtableInstance, Type * exceptType );
 /* Create the definition of the exception virtual function.
  * exceptType node is consumed.
 …
         ast::ObjectDecl const * vtableInstance, ast::Type const * exceptType );
-ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType );
 /* Build an instance of the type-id from the type of the type-id.
  * TODO: Should take the parent type. Currently locked to the exception_t.

src/main.cc

-              r0030b508
+              rfc12f05
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Sep 28 22:28:45 2023
 // Update Count     : 687
+// Last Modified On : Wed Nov  1 21:12:58 2023
+// Update Count     : 690
 //
 …
 #include <string>                           // for char_traits, operator<<
-#include "AST/Convert.hpp"
 #include "AST/Pass.hpp"                     // for pass_visitor_stats
+#include "AST/Print.hpp"                    // for printAll
 #include "AST/TranslationUnit.hpp"          // for TranslationUnit
 #include "AST/Util.hpp"                     // for checkInvariants
 …
 #include "CodeGen/Generate.h"               // for generate
 #include "CodeGen/LinkOnce.h"               // for translateLinkOnce
-#include "CodeTools/TrackLoc.h"             // for fillLocations
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
 #include "Common/DeclStats.hpp"             // for printDeclStats
 …
 #include "ResolvExpr/EraseWith.hpp"         // for eraseWith
 #include "ResolvExpr/Resolver.h"            // for resolve
-#include "SynTree/LinkageSpec.h"            // for Spec, Cforall, Intrinsic
-#include "SynTree/Declaration.h"            // for Declaration
 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
 #include "Validate/Autogen.hpp"             // for autogenerateRoutines
 …
         using namespace Stats::Counters;
+        {
                 static auto group = build<CounterGroup>( "Pass Visitor" );
+                static auto group = build<CounterGroup>( "Pass Visitor Template" );
                 auto pass = build<CounterGroup>( name, group );
+                pass_visitor_stats.depth = 0;
+                pass_visitor_stats.avg = build<AverageCounter<double>>( "Average Depth", pass );
+                pass_visitor_stats.max = build<MaxCounter<double>>( "Max Depth", pass );
+        }
+        {
+                static auto group = build<CounterGroup>( "Syntax Node" );
+                auto pass = build<CounterGroup>( name, group );
+                BaseSyntaxNode::new_nodes = build<SimpleCounter>( "Allocs", pass );
+                ast::pass_visitor_stats.depth = 0;
+                ast::pass_visitor_stats.avg = build<AverageCounter<double>>( "Average Depth", pass );
+                ast::pass_visitor_stats.max = build<MaxCounter<double>>( "Max Depth", pass );
+        }
+}
 …
 static void parse_cmdline( int argc, char * argv[] );
-static void dump( list< Declaration * > & translationUnit, ostream & out = cout );
 static void dump( ast::TranslationUnit && transUnit, ostream & out = cout );
 …
         FILE * input;                                                                           // use FILE rather than istream because yyin is FILE
         ostream * output = & cout;
-        list< Declaration * > translationUnit;
         ast::TranslationUnit transUnit;
 …
         parse_cmdline( argc, argv );                                            // process command-line arguments
-        CodeGen::FixMain::setReplaceMain( !nomainp );
         if ( waiting_for_gdb ) {
 …
                         // Read to gcc builtins, if not generating the cfa library
                         FILE * gcc_builtins = fopen( (PreludeDirector + "/gcc-builtins.cf").c_str(), "r" );
+                        FILE * gcc_builtins = fopen( (PreludeDirector + "/gcc-builtins.cfa").c_str(), "r" );
                         assertf( gcc_builtins, "cannot open gcc-builtins.cf\n" );
                         parse( gcc_builtins, ast::Linkage::Compiler );
                         // read the extra prelude in, if not generating the cfa library
                         FILE * extras = fopen( (PreludeDirector + "/extras.cf").c_str(), "r" );
+                        FILE * extras = fopen( (PreludeDirector + "/extras.cfa").c_str(), "r" );
                         assertf( extras, "cannot open extras.cf\n" );
                         parse( extras, ast::Linkage::BuiltinC );
 …
                                 // Read to cfa builtins, if not generating the cfa library
                                 FILE * builtins = fopen( (PreludeDirector + "/builtins.cf").c_str(), "r" );
+                                FILE * builtins = fopen( (PreludeDirector + "/builtins.cfa").c_str(), "r" );
                                 assertf( builtins, "cannot open builtins.cf\n" );
                                 parse( builtins, ast::Linkage::BuiltinCFA );
 …
                 Stats::Time::StopBlock();
-                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( "Hoist Type Decls", Validate::hoistTypeDecls, transUnit );
 …
                 PASS( "Translate Tries", ControlStruct::translateTries, transUnit );
                 PASS( "Gen Waitfor", Concurrency::generateWaitFor, transUnit );
+                PASS( "Fix Main Linkage", CodeGen::fixMainLinkage, transUnit, !nomainp );
                 // Needs to happen before tuple types are expanded.
 …
                 PASS( "Link-Once", CodeGen::translateLinkOnce, transUnit );
-                translationUnit = convert( std::move( transUnit ) );
                 // Code has been lowered to C, now we can start generation.
                 DUMP( bcodegenp, translationUnit );
+                DUMP( bcodegenp, std::move( transUnit ) );
                 if ( optind < argc ) {                                                  // any commands after the flags and input file ? => output file name
 …
                 } // if
+                CodeTools::fillLocations( translationUnit );
+                PASS( "Code Gen", CodeGen::generate, translationUnit, *output, ! genproto, prettycodegenp, true, linemarks );
+                CodeGen::FixMain::fix( translationUnit, *output,
+                                (PreludeDirector + "/bootloader.c").c_str() );
+                PASS( "Code Gen", CodeGen::generate, transUnit, *output, !genproto, prettycodegenp, true, linemarks, false );
+                CodeGen::fixMainInvoke( transUnit, *output, (PreludeDirector + "/bootloader.c").c_str() );
                 if ( output != &cout ) {
                         delete output;
 …
                 if ( errorp ) {
                         cerr << "---AST at error:---" << endl;
+                        // We check which section the errors came from without looking at
+                        // transUnit because std::move means it could look like anything.
+                        if ( !translationUnit.empty() ) {
+                                dump( translationUnit, cerr );
+                        } else {
+                                dump( std::move( transUnit ), cerr );
+                        }
+                        dump( std::move( transUnit ), cerr );
                         cerr << endl << "---End of AST, begin error message:---\n" << endl;
                 } // if
 …
         } // try
-        deleteAll( translationUnit );
         Stats::print();
         return EXIT_SUCCESS;
 …
 } // parse_cmdline
+static bool notPrelude( Declaration * decl ) {
+        return ! LinkageSpec::isBuiltin( decl->get_linkage() );
+} // notPrelude
+static void dump( list< Declaration * > & translationUnit, ostream & out ) {
+        list< Declaration * > decls;
+static bool notPrelude( ast::ptr<ast::Decl> & decl ) {
+        return !decl->linkage.is_builtin;
+}
+static void dump( ast::TranslationUnit && unit, std::ostream & out ) {
+        // May filter out all prelude declarations.
         if ( genproto ) {
+                filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), notPrelude );
+                std::list<ast::ptr<ast::Decl>> decls;
+                std::copy_if( unit.decls.begin(), unit.decls.end(),
+                        std::back_inserter( decls ), notPrelude );
+                decls.swap( unit.decls );
+        }
+        // May print as full dump or as code generation.
+        if ( codegenp ) {
+                CodeGen::generate( unit, out, !genproto, prettycodegenp, false, false, false );
         } else {
+                decls = translationUnit;
+        } // if
+        // depending on commandline options, either generate code or dump the AST
+        if ( codegenp ) {
+                CodeGen::generate( decls, out, ! genproto, prettycodegenp );
+        } else {
+                printAll( decls, out );
+        } // if
+        deleteAll( translationUnit );
+} // dump
+static void dump( ast::TranslationUnit && transUnit, ostream & out ) {
+        std::list< Declaration * > translationUnit = convert( std::move( transUnit ) );
+        dump( translationUnit, out );
+                ast::printAll( out, unit.decls );
+        }
+}

Context Navigation

Legend:

Download in other formats: