Changeset c532847

Timestamp:

Oct 24, 2020, 9:42:38 AM (4 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

a3f36dc

Parents:

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

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Convert.cpp (modified) (19 diffs)
• AST/Decl.cpp (modified) (1 diff)
• AST/Decl.hpp (modified) (1 diff)
• AST/DeclReplacer.cpp (modified) (3 diffs)
• AST/DeclReplacer.hpp (modified) (1 diff)
• AST/Expr.cpp (modified) (2 diffs)
• AST/Expr.hpp (modified) (4 diffs)
• AST/Fwd.hpp (modified) (1 diff)
• AST/Node.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (2 diffs)
• AST/Pass.impl.hpp (modified) (6 diffs)
• AST/SymbolTable.cpp (modified) (1 diff)
• AST/SymbolTable.hpp (modified) (1 diff)
• Common/utility.h (modified) (1 diff)
• GenPoly/GenPoly.cc (modified) (9 diffs)
• GenPoly/GenPoly.h (modified) (4 diffs)
• InitTweak/FixGlobalInit.cc (modified) (4 diffs)
• InitTweak/FixGlobalInit.h (modified) (2 diffs)
• InitTweak/FixInit.cc (modified) (1 diff)
• InitTweak/FixInit.h (modified) (2 diffs)
• InitTweak/FixInitNew.cpp (added)
• InitTweak/GenInit.cc (modified) (1 diff)
• InitTweak/GenInit.h (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (6 diffs)
• InitTweak/InitTweak.h (modified) (3 diffs)
• InitTweak/module.mk (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (5 diffs)
• ResolvExpr/Resolver.h (modified) (1 diff)
• SymTab/Autogen.cc (modified) (2 diffs)
• SymTab/Autogen.h (modified) (1 diff)
• main.cc (modified) (1 diff)

src/AST/Convert.cpp

@@ -47 +47 @@
 
 //================================================================================================
-namespace {
+namespace ast {
 
 // This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
 // allow us to use the same stratagy in the new ast.
+// xxx - since convert back pass works, this concern seems to be unnecessary.
+
+// these need to be accessed in new FixInit now
 ast::Type * sizeType = nullptr;
 ast::FunctionDecl * dereferenceOperator = nullptr;
@@ -63 +66 @@
         using Cache = std::unordered_map< const ast::Node *, BaseSyntaxNode * >;
         Cache cache;
+
+        // Statements can no longer be shared.
+        // however, since StmtExprResult is now implemented, need to still maintain
+        // readonly references.
+        Cache readonlyCache;
 
         template<typename T>
@@ -154 +162 @@
         }
 
-        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
-                auto&& bfwd = get<Expression>().accept1( node->bitfieldWidth );
-                auto&& type = get<Type>().accept1( node->type );
-                auto&& init = get<Initializer>().accept1( node->init );
-                auto&& attr = get<Attribute>().acceptL( node->attributes );
+        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {        
                 if ( inCache( node ) ) {
                         return nullptr;
                 }
+                auto bfwd = get<Expression>().accept1( node->bitfieldWidth );
+                auto type = get<Type>().accept1( node->type );
+                auto attr = get<Attribute>().acceptL( node->attributes );
+
                 auto decl = new ObjectDecl(
                         node->name,
@@ -168 +176 @@
                         bfwd,
                         type->clone(),
-                        init,
+                        nullptr, // prevent infinite loop
                         attr,
                         Type::FuncSpecifiers( node->funcSpec.val )
                 );
-                return declWithTypePostamble( decl, node );
+
+                // handles the case where node->init references itself
+                // xxx - does it really happen?
+                declWithTypePostamble(decl, node);
+                auto init = get<Initializer>().accept1( node->init );
+                decl->init = init;
+                
+                this->node = decl;
+                return nullptr;
         }
 
@@ -205 +221 @@
                 decl->statements = get<CompoundStmt>().accept1( node->stmts );
                 decl->withExprs = get<Expression>().acceptL( node->withExprs );
-                if ( dereferenceOperator == node ) {
+                if ( ast::dereferenceOperator == node ) {
                         Validate::dereferenceOperator = decl;
                 }
-                if ( dtorStructDestroy == node ) {
+                if ( ast::dtorStructDestroy == node ) {
                         Validate::dtorStructDestroy = decl;
                 }
@@ -267 +283 @@
                 );
 
-                if ( dtorStruct == node ) {
+                if ( ast::dtorStruct == node ) {
                         Validate::dtorStruct = decl;
                 }
@@ -320 +336 @@
 
         const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
-                cache.emplace( node, stmt );
+                // force statements in old tree to be unique.
+                // cache.emplace( node, stmt );
+                readonlyCache.emplace( node, stmt );
                 stmt->location = node->location;
                 stmt->labels = makeLabelL( stmt, node->labels );
@@ -337 +355 @@
                 if ( inCache( node ) ) return nullptr;
                 auto stmt = new ExprStmt( nullptr );
-                cache.emplace( node, stmt );
                 stmt->expr = get<Expression>().accept1( node->expr );
                 return stmtPostamble( stmt, node );
@@ -1011 +1028 @@
                 auto stmts = node->stmts;
                 // disable sharing between multiple StmtExprs explicitly.
-                if (inCache(stmts)) {
-                        stmts = ast::deepCopy(stmts.get());
-                }
+                // this should no longer be true.
+
                 auto rslt = new StmtExpr(
                         get<CompoundStmt>().accept1(stmts)
@@ -1020 +1036 @@
                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
                 rslt->dtors       = get<Expression>().acceptL(node->dtors);
+                if (node->resultExpr) {
+                        // this MUST be found by children visit
+                        rslt->resultExpr  = strict_dynamic_cast<ExprStmt *>(readonlyCache.at(node->resultExpr));
+                }
 
                 auto expr = visitBaseExpr( node, rslt );
@@ -1036 +1056 @@
 
                 auto expr = visitBaseExpr( node, rslt );
-                this->node = expr;
+                this->node = expr->clone();
                 return nullptr;
         }
@@ -1126 +1146 @@
                 auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
                 // I believe this should always be a BasicType.
-                if ( sizeType == node ) {
+                if ( ast::sizeType == node ) {
                         Validate::SizeType = type;
                 }
@@ -1529 +1549 @@
 
                 // function type is now derived from parameter decls instead of storing them
+
+                /*
                 auto ftype = new ast::FunctionType((ast::ArgumentFlag)old->type->isVarArgs, cv(old->type));
                 ftype->params.reserve(paramVars.size());
@@ -1540 +1562 @@
                 }
                 ftype->forall = std::move(forall);
-                visitType(old->type, ftype);
+                */
+
+                // can function type have attributes? seems not to be the case.
+                // visitType(old->type, ftype);
 
                 auto decl = new ast::FunctionDecl{
@@ -1546 +1571 @@
                         old->name,
                         // GET_ACCEPT_1(type, FunctionType),
+                        std::move(forall),
                         std::move(paramVars),
                         std::move(returnVars),
@@ -1552 +1578 @@
                         { old->linkage.val },
                         GET_ACCEPT_V(attributes, Attribute),
-                        { old->get_funcSpec().val }
+                        { old->get_funcSpec().val },
+                        old->type->isVarArgs
                 };
 
-                decl->type = ftype;
+                // decl->type = ftype;
                 cache.emplace( old, decl );
 
@@ -1570 +1597 @@
 
                 if ( Validate::dereferenceOperator == old ) {
-                        dereferenceOperator = decl;
+                        ast::dereferenceOperator = decl;
                 }
 
                 if ( Validate::dtorStructDestroy == old ) {
-                        dtorStructDestroy = decl;
+                        ast::dtorStructDestroy = decl;
                 }
         }
@@ -1599 +1626 @@
 
                 if ( Validate::dtorStruct == old ) {
-                        dtorStruct = decl;
+                        ast::dtorStruct = decl;
                 }
         }
@@ -2531 +2558 @@
                 // I believe this should always be a BasicType.
                 if ( Validate::SizeType == old ) {
-                        sizeType = type;
+                        ast::sizeType = type;
                 }
                 visitType( old, type );

src/AST/Decl.cpp

@@ -48 +48 @@
 
 // --- FunctionDecl
+
+FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name, 
+                std::vector<ptr<TypeDecl>>&& forall,
+                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+                CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
+                std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+          stmts( stmts ) {
+                  FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+                  for (auto & param : this->params) {
+                          ftype->params.emplace_back(param->get_type());
+                  }
+                  for (auto & ret : this->returns) {
+                          ftype->returns.emplace_back(ret->get_type());
+                  }
+                  ftype->forall = std::move(forall);
+                  this->type = ftype;
+          }
+
 
 const Type * FunctionDecl::get_type() const { return type.get(); }

src/AST/Decl.hpp

@@ -131 +131 @@
         std::vector< ptr<Expr> > withExprs;
 
-        FunctionDecl( const CodeLocation & loc, const std::string & name, 
+        FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
-        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
-          stmts( stmts ) {}
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+        // : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+        //  stmts( stmts ) {}
 
         const Type * get_type() const override;

src/AST/DeclReplacer.cpp

@@ -38 +38 @@
                         const ast::TypeInstType * previsit( const ast::TypeInstType * );
                 };
+
+                struct VarExprReplacer {
+                private:
+                        const ExprMap & exprMap;
+                        
+                public:
+                        VarExprReplacer(const ExprMap & exprMap): exprMap (exprMap) {}
+
+                        const Expr * postvisit (const VariableExpr *);
+                };
         }
 
@@ -54 +64 @@
                 DeclMap declMap;
                 return replace( node, declMap, typeMap, debug );
+        }
+
+        const ast::Node * replace( const ast::Node * node, const ExprMap & exprMap) {
+                Pass<VarExprReplacer> replacer = {exprMap};
+                return node->accept( replacer );
         }
 
@@ -88 +103 @@
                         return ninst;
                 }
+
+                const Expr * VarExprReplacer::postvisit( const VariableExpr * expr ) {
+                        if (!exprMap.count(expr->var)) return expr;
+
+                        return exprMap.at(expr->var);
+                }
+
         }
 }

