Changeset c28ea4e for src/AST

Timestamp:

Nov 4, 2020, 2:56:30 PM (5 years ago)

Author:

Colby Alexander Parsons <caparsons@…>

Branches:

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

Children:

eeb5023

Parents:

4b30e8cc (diff), a3f5208a (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/AST

Files:

• Convert.cpp (modified) (22 diffs)
• Convert.hpp (modified) (1 diff)
• Decl.cpp (modified) (1 diff)
• Decl.hpp (modified) (1 diff)
• DeclReplacer.cpp (modified) (3 diffs)
• DeclReplacer.hpp (modified) (1 diff)
• Expr.cpp (modified) (4 diffs)
• Expr.hpp (modified) (6 diffs)
• Fwd.hpp (modified) (1 diff)
• Node.hpp (modified) (1 diff)
• Pass.hpp (modified) (8 diffs)
• Pass.impl.hpp (modified) (10 diffs)
• Pass.proto.hpp (modified) (1 diff)
• SymbolTable.cpp (modified) (1 diff)
• SymbolTable.hpp (modified) (1 diff)
• TranslationUnit.hpp (added)
• Type.cpp (modified) (1 diff)
• Type.hpp (modified) (3 diffs)
• porting.md (modified) (5 diffs)

src/AST/Convert.cpp

@@ -25 +25 @@
 #include "AST/Init.hpp"
 #include "AST/Stmt.hpp"
+#include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
 
@@ -47 +48 @@
 
 //================================================================================================
-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 +67 @@
         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 +163 @@
         }
 
-        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 +177 @@
                         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 +222 @@
                 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 +284 @@
                 );
 
-                if ( dtorStruct == node ) {
+                if ( ast::dtorStruct == node ) {
                         Validate::dtorStruct = decl;
                 }
@@ -320 +337 @@
 
         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 +356 @@
                 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 +1029 @@
                 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 +1037 @@
                 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 +1057 @@
 
                 auto expr = visitBaseExpr( node, rslt );
-                this->node = expr;
+                this->node = expr->clone();
                 return nullptr;
         }
@@ -1126 +1147 @@
                 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;
                 }
@@ -1384 +1405 @@
 };
 
-std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit ) {
+std::list< Declaration * > convert( const ast::TranslationUnit && translationUnit ) {
         ConverterNewToOld c;
         std::list< Declaration * > decls;
-        for(auto d : translationUnit) {
+        for(auto d : translationUnit.decls) {
                 decls.emplace_back( c.decl( d ) );
         }
@@ -1529 +1550 @@
 
                 // 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 +1563 @@
                 }
                 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 +1572 @@
                         old->name,
                         // GET_ACCEPT_1(type, FunctionType),
+                        std::move(forall),
                         std::move(paramVars),
                         std::move(returnVars),
@@ -1552 +1579 @@
                         { 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 +1598 @@
 
                 if ( Validate::dereferenceOperator == old ) {
-                        dereferenceOperator = decl;
+                        ast::dereferenceOperator = decl;
                 }
 
                 if ( Validate::dtorStructDestroy == old ) {
-                        dtorStructDestroy = decl;
+                        ast::dtorStructDestroy = decl;
                 }
         }
@@ -1599 +1627 @@
 
                 if ( Validate::dtorStruct == old ) {
-                        dtorStruct = decl;
+                        ast::dtorStruct = decl;
                 }
         }
@@ -2531 +2559 @@
                 // I believe this should always be a BasicType.
                 if ( Validate::SizeType == old ) {
-                        sizeType = type;
+                        ast::sizeType = type;
                 }
                 visitType( old, type );
@@ -2776 +2804 @@
 #undef GET_ACCEPT_1
 
-std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
+ast::TranslationUnit convert( const std::list< Declaration * > && translationUnit ) {
         ConverterOldToNew c;
-        std::list< ast::ptr< ast::Decl > > decls;
+        ast::TranslationUnit unit;
         for(auto d : translationUnit) {
                 d->accept( c );
-                decls.emplace_back( c.decl() );
+                unit.decls.emplace_back( c.decl() );
         }
         deleteAll(translationUnit);
-        return decls;
+        return unit;
 }

src/AST/Convert.hpp

@@ -18 +18 @@
 #include <list>
 
-#include "AST/Node.hpp"
-
 class Declaration;
 namespace ast {
-        class Decl;
+        class TranslationUnit;
 };
 
-std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit );
-std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit );
+std::list< Declaration * > convert( const ast::TranslationUnit && translationUnit );
+ast::TranslationUnit convert( const std::list< Declaration * > && translationUnit );

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 );
 
@@ -102 +102 @@
         }
         return ret;
