Changes in / [c532847:76d73fc]

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 (deleted)
• 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 ast {
+namespace {
 
 // 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;
@@ -66 +63 @@
         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>
@@ -162 +154 @@
         }
 
-        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {        
+        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 );
                 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,
@@ -176 +168 @@
                         bfwd,
                         type->clone(),
-                        nullptr, // prevent infinite loop
+                        init,
                         attr,
                         Type::FuncSpecifiers( node->funcSpec.val )
                 );
-
-                // 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;
+                return declWithTypePostamble( decl, node );
         }
 
@@ -221 +205 @@
                 decl->statements = get<CompoundStmt>().accept1( node->stmts );
                 decl->withExprs = get<Expression>().acceptL( node->withExprs );
-                if ( ast::dereferenceOperator == node ) {
+                if ( dereferenceOperator == node ) {
                         Validate::dereferenceOperator = decl;
                 }
-                if ( ast::dtorStructDestroy == node ) {
+                if ( dtorStructDestroy == node ) {
                         Validate::dtorStructDestroy = decl;
                 }
@@ -283 +267 @@
                 );
 
-                if ( ast::dtorStruct == node ) {
+                if ( dtorStruct == node ) {
                         Validate::dtorStruct = decl;
                 }
@@ -336 +320 @@
 
         const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
-                // force statements in old tree to be unique.
-                // cache.emplace( node, stmt );
-                readonlyCache.emplace( node, stmt );
+                cache.emplace( node, stmt );
                 stmt->location = node->location;
                 stmt->labels = makeLabelL( stmt, node->labels );
@@ -355 +337 @@
                 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 );
@@ -1028 +1011 @@
                 auto stmts = node->stmts;
                 // disable sharing between multiple StmtExprs explicitly.
-                // this should no longer be true.
-
+                if (inCache(stmts)) {
+                        stmts = ast::deepCopy(stmts.get());
+                }
                 auto rslt = new StmtExpr(
                         get<CompoundStmt>().accept1(stmts)
@@ -1036 +1020 @@
                 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 );
@@ -1056 +1036 @@
 
                 auto expr = visitBaseExpr( node, rslt );
-                this->node = expr->clone();
+                this->node = expr;
                 return nullptr;
         }
@@ -1146 +1126 @@
                 auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
                 // I believe this should always be a BasicType.
-                if ( ast::sizeType == node ) {
+                if ( sizeType == node ) {
                         Validate::SizeType = type;
                 }
@@ -1549 +1529 @@
 
                 // 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());
@@ -1562 +1540 @@
                 }
                 ftype->forall = std::move(forall);
-                */
-
-                // can function type have attributes? seems not to be the case.
-                // visitType(old->type, ftype);
+                visitType(old->type, ftype);
 
                 auto decl = new ast::FunctionDecl{
@@ -1571 +1546 @@
                         old->name,
                         // GET_ACCEPT_1(type, FunctionType),
-                        std::move(forall),
                         std::move(paramVars),
                         std::move(returnVars),
@@ -1578 +1552 @@
                         { old->linkage.val },
                         GET_ACCEPT_V(attributes, Attribute),
-                        { old->get_funcSpec().val },
-                        old->type->isVarArgs
+                        { old->get_funcSpec().val }
                 };
 
-                // decl->type = ftype;
+                decl->type = ftype;
                 cache.emplace( old, decl );
 
@@ -1597 +1570 @@
 
                 if ( Validate::dereferenceOperator == old ) {
-                        ast::dereferenceOperator = decl;
+                        dereferenceOperator = decl;
                 }
 
                 if ( Validate::dtorStructDestroy == old ) {
-                        ast::dtorStructDestroy = decl;
+                        dtorStructDestroy = decl;
                 }
         }
@@ -1626 +1599 @@
 
                 if ( Validate::dtorStruct == old ) {
-                        ast::dtorStruct = decl;
+                        dtorStruct = decl;
                 }
         }
@@ -2558 +2531 @@
                 // I believe this should always be a BasicType.
                 if ( Validate::SizeType == old ) {
-                        ast::sizeType = type;
+                        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, std::vector<ptr<TypeDecl>>&& forall,
+        FunctionDecl( const CodeLocation & loc, const std::string & name, 
                 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 = {}, bool isVarArgs = false);
-        // : 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 = {})
+        : 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 *);
-                };
         }
 
@@ -64 +54 @@
                 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 );
         }
 
@@ -103 +88 @@
                         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, const Expr * arg ) {
+UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, Expr * arg ) {
         assert( arg );
 
@@ -92 +92 @@
 }
 
-UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs ) {
+UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs ) {
         assert( lhs && rhs );
 

src/AST/Expr.hpp

@@ -226 +226 @@
 
         /// Creates a new dereference expression
-        static UntypedExpr * createDeref( const CodeLocation & loc, const Expr * arg );
+        static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
         /// Creates a new assignment expression
-        static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
+        static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, 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 ), underlyer(ty) {}
+        : Expr( loc, ty ), rep( r ), ival( i ) {}
 
         /// 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 ), callExpr(call) { assert( call ); assert(call->result); }
+        : Expr( loc, call->result ) { assert( call ); }
 
         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<
@@ -261 +257 @@
         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;
@@ -332 +324 @@
 
                 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");
@@ -735 +703 @@
                 maybe_accept( node, &IfStmt::inits    );
                 maybe_accept( node, &IfStmt::cond     );
-                maybe_accept_as_compound( node, &IfStmt::thenPart );
-                maybe_accept_as_compound( node, &IfStmt::elsePart );
+                maybe_accept( node, &IfStmt::thenPart );
+                maybe_accept( node, &IfStmt::elsePart );
         })
 
@@ -753 +721 @@
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
-                maybe_accept_as_compound( node, &WhileStmt::body  );
+                maybe_accept( node, &WhileStmt::body  );
         })
 
@@ -768 +736 @@
                 // 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_as_compound( node, &ForStmt::body  );
+                maybe_accept( node, &ForStmt::body  );
         })
 
@@ -867 +834 @@
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
-                maybe_accept_as_compound( node, &CatchStmt::body );
+                maybe_accept( node, &CatchStmt::body );
         })
 

src/AST/SymbolTable.cpp

@@ -335 +335 @@
 }
 
-
-void SymbolTable::addFunction( const FunctionDecl * func ) {
-        addTypes( func->type->forall );
-        addIds( func->returns );
-        addIds( func->params );
-}
-
+/*
+void SymbolTable::addFunctionType( const FunctionType * ftype ) {
+        addTypes( ftype->forall );
+        addIds( ftype->returns );
+        addIds( ftype->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 addFunction( const FunctionDecl * );
+        // void addFunctionType( const FunctionType * ftype );
 
 private:

src/Common/utility.h

@@ -360 +360 @@
         reverse_iterate_t( T & ref ) : ref(ref) {}
 
-        // this does NOT work on const T!!!
-        // typedef typename T::reverse_iterator iterator;
-        auto begin() { return ref.rbegin(); }
-        auto end() { return ref.rend(); }
+        typedef typename T::reverse_iterator iterator;
+        iterator begin() { return ref.rbegin(); }
+        iterator 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 ) {
@@ -64 +56 @@
                 }
 
-                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 ) {
@@ -108 +92 @@
                         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;
@@ -136 +111 @@
         }
 
-        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 );
@@ -166 +126 @@
                 }
                 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;
         }
 
@@ -504 +449 @@
         }
 
-        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
@@ -522 +459 @@
         }
 
-        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 );
@@ -539 +467 @@
         }
 
-        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}));
         }
 
@@ -563 +478 @@
                 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;
 
-        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
@@ -86 +84 @@
         /// 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`
@@ -97 +93 @@
         /// 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 {
@@ -54 +50 @@
                 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;
         };
 
@@ -109 +91 @@
         }
 
-        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();
@@ -168 +127 @@
         }
 
-        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;
 
@@ -29 +26 @@
         /// 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;
 
@@ -26 +24 @@
         /// 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 );
@@ -518 +511 @@
         }
 
-        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 ) {}
@@ -557 +536 @@
 
         struct CallFinder_new final {
-                std::vector< const ast::Expr * > matches;
+                std::vector< ast::ptr< ast::Expr > > matches;
                 const std::vector< std::string > names;
 
@@ -579 +558 @@
         }
 
-        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt ) {
+        std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt ) {
                 ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
                 maybe_accept( stmt, finder );
@@ -717 +696 @@
                 template <typename Predicate>
                 bool allofCtorDtor( const ast::Stmt * stmt, const Predicate & pred ) {
-                        std::vector< const ast::Expr * > callExprs = collectCtorDtorCalls( stmt );
+                        std::vector< ast::ptr< ast::Expr > > callExprs = collectCtorDtorCalls( stmt );
                         return std::all_of( callExprs.begin(), callExprs.end(), pred );
                 }
@@ -960 +939 @@
         }
 
-        // 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
@@ -51 +48 @@
         /// 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
@@ -84 +79 @@
         /// 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 );
+        std::vector< ast::ptr< 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/FixInitNew.cpp
+        InitTweak/InitTweak.h
 
 SRCDEMANGLE += \

src/ResolvExpr/Resolver.cc

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