src/AST/DeclReplacer.hpp

@@ -23 +23 @@
         class DeclWithType;
         class TypeDecl;
+        class Expr;
 
         namespace DeclReplacer {
                 using DeclMap = std::unordered_map< const DeclWithType *, const DeclWithType * >;
                 using TypeMap = std::unordered_map< const TypeDecl *, const TypeDecl * >;
+                using ExprMap = std::unordered_map< const DeclWithType *, const Expr * >;
 
                 const Node * replace( const Node * node, const DeclMap & declMap, bool debug = false );
                 const Node * replace( const Node * node, const TypeMap & typeMap, bool debug = false );
                 const Node * replace( const Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
+                const Node * replace( const Node * node, const ExprMap & exprMap);
         }
 }

src/AST/Expr.cpp

@@ -67 +67 @@
 // --- UntypedExpr
 
-UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, Expr * arg ) {
+UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, const Expr * arg ) {
         assert( arg );
 
@@ -92 +92 @@
 }
 
-UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs ) {
+UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs ) {
         assert( lhs && rhs );
 

src/AST/Expr.hpp

@@ -226 +226 @@
 
         /// Creates a new dereference expression
-        static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
+        static UntypedExpr * createDeref( const CodeLocation & loc, const Expr * arg );
         /// Creates a new assignment expression
-        static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs );
+        static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -422 +422 @@
                 const CodeLocation & loc, const Type * ty, const std::string & r,
                         std::optional<unsigned long long> i )