+}
+
+// --- VariableExpr
+
+VariableExpr::VariableExpr( const CodeLocation & loc )
+: Expr( loc ), var( nullptr ) {}
+
+VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
+: Expr( loc ), var( v ) {
+        assert( var );
+        assert( var->get_type() );
+        result = shallowCopy( var->get_type() );
+}
+
+bool VariableExpr::get_lvalue() const {
+        // It isn't always an lvalue, but it is never an rvalue.
+        return true;
+}
+
+VariableExpr * VariableExpr::functionPointer(
+                const CodeLocation & loc, const FunctionDecl * decl ) {
+        // wrap usually-determined result type in a pointer
+        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
+        funcExpr->result = new PointerType{ funcExpr->result };
+        return funcExpr;
 }
 
@@ -238 +263 @@
 }
 
-// --- VariableExpr
-
-VariableExpr::VariableExpr( const CodeLocation & loc )
-: Expr( loc ), var( nullptr ) {}
-
-VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
-: Expr( loc ), var( v ) {
-        assert( var );
-        assert( var->get_type() );
-        result = shallowCopy( var->get_type() );
-}
-
-bool VariableExpr::get_lvalue() const {
-        // It isn't always an lvalue, but it is never an rvalue.
-        return true;
-}
-
-VariableExpr * VariableExpr::functionPointer(
-                const CodeLocation & loc, const FunctionDecl * decl ) {
-        // wrap usually-determined result type in a pointer
-        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
-        funcExpr->result = new PointerType{ funcExpr->result };
-        return funcExpr;
-}
-
 // --- ConstantExpr
 

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 ); }
@@ -247 +247 @@
 private:
         NameExpr * clone() const override { return new NameExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// A reference to a named variable.
+class VariableExpr final : public Expr {
+public:
+        readonly<DeclWithType> var;
+
+        VariableExpr( const CodeLocation & loc );
+        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
+
+        bool get_lvalue() const final;
+
+        /// generates a function pointer for a given function
+        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
         MUTATE_FRIEND
 };
@@ -392 +411 @@
 };
 
-/// A reference to a named variable.
-class VariableExpr final : public Expr {
-public:
-        readonly<DeclWithType> var;
-
-        VariableExpr( const CodeLocation & loc );
-        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
-
-        bool get_lvalue() const final;
-
-        /// generates a function pointer for a given function
-        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
-
-        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
-        MUTATE_FRIEND
-};
-
 /// A compile-time constant.
 /// Mostly carries C-source text from parse to code-gen, without interpretation.  E.g. strings keep their outer quotes and never have backslashes interpreted.
@@ -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;
 
+class TranslationUnit;
+// TODO: Get from the TranslationUnit:
+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

@@ -103 +103 @@
         /// Construct and run a pass on a translation unit.
         template< typename... Args >
-        static void run( std::list< ptr<Decl> > & decls, Args &&... args ) {
+        static void run( TranslationUnit & decls, Args &&... args ) {
                 Pass<core_t> visitor( std::forward<Args>( args )... );
                 accept_all( decls, visitor );
@@ -119 +119 @@
         // Versions of the above for older compilers.
         template< typename... Args >
-        static void run( std::list< ptr<Decl> > & decls ) {
+        static void run( TranslationUnit & decls ) {
                 Pass<core_t> visitor;
                 accept_all( decls, visitor );
@@ -228 +228 @@
         template<typename core_type>
         friend void accept_all( std::list< ptr<Decl> > & decls, Pass<core_type>& visitor );
+
+        bool isInFunction() const {
+                return inFunction;
+        }
+
 private:
 
@@ -235 +240 @@
         const ast::Stmt * call_accept( const ast::Stmt * );
         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 >
@@ -257 +266 @@
         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:
@@ -284 +296 @@
 private:
         bool inFunction = false;
+        bool atFunctionTop = false;
 };
 
@@ -289 +302 @@
 template<typename core_t>
 void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<core_t> & visitor );
+
+template<typename core_t>
+void accept_all( ast::TranslationUnit &, ast::Pass<core_t> & visitor );
 
 //-------------------------------------------------------------------------------------------------
@@ -371 +387 @@
 struct WithVisitorRef {
         Pass<core_t> * const visitor = nullptr;
+
+        bool isInFunction() const {
+                return visitor->isInFunction();
+        }
 };
 

src/AST/Pass.impl.hpp

@@ -20 +20 @@
 #include <unordered_map>
 
+#include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
 
@@ -167 +168 @@
                 __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;
@@ -334 +343 @@
         }
 
+        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");
+
+                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 >
@@ -398 +431 @@
         pass_visitor_stats.depth--;
         if ( !errors.isEmpty() ) { throw errors; }
+}
+
+template< typename core_t >
+inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
+        return ast::accept_all( unit.decls, visitor );
 }
 
@@ -470 +508 @@
                                 // foralls are still in function type
                                 maybe_accept( node, &FunctionDecl::type );
-                                // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                                // a new scope if inFunction is true
+                                // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
                                 inFunction = true;