-        : Expr( loc, ty ), rep( r ), ival( i ) {}
+        : Expr( loc, ty ), rep( r ), ival( i ), underlyer(ty) {}
 
         /// Gets the integer value of this constant, if one is appropriate to its type.
@@ -617 +617 @@
 
         ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
-        : Expr( loc, call->result ) { assert( call ); }
+        : Expr( loc, call->result ), callExpr(call) { assert( call ); assert(call->result); }
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -742 +742 @@
         std::vector<ptr<Expr>> dtors;              ///< destructor(s) for return variable(s)
 
+        readonly<ExprStmt> resultExpr;
+
         StmtExpr( const CodeLocation & loc, const CompoundStmt * ss );
 

src/AST/Fwd.hpp

@@ -137 +137 @@
 typedef unsigned int UniqueId;
 
+extern Type * sizeType;
+extern FunctionDecl * dereferenceOperator;
+extern StructDecl   * dtorStruct;
+extern FunctionDecl * dtorStructDestroy;
+
 }

src/AST/Node.hpp

@@ -49 +49 @@
 
         bool unique() const { return strong_count == 1; }
+        bool isManaged() const {return strong_count > 0; }
 
 private:

src/AST/Pass.hpp

@@ -236 +236 @@
         const ast::Expr * call_accept( const ast::Expr * );
 
+        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
+
+        const ast::Stmt * call_accept_as_compound(const ast::Stmt *);
+
         template< typename node_t >
         auto call_accept( const node_t * node ) -> typename std::enable_if<
@@ -257 +261 @@
         template<typename node_t, typename parent_t, typename child_t>
         void maybe_accept(const node_t * &, child_t parent_t::* child);
+
+        template<typename node_t, typename parent_t, typename child_t>
+        void maybe_accept_as_compound(const node_t * &, child_t parent_t::* child);
 
 private:

src/AST/Pass.impl.hpp

@@ -167 +167 @@
                 __pedantic_pass_assert( stmt );
 
+                return stmt->accept( *this );
+        }
+
+        template< typename core_t >
+        const ast::Stmt * ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
+                __pedantic_pass_assert( __visit_children() );
+                __pedantic_pass_assert( stmt );
+
                 // add a few useful symbols to the scope
                 using __pass::empty;
@@ -324 +332 @@
 
                 auto new_val = call_accept( old_val );
+
+                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
+
+                if( __pass::differs(old_val, new_val) ) {
+                        auto new_parent = __pass::mutate<core_t>(parent);
+                        new_parent->*child = new_val;
+                        parent = new_parent;
+                }
+        }
+
+        template< typename core_t >
+        template<typename node_t, typename parent_t, typename child_t>
+        void ast::Pass< core_t >::maybe_accept_as_compound(
+                const node_t * & parent,
+                child_t parent_t::*child
+        ) {
+                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
+
+                if(__pass::skip(parent->*child)) return;
+                const auto & old_val = __pass::get(parent->*child, 0);
+
+                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
+
+                auto new_val = call_accept_as_compound( old_val );
 
                 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
@@ -703 +735 @@
                 maybe_accept( node, &IfStmt::inits    );
                 maybe_accept( node, &IfStmt::cond     );
-                maybe_accept( node, &IfStmt::thenPart );
-                maybe_accept( node, &IfStmt::elsePart );
+                maybe_accept_as_compound( node, &IfStmt::thenPart );
+                maybe_accept_as_compound( node, &IfStmt::elsePart );
         })
 
@@ -721 +753 @@
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
-                maybe_accept( node, &WhileStmt::body  );
+                maybe_accept_as_compound( node, &WhileStmt::body  );
         })
 
@@ -736 +768 @@
                 // for statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
+                // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
                 maybe_accept( node, &ForStmt::inits );
                 maybe_accept( node, &ForStmt::cond  );
                 maybe_accept( node, &ForStmt::inc   );
-                maybe_accept( node, &ForStmt::body  );
+                maybe_accept_as_compound( node, &ForStmt::body  );
         })
 
@@ -834 +867 @@
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
-                maybe_accept( node, &CatchStmt::body );
+                maybe_accept_as_compound( node, &CatchStmt::body );
         })
 

src/AST/SymbolTable.cpp

@@ -335 +335 @@
 }
 
-/*
-void SymbolTable::addFunctionType( const FunctionType * ftype ) {
-        addTypes( ftype->forall );
-        addIds( ftype->returns );
-        addIds( ftype->params );
-}
-*/
+
+void SymbolTable::addFunction( const FunctionDecl * func ) {
+        addTypes( func->type->forall );
+        addIds( func->returns );
+        addIds( func->params );
+}
+
 
 void SymbolTable::lazyInitScope() {

src/AST/SymbolTable.hpp

@@ -145 +145 @@
 
         /// convenience function for adding all of the declarations in a function type to the indexer
-        // void addFunctionType( const FunctionType * ftype );
+        void addFunction( const FunctionDecl * );
 
 private:

src/Common/utility.h

@@ -360 +360 @@
         reverse_iterate_t( T & ref ) : ref(ref) {}
 
-        typedef typename T::reverse_iterator iterator;
-        iterator begin() { return ref.rbegin(); }
-        iterator end() { return ref.rend(); }
+        // this does NOT work on const T!!!
+        // typedef typename T::reverse_iterator iterator;
+        auto begin() { return ref.rbegin(); }
+        auto end() { return ref.rend(); }
 };
 

src/GenPoly/GenPoly.cc

@@ -46 +46 @@
                 }
 
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env) {
+                        for (auto &param : params) {
+                                auto paramType = param.strict_as<ast::TypeExpr>();
+                                if (isPolyType(paramType->type, env)) return true;
+                        }
+                        return false;
+                }
+
                 /// 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 ) {