+                                // The function body needs to have the same scope as parameters.
+                                // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                                atFunctionTop = true;
                                 maybe_accept( node, &FunctionDecl::stmts );
                                 maybe_accept( node, &FunctionDecl::attributes );
@@ -639 +680 @@
 const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
         VISIT_START( node );
-        VISIT({
-                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() {
-                        if ( ! inFunctionCpy ) __pass::symtab::enter(core, 0);
-                }, [this, inFunctionCpy = this->inFunction]() {
-                        if ( ! inFunctionCpy ) __pass::symtab::leave(core, 0);
+        VISIT(
+                // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
+                auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
+                        if ( enterScope ) __pass::symtab::enter(core, 0);
+                }, [this, leaveScope = !this->atFunctionTop]() {
+                        if ( leaveScope ) __pass::symtab::leave(core, 0);
                 });
-                ValueGuard< bool > guard2( inFunction );
+                ValueGuard< bool > guard2( atFunctionTop );
+                atFunctionTop = false;
                 guard_scope guard3 { *this };
-                inFunction = false;
                 maybe_accept( node, &CompoundStmt::kids );
-        })
+        )
         VISIT_END( CompoundStmt, node );
 }
@@ -703 +744 @@
                 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 +762 @@
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
-                maybe_accept( node, &WhileStmt::body  );
+                maybe_accept_as_compound( node, &WhileStmt::body  );
         })
 
@@ -736 +777 @@
                 // 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 +876 @@
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
-                maybe_accept( node, &CatchStmt::body );
+                maybe_accept_as_compound( node, &CatchStmt::body );
         })
 

src/AST/Pass.proto.hpp

@@ -22 +22 @@
 template<typename core_t>
 class Pass;
+
+class TranslationUnit;
 
 struct PureVisitor;

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/AST/Type.cpp

@@ -157 +157 @@
 
 template<typename decl_t>
+SueInstType<decl_t>::SueInstType(
+        const base_type * b, std::vector<ptr<Expr>> && params,
+        CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
+: BaseInstType( b->name, std::move(params), q, std::move(as) ), base( b ) {}
+
+template<typename decl_t>
 bool SueInstType<decl_t>::isComplete() const {
         return base ? base->body : false;

src/AST/Type.hpp

@@ -302 +302 @@
 class FunctionType final : public ParameterizedType {
 public:
-//      std::vector<ptr<DeclWithType>> returns;
-//      std::vector<ptr<DeclWithType>> params;
-
         std::vector<ptr<Type>> returns;
         std::vector<ptr<Type>> params;
@@ -345 +342 @@
         : ParameterizedType(q, std::move(as)), params(), name(n) {}
 
+        BaseInstType(
+                const std::string& n, std::vector<ptr<Expr>> && params,
+                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
+        : ParameterizedType(q, std::move(as)), params(std::move(params)), name(n) {}
+
         BaseInstType( const BaseInstType & o );
 
@@ -369 +371 @@
 
         SueInstType(
-                const decl_t * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
+                const base_type * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
+
+        SueInstType(
+                const base_type * b, std::vector<ptr<Expr>> && params,
+                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         bool isComplete() const override;

src/AST/porting.md

@@ -30 +30 @@
   * Base nodes now override `const Node * accept( Visitor & v ) const = 0` with, e.g. `const Stmt * accept( Visitor & v ) const override = 0`
 * `PassVisitor` is replaced with `ast::Pass`
+  * Most one shot uses can use `ast::Pass::run` and `ast::Pass::read`.
+
+`WithConstTypeSubstitution`
+* `env` => `typeSubs`
 
 ## Structural Changes ##
@@ -146 +150 @@
   * allows `newObject` as just default settings
 
+`FunctionDecl`
+* `params` and `returns` added.
+  * Contain the declarations of the parameters and return variables.
+  * Types should match (even be shared with) the fields of `type`.
+
 `NamedTypeDecl`
 * `parameters` => `params`
@@ -154 +163 @@
 `AggregateDecl`
 * `parameters` => `params`
+
+`StructDecl`
+* `makeInst` replaced by better constructor on `StructInstType`.
 
 `Expr`
@@ -245 +257 @@
 * **TODO** move `kind`, `typeNames` into code generator
 
-`ReferenceToType`
+`ReferenceToType` => `BaseInstType`
 * deleted `get_baseParameters()` from children
   * replace with `aggr() ? aggr()->params : nullptr`
@@ -261 +273 @@
 * `returnVals` => `returns`
 * `parameters` => `params`
+  * Both now just point at types.
 * `bool isVarArgs;` => `enum ArgumentFlag { FixedArgs, VariableArgs }; ArgumentFlag isVarArgs;`
+
+`SueInstType`
+* Template class, with specializations and using to implement some other types:
+  * `StructInstType`, `UnionInstType` & `EnumInstType`
 
 `TypeInstType`