@@ -56 +64 @@
                 }
 
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
+                        for (auto &param : params) {
+                                auto paramType = param.strict_as<ast::TypeExpr>();
+                                if (isPolyType(paramType->type, tyVars, env)) return true;
+                        }
+                        return false;
+                }
+
                 /// 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 ) {
@@ -92 +108 @@
                         Type *newType = env->lookup( typeInst->get_name() );
                         if ( newType ) return newType;
+                }
+                return type;
+        }
+
+        const ast::Type * replaceTypeInst(const ast::Type * type, const ast::TypeSubstitution * env) {
+                if (!env) return type;
+                if (auto typeInst = dynamic_cast<const ast::TypeInstType*> (type)) {
+                        auto newType = env->lookup(typeInst->name);
+                        if (newType) return newType;
                 }
                 return type;
@@ -111 +136 @@
         }
 
+        const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env) {
+                type = replaceTypeInst( type, env );
+
+                if ( dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                        return type;
+                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        return isPolyType( arrayType->base, env );
+                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->params, env ) ) return type;
+                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->params, env ) ) return type;
+                }
+                return 0;
+        }
+
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 type = replaceTypeInst( type, env );
@@ -126 +166 @@
                 }
                 return 0;
+        }
+
+        const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
+                type = replaceTypeInst( type, env );
+
+                if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                        return tyVars.find(typeInst->name) != tyVars.end() ? type : nullptr;
+                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        return isPolyType( arrayType->base, env );
+                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->params, env ) ) return type;
+                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->params, env ) ) return type;
+                }
+                return nullptr;
         }
 
@@ -449 +504 @@
         }
 
+        namespace {
+                // temporary hack to avoid re-implementing anything related to TyVarMap
+                // does this work? these two structs have identical definitions.
+                inline TypeDecl::Data convData(const ast::TypeDecl::Data & data) {
+                        return *reinterpret_cast<const TypeDecl::Data *>(&data);
+                }
+        }
+
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
                 // is parameter is not polymorphic, don't need to box
@@ -459 +522 @@
         }
 
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env) {
+                // is parameter is not polymorphic, don't need to box
+                if ( ! isPolyType( param, exprTyVars ) ) return false;
+                ast::ptr<ast::Type> newType = arg;
+                if ( env ) env->apply( newType );
+                // if the argument's type is polymorphic, we don't need to box again!
+                return ! isPolyType( newType );
+        }
+
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
                 FunctionType * function = getFunctionType( appExpr->function->result );
@@ -467 +539 @@
         }
 
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env) {
+                const ast::FunctionType * function = getFunctionType(appExpr->func->result);
+                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->func->result ).c_str() );
+                TyVarMap exprTyVars(TypeDecl::Data{});
+                makeTyVarMap(function, exprTyVars);
+                return needsBoxing(param, arg, exprTyVars, env);
+
+        }
+
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
                 tyVarMap.insert( tyVar->name, TypeDecl::Data{ tyVar } );
+        }
+
+        void addToTyVarMap( const ast::TypeDecl * tyVar, TyVarMap & tyVarMap) {
+                tyVarMap.insert(tyVar->name, convData(ast::TypeDecl::Data{tyVar}));
         }
 
@@ -478 +563 @@
                 if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
                         makeTyVarMap( pointer->get_base(), tyVarMap );
+                }
+        }
+
+        void makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap) {
+                if (auto ptype = dynamic_cast<const ast::ParameterizedType *>(type)) {
+                        for (auto & tyVar : ptype->forall) {
+                                assert (tyVar);
+                                addToTyVarMap(tyVar, tyVarMap);
+                        }
+                }
+                if (auto pointer = dynamic_cast<const ast::PointerType *>(type)) {
+                        makeTyVarMap(pointer->base, tyVarMap);
                 }
         }

src/GenPoly/GenPoly.h

@@ -26 +26 @@
 
 namespace GenPoly {
+
         typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
-
         /// Replaces a TypeInstType by its referrent in the environment, if applicable
         Type* replaceTypeInst( Type* type, const TypeSubstitution* env );
@@ -33 +33 @@
         /// 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 TyVarMap & tyVars, const ast::TypeSubstitution * env = nullptr);
 
         /// returns dynamic-layout type if is dynamic-layout type in tyVars, NULL otherwise; will look up substitution in env if provided
@@ -84 +86 @@
         /// 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 TyVarMap &exprTyVars, const ast::TypeSubstitution * env);
 
         /// 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 * appExpr, const ast::TypeSubstitution * env);
 
         /// Adds the type variable `tyVar` to `tyVarMap`
@@ -93 +97 @@
         /// 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 makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap);
 
         /// Prints type variable map

src/InitTweak/FixGlobalInit.cc

@@ -34 +34 @@
 #include "SynTree/Visitor.h"       // for acceptAll, Visitor
 
+#include "AST/Expr.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+
 namespace InitTweak {
         class GlobalFixer : public WithShortCircuiting {
@@ -50 +54 @@
                 FunctionDecl * initFunction;
                 FunctionDecl * destroyFunction;
+        };
+
+        class GlobalFixer_new : public ast::WithShortCircuiting {
+        public:
+                void previsit (const ast::ObjectDecl *);
+                void previsit (const ast::FunctionDecl *) { visit_children = false; }
+                void previsit (const ast::StructDecl *) { visit_children = false; }
+                void previsit (const ast::UnionDecl *) { visit_children = false; }
+                void previsit (const ast::EnumDecl *) { visit_children = false; }
+                void previsit (const ast::TraitDecl *) { visit_children = false; }
+                void previsit (const ast::TypeDecl *) { visit_children = false; }
+
+                std::list< ast::ptr<ast::Stmt> > initStmts;
+                std::list< ast::ptr<ast::Stmt> > destroyStmts;
         };
 
@@ -91 +109 @@
         }
 
+        void fixGlobalInit(std::list<ast::ptr<ast::Decl>> & translationUnit, bool inLibrary) {
+                ast::Pass<GlobalFixer_new> fixer;
+                accept_all(translationUnit, fixer);
+
+                if ( !fixer.core.initStmts.empty() ) {
+                        std::vector<ast::ptr<ast::Expr>> ctorParams;
+                        if (inLibrary) ctorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
+                        auto initFunction = new ast::FunctionDecl({}, "__global_init__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.initStmts)), 
+                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("constructor", std::move(ctorParams))});
+
+                        translationUnit.emplace_back( initFunction );
+                } // if
+
+                if ( !fixer.core.destroyStmts.empty() ) {
+                        std::vector<ast::ptr<ast::Expr>> dtorParams;
+                        if (inLibrary) dtorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
+                        auto destroyFunction = new ast::FunctionDecl({}, "__global_destroy__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.destroyStmts)), 
+                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("destructor", std::move(dtorParams))});
+
+                        translationUnit.emplace_back(destroyFunction);
+                } // if
+        }
+
         void GlobalFixer::previsit( ObjectDecl *objDecl ) {
                 std::list< Statement * > & initStatements = initFunction->get_statements()->get_kids();
@@ -127 +168 @@
         }
 
+        void GlobalFixer_new::previsit(const ast::ObjectDecl * objDecl) {
+                auto mutDecl = mutate(objDecl);
+                assertf(mutDecl == objDecl, "Global object decl must be unique");
+                if ( auto ctorInit = objDecl->init.as<ast::ConstructorInit>() ) {
+                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
+                        assert( ! ctorInit->ctor || ! ctorInit->init );
+
+                        const ast::Stmt * 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
+                                destroyStmts.push_front( dtor );
+                                // ctorInit->dtor = nullptr;
+                        } // if
+                        if ( const ast::Stmt * ctor = ctorInit->ctor ) {
+                                initStmts.push_back( ctor );
+                                mutDecl->init = nullptr;
+                                // ctorInit->ctor = nullptr;
+                        } else if ( const ast::Init * init = ctorInit->init ) {
+                                mutDecl->init = init;
+                                // ctorInit->init = nullptr;
+                        } else {
+                                // no constructor and no initializer, which is okay
+                                mutDecl->init = nullptr;
+                        } // if
+                        // delete ctorInit;
+                } // if
+        }
+
         // only modify global variables
         void GlobalFixer::previsit( FunctionDecl * ) { visit_children = false; }

src/InitTweak/FixGlobalInit.h

@@ -19 +19 @@
 #include <string>  // for string
 
+#include <AST/Fwd.hpp>
+
+
 class Declaration;
 
@@ -26 +29 @@
         /// function is for library code.
         void fixGlobalInit( std::list< Declaration * > & translationUnit, bool inLibrary );
+        void fixGlobalInit( std::list< ast::ptr<ast::Decl> > & translationUnit, bool inLibrary );
 } // namespace
 

src/InitTweak/FixInit.cc

@@ -219 +219 @@
                 };
 
-                struct SplitExpressions : public WithShortCircuiting, public WithTypeSubstitution, public WithStmtsToAdd {
+                struct SplitExpressions : public WithShortCircuiting, /*public WithTypeSubstitution, */public WithStmtsToAdd {
                         /// add CompoundStmts around top-level expressions so that temporaries are destroyed in the correct places.
                         static void split( std::list< Declaration * > &translationUnit );

src/InitTweak/FixInit.h

@@ -19 +19 @@
 #include <string>  // for string
 
+#include <AST/Fwd.hpp>
+
 class Declaration;
 
@@ -24 +26 @@
         /// replace constructor initializers with expression statements and unwrap basic C-style initializers
         void fix( std::list< Declaration * > & translationUnit, bool inLibrary );
+
+        void fix( std::list<ast::ptr<ast::Decl>> & translationUnit, bool inLibrary);
 } // namespace
 

src/InitTweak/GenInit.cc

@@ -283 +283 @@
                 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);
         }
 

src/InitTweak/GenInit.h

@@ -33 +33 @@
         /// 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

src/InitTweak/InitTweak.cc

@@ -498 +498 @@
         }
 
+        const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func) {
+                assertf( func, "getParamThis: nullptr ftype" );
+                auto & params = func->params;
+                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 );
@@ -511 +518 @@
         }
 
+        bool tryConstruct( const ast::DeclWithType * dwt ) {
+                auto objDecl = dynamic_cast< const ast::ObjectDecl * >( dwt );
+                if ( ! objDecl ) return false;
+                return (objDecl->init == nullptr ||
+                                ( objDecl->init != nullptr && objDecl->init->maybeConstructed ))
+                        && ! objDecl->storage.is_extern
+                        && isConstructable( objDecl->type );
+        }
+
+        bool isConstructable( const ast::Type * type ) {
+                return ! dynamic_cast< const ast::VarArgsType * >( type ) && ! dynamic_cast< const ast::ReferenceType * >( type ) 
+                && ! dynamic_cast< const ast::FunctionType * >( type ) && ! Tuples::isTtype( type );
+        }
+
         struct CallFinder_old {
                 CallFinder_old( const std::list< std::string > & names ) : names( names ) {}
@@ -536 +557 @@
 
         struct CallFinder_new final {
-                std::vector< ast::ptr< ast::Expr > > matches;
+                std::vector< const ast::Expr * > matches;
                 const std::vector< std::string > names;
 
@@ -558 +579 @@
         }
 
-        std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt ) {
+        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt ) {
                 ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
                 maybe_accept( stmt, finder );
@@ -696 +717 @@
                 template <typename Predicate>
                 bool allofCtorDtor( const ast::Stmt * stmt, const Predicate & pred ) {
-                        std::vector< ast::ptr< ast::Expr > > callExprs = collectCtorDtorCalls( stmt );
+                        std::vector< const ast::Expr * > callExprs = collectCtorDtorCalls( stmt );
                         return std::all_of( callExprs.begin(), callExprs.end(), pred );
                 }
@@ -939 +960 @@
         }
 
+        // looks like some other such codegen uses UntypedExpr and does not create fake function. should revisit afterwards
+        // following passes may accidentally resolve this expression if returned as untyped...
+        ast::Expr * createBitwiseAssignment (const ast::Expr * dst, const ast::Expr * src) {
+                static ast::ptr<ast::FunctionDecl> assign = nullptr;
+                if (!assign) {
+                        auto td = new ast::TypeDecl({}, "T", {}, nullptr, ast::TypeDecl::Dtype, true);
+                        assign = new ast::FunctionDecl({}, "?=?", {}, 
+                        { new ast::ObjectDecl({}, "_dst", new ast::ReferenceType(new ast::TypeInstType("T", td))),
+                          new ast::ObjectDecl({}, "_src", new ast::TypeInstType("T", td))},
+                        { new ast::ObjectDecl({}, "_ret", new ast::TypeInstType("T", td))}, nullptr, {}, ast::Linkage::Intrinsic);
+                }
+                if (dst->result.as<ast::ReferenceType>()) {
+                        for (int depth = dst->result->referenceDepth(); depth > 0; depth--) {
+                                dst = new ast::AddressExpr(dst);
+                        }
+                }
+                else {
+                        dst = new ast::CastExpr(dst, new ast::ReferenceType(dst->result, {}));
+                }
+                if (src->result.as<ast::ReferenceType>()) {
+                        for (int depth = src->result->referenceDepth(); depth > 0; depth--) {
+                                src = new ast::AddressExpr(src);
+                        }
+                }
+                return new ast::ApplicationExpr(dst->location, ast::VariableExpr::functionPointer(dst->location, assign), {dst, src});
+        }
+
         struct ConstExprChecker : public WithShortCircuiting {
                 // most expressions are not const expr

src/InitTweak/InitTweak.h

@@ -38 +38 @@
         /// 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
@@ -48 +51 @@
         /// 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
@@ -79 +84 @@
         /// get all Ctor/Dtor call expressions from a Statement
         void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches );
-        std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt );
+        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

src/InitTweak/module.mk

@@ -23 +23 @@
         InitTweak/GenInit.h \
         InitTweak/InitTweak.cc \
-        InitTweak/InitTweak.h
+        InitTweak/InitTweak.h \
+        InitTweak/FixInitNew.cpp
 
 SRCDEMANGLE += \

src/ResolvExpr/Resolver.cc

@@ -1105 +1105 @@
                 }
 
-                /// Establish post-resolver invariants for expressions
+                
+        } // anonymous namespace
+/// Establish post-resolver invariants for expressions
                 void finishExpr(
                         ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env,
@@ -1118 +1120 @@
                         StripCasts_new::strip( expr );
                 }
-        } // anonymous namespace
-
 
         ast::ptr< ast::Expr > resolveInVoidContext(
@@ -1139 +1139 @@
         }
 
-        namespace {
-                /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
+        /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
                 /// context.
                 ast::ptr< ast::Expr > findVoidExpression(
@@ -1151 +1150 @@
                         return newExpr;
                 }
+
+        namespace {
+                
 
                 /// resolve `untyped` to the expression whose candidate satisfies `pred` with the
@@ -1162 +1164 @@
                         CandidateRef choice =
                                 findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
-                        finishExpr( choice->expr, choice->env, untyped->env );
+                        ResolvExpr::finishExpr( choice->expr, choice->env, untyped->env );
                         return std::move( choice->expr );
                 }

src/ResolvExpr/Resolver.h

@@ -66 +66 @@
         ast::ptr< ast::Expr > findSingleExpression(
                 const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab );
+        ast::ptr< ast::Expr > findVoidExpression(
+                const ast::Expr * untyped, const ast::SymbolTable & symtab);
         /// Resolves a constructor init expression
         ast::ptr< ast::Init > resolveCtorInit( 

src/SymTab/Autogen.cc

@@ -233 +233 @@
         }
 
+        // shallow copy the pointer list for return
+        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams (const ast::Type * t) {
+                if (auto structInst = dynamic_cast<const ast::StructInstType*>(t)) {
+                        return structInst->base->params;
+                }
+                if (auto unionInst = dynamic_cast<const ast::UnionInstType*>(t)) {
+                        return unionInst->base->params;
+                }
+                return {};
+        }
+
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
@@ -244 +255 @@
                 ftype->parameters.push_back( dstParam );
                 return ftype;
+        }
+
+        /// 
+        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic) {
+                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
+                if (maybePolymorphic) typeParams = getGenericParams(paramType);
+                auto dstParam = new ast::ObjectDecl(loc, "_dst", new ast::ReferenceType(paramType), nullptr, {}, ast::Linkage::Cforall);
+                return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc));
         }
 

src/SymTab/Autogen.h

@@ -55 +55 @@
         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
+
+        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic = true);
 
         /// generate the type of a copy constructor for paramType.

src/main.cc

@@ -343 +343 @@
                         auto transUnit = convert( move( translationUnit ) );
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
+                        if ( exprp ) {
+                                translationUnit = convert( move( transUnit ) );
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+
+                        PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
                         translationUnit = convert( move( transUnit ) );
                 } else {
                         PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
+                        if ( exprp ) {
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        }
+
+                        PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
                 }
 
-                if ( exprp ) {
-                        dump( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
-
                 // fix ObjectDecl - replaces ConstructorInit nodes
-                PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
                 if ( ctorinitp ) {
                         dump ( translationUnit );