Changeset 63be3387 for src

Timestamp:

Nov 14, 2022, 11:52:44 AM (3 years ago)

Author:

caparson <caparson@…>

Branches:

ADT, ast-experimental, master

Children:

7d9598d8

Parents:

b77f0e1 (diff), 19a8c40 (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) (3 diffs)
• AST/Decl.hpp (modified) (3 diffs)
• AST/Fwd.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (3 diffs)
• AST/Print.cpp (modified) (1 diff)
• AST/Type.cpp (modified) (2 diffs)
• AST/Type.hpp (modified) (1 diff)
• AST/Visitor.hpp (modified) (1 diff)
• Common/CodeLocationTools.cpp (modified) (1 diff)
• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (3 diffs)
• Common/utility.h (modified) (1 diff)
• GenPoly/Box.cc (modified) (62 diffs)
• GenPoly/FindFunction.cc (modified) (3 diffs)
• GenPoly/FindFunction.h (modified) (1 diff)
• GenPoly/GenPoly.cc (modified) (6 diffs)
• GenPoly/GenPoly.h (modified) (6 diffs)
• GenPoly/InstantiateGenericNew.cpp (modified) (3 diffs)
• GenPoly/ScrubTyVars.cc (modified) (4 diffs)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/ExpressionNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/TypeData.cc (modified) (1 diff)
• Parser/parser.yy (modified) (8 diffs)
• ResolvExpr/CommonType.cc (modified) (2 diffs)
• ResolvExpr/ConversionCost.cc (modified) (1 diff)
• ResolvExpr/SatisfyAssertions.cpp (modified) (1 diff)
• SymTab/Mangler.cc (modified) (4 diffs)
• SymTab/Mangler.h (modified) (4 diffs)
• SymTab/Validate.cc (modified) (2 diffs)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/InlineMemberDecl.cc (added)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• SynTree/module.mk (modified) (1 diff)
• Validate/EnumAndPointerDecay.cpp (modified) (3 diffs)
• Validate/LinkReferenceToTypes.cpp (modified) (2 diffs)
• Virtual/ExpandCasts.cc (modified) (2 diffs)

src/AST/Convert.cpp

@@ -234 +234 @@
                 }
                 return declWithTypePostamble( decl, node );
+        }
+
+        // InlineMemberDecl vanish after EnumAndPointerDecay pass so no necessary to implement NewToOld
+        const ast::DeclWithType * visit( const ast::InlineMemberDecl * node ) override final {  
+                assert( false );
+                (void) node;
+                return nullptr;
         }
 
@@ -1614 +1621 @@
                         { old->get_funcSpec().val }
                 );
-                decl->enumInLine = old->enumInLine;
                 cache.emplace(old, decl);
                 assert(cache.find( old ) != cache.end());
@@ -1859 +1865 @@
                 decl->uniqueId   = old->uniqueId;
                 decl->storage    = { old->storageClasses.val };
+
+                this->node = decl;
+        }
+
+        virtual void visit( const InlineMemberDecl * old ) override final {
+                if ( inCache( old ) ) {
+                        return;
+                }
+                auto&& type = GET_ACCEPT_1(type, Type);
+                auto&& attr = GET_ACCEPT_V(attributes, Attribute);
+
+                auto decl = new ast::InlineMemberDecl(
+                        old->location,
+                        old->name,
+                        type,
+                        { old->get_storageClasses().val },
+                        { old->linkage.val },
+                        std::move(attr),
+                        { old->get_funcSpec().val }
+                );
+                cache.emplace(old, decl);
+                assert(cache.find( old ) != cache.end());
+                decl->scopeLevel = old->scopeLevel;
+                decl->mangleName = old->mangleName;
+                decl->isDeleted  = old->isDeleted;
+                decl->asmName    = GET_ACCEPT_1(asmName, Expr);
+                decl->uniqueId   = old->uniqueId;
+                decl->extension  = old->extension;
 
                 this->node = decl;

src/AST/Decl.hpp

@@ -105 +105 @@
         ptr<Init> init;
         ptr<Expr> bitfieldWidth;
-        bool enumInLine = false; // enum inline is not a real object declaration. 
-        // It is a place holder for a set of enum value (ObjectDecl)
-        bool importValue = false; // if the value copied from somewhere else
 
         ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type,
@@ -400 +397 @@
 };
 
+/// Static Assertion `_Static_assert( ... , ... );`
 class StaticAssertDecl : public Decl {
 public:
@@ -411 +409 @@
 private:
         StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
+        MUTATE_FRIEND
+};
+
+/// Inline Member Declaration `inline TypeName;`
+class InlineMemberDecl final : public DeclWithType {
+public:
+        ptr<Type> type;
+
+        InlineMemberDecl( const CodeLocation & loc, const std::string & name, const Type * type,
+                Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
+                std::vector< ptr<Attribute> > && attrs = {}, Function::Specs fs = {} )
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ) {}
+
+        const Type * get_type() const override { return type; }
+        void set_type( const Type * ty ) override { type = ty; }
+
+        const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
+private:
+        InlineMemberDecl * clone() const override { return new InlineMemberDecl{ *this }; }
         MUTATE_FRIEND
 };

src/AST/Fwd.hpp

@@ -37 +37 @@
 class DirectiveDecl;
 class StaticAssertDecl;
+class InlineMemberDecl;
 
 class Stmt;

src/AST/Pass.hpp

@@ -141 +141 @@
         const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) override final;
         const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) override final;
+        const ast::DeclWithType *     visit( const ast::InlineMemberDecl     * ) override final;
         const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) override final;
         const ast::Stmt *             visit( const ast::ExprStmt             * ) override final;

src/AST/Pass.impl.hpp

@@ -617 +617 @@
                                 maybe_accept( node, &FunctionDecl::returns );
                                 maybe_accept( node, &FunctionDecl::type );
+                                maybe_accept( node, &FunctionDecl::attributes );
                                 // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
@@ -625 +626 @@
                                 atFunctionTop = true;
                                 maybe_accept( node, &FunctionDecl::stmts );
-                                maybe_accept( node, &FunctionDecl::attributes );
                         }
                 }
@@ -800 +800 @@
 
         VISIT_END( StaticAssertDecl, node );
+}
+
+//--------------------------------------------------------------------------
+// InlineMemberDecl
+template< typename core_t >
+const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::InlineMemberDecl * node ) {
+        VISIT_START( node );
+
+        if ( __visit_children() ) {
+                {
+                        guard_symtab guard { *this };
+                        maybe_accept( node, &InlineMemberDecl::type );
+                }
+        }
+
+        VISIT_END( DeclWithType, node );
 }
 

src/AST/Print.cpp

@@ -398 +398 @@
         virtual const ast::Decl * visit( const ast::StructDecl * node ) override final {
                 print(node);
+                return node;
+        }
+
+        virtual const ast::DeclWithType * visit( const ast::InlineMemberDecl * node ) override final {
+                os << "inline ";
+                if ( ! node->name.empty() ) os << node->name;
+
                 return node;
         }

src/AST/Type.cpp

@@ -147 +147 @@
 // --- TypeInstType
 
+bool TypeInstType::operator==( const TypeInstType & other ) const {
+        return base == other.base
+                && formal_usage == other.formal_usage
+                && expr_id == other.expr_id;
+}
+
 TypeInstType::TypeInstType( const TypeDecl * b,
         CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
@@ -157 +163 @@
 
 bool TypeInstType::isComplete() const { return base->sized; }
+
+std::string TypeInstType::TypeEnvKey::typeString() const {
+        return std::string("_") + std::to_string(formal_usage)
+                + "_" + std::to_string(expr_id) + "_" + base->name;
+}
+
+bool TypeInstType::TypeEnvKey::operator==(
+                const TypeInstType::TypeEnvKey & other ) const {
+        return base == other.base
+                && formal_usage == other.formal_usage
+                && expr_id == other.expr_id;
+}
+
+bool TypeInstType::TypeEnvKey::operator<(
+                const TypeInstType::TypeEnvKey & other ) const {
+        // TypeEnvKey ordering is an arbitrary total ordering.
+        // It doesn't mean anything but allows for a sorting.
+        if ( base < other.base ) {
+                return true;
+        } else if ( other.base < base ) {
+                return false;
+        } else if ( formal_usage < other.formal_usage ) {
+                return true;
+        } else if ( other.formal_usage < formal_usage ) {
+                return false;
+        } else {
+                return expr_id < other.expr_id;
+        }
+}
 
 // --- TupleType

src/AST/Type.hpp

@@ -408 +408 @@
 
                 TypeEnvKey() = default;
-                TypeEnvKey(const TypeDecl * base, int formal_usage = 0, int expr_id = 0): base(base), formal_usage(formal_usage), expr_id(expr_id) {}
-                TypeEnvKey(const TypeInstType & inst): base(inst.base), formal_usage(inst.formal_usage), expr_id(inst.expr_id) {}
-                std::string typeString() const { return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + base->name; }
-                bool operator==(const TypeEnvKey & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
+                TypeEnvKey(const TypeDecl * base, int formal_usage = 0, int expr_id = 0)
+                : base(base), formal_usage(formal_usage), expr_id(expr_id) {}
+                TypeEnvKey(const TypeInstType & inst)
+                : base(inst.base), formal_usage(inst.formal_usage), expr_id(inst.expr_id) {}
+                std::string typeString() const;
+                bool operator==(const TypeEnvKey & other) const;
+                bool operator<(const TypeEnvKey & other) const;
         };
 
-        bool operator==(const TypeInstType & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
+        bool operator==(const TypeInstType & other) const;
 
         TypeInstType(

src/AST/Visitor.hpp

@@ -33 +33 @@
     virtual const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) = 0;
     virtual const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) = 0;
+    virtual const ast::DeclWithType *     visit( const ast::InlineMemberDecl     * ) = 0;
     virtual const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ExprStmt             * ) = 0;

src/Common/CodeLocationTools.cpp

@@ -111 +111 @@
     macro(DirectiveDecl, DirectiveDecl) \
     macro(StaticAssertDecl, StaticAssertDecl) \
+    macro(InlineMemberDecl, DeclWithType) \
     macro(CompoundStmt, CompoundStmt) \
     macro(ExprStmt, Stmt) \

src/Common/PassVisitor.h

@@ -81 +81 @@
         virtual void visit( StaticAssertDecl * assertDecl ) override final;
         virtual void visit( const StaticAssertDecl * assertDecl ) override final;
+        virtual void visit( InlineMemberDecl * valueDecl ) override final;
+        virtual void visit( const InlineMemberDecl * valueDecl ) override final;
 
         virtual void visit( CompoundStmt * compoundStmt ) override final;
@@ -273 +275 @@
         virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) override final;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;
+        virtual DeclarationWithType * mutate( InlineMemberDecl * valueDecl ) override final;
 
         virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final;

src/Common/PassVisitor.impl.h

@@ -607 +607 @@
                         indexerAddId( &func );
                         maybeMutate_impl( node->type, *this );
+                        maybeMutate_impl( node->attributes, *this );
                         // First remember that we are now within a function.
                         ValueGuard< bool > oldInFunction( inFunction );
@@ -615 +616 @@
                         atFunctionTop = true;
                         maybeMutate_impl( node->statements, *this );
-                        maybeMutate_impl( node->attributes, *this );
                 }
         }
@@ -1044 +1044 @@
 
         MUTATE_END( StaticAssertDecl, node );
+}
+
+//--------------------------------------------------------------------------
+// InlineMemberDecl
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( InlineMemberDecl * node ) {
+        VISIT_START( node );
+
+        maybeAccept_impl( node->type, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const InlineMemberDecl * node ) {
+        VISIT_START( node );
+
+        maybeAccept_impl( node->type, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+DeclarationWithType * PassVisitor< pass_type >::mutate( InlineMemberDecl * node ) {
+        MUTATE_START( node );
+
+        maybeMutate_impl( node->type, *this );
+
+        MUTATE_END( DeclarationWithType, node );
 }
 

src/Common/utility.h

@@ -452 +452 @@
 
 // -----------------------------------------------------------------------------
-// Helper struct and function to support
-// for ( val : group_iterate( container1, container2, ... ) ) {}
-// syntax to have a for each that iterates multiple containers of the same length
-// TODO: update to use variadic arguments
-
-template< typename T1, typename T2 >
-struct group_iterate_t {
-private:
-        std::tuple<T1, T2> args;
+// Helper struct and function to support:
+// for ( auto val : group_iterate( container1, container2, ... ) ) { ... }
+// This iteraters through multiple containers of the same size.
+
+template<typename... Args>
+class group_iterate_t {
+        using Iterables = std::tuple<Args...>;
+        Iterables iterables;
+
+        // Getting the iterator and value types this way preserves const.
+        template<size_t I> using Iter = decltype(std::get<I>(iterables).begin());
+        template<size_t I> using Data = decltype(*std::get<I>(iterables).begin());
+        template<typename> struct base_iterator;
+
+        // This inner template puts the sequence of `0, 1, ... sizeof...(Args)-1`
+        // into a pack. These are the indexes into the tuples, so unpacking can
+        // go over each element of the tuple.
+        // The std::integer_sequence is just used to build that sequence.
+        // A library reference will probably explain it better than I can.
+        template<std::size_t... Indices>
+        struct base_iterator<std::integer_sequence<std::size_t, Indices...>> {
+                using value_type = std::tuple< Data<Indices>... >;
+                std::tuple<Iter<Indices>...> iterators;
+
+                base_iterator( Iter<Indices>... is ) : iterators( is... ) {}
+                base_iterator operator++() {
+                        return base_iterator( ++std::get<Indices>( iterators )... );
+                }
+                bool operator!=( const base_iterator& other ) const {
+                        return iterators != other.iterators;
+                }
+                value_type operator*() const {
+                        return std::tie( *std::get<Indices>( iterators )... );
+                }
+
+                static base_iterator make_begin( Iterables & data ) {
+                        return base_iterator( std::get<Indices>( data ).begin()... );
+                }
+                static base_iterator make_end( Iterables & data ) {
+                        return base_iterator( std::get<Indices>( data ).end()... );
+                }
+        };
+
 public:
-        group_iterate_t( bool skipBoundsCheck, const T1 & v1, const T2 & v2 ) : args(v1, v2) {
-                assertf(skipBoundsCheck || v1.size() == v2.size(), "group iteration requires containers of the same size: <%zd, %zd>.", v1.size(), v2.size());
-        };
-
-        typedef std::tuple<decltype(*std::get<0>(args).begin()), decltype(*std::get<1>(args).begin())> value_type;
-        typedef decltype(std::get<0>(args).begin()) T1Iter;
-        typedef decltype(std::get<1>(args).begin()) T2Iter;
-
-        struct iterator {
-                typedef std::tuple<T1Iter, T2Iter> IterTuple;
-                IterTuple it;
-                iterator( T1Iter i1, T2Iter i2 ) : it( i1, i2 ) {}
-                iterator operator++() {
-                        return iterator( ++std::get<0>(it), ++std::get<1>(it) );
-                }
-                bool operator!=( const iterator &other ) const { return it != other.it; }
-                value_type operator*() const { return std::tie( *std::get<0>(it), *std::get<1>(it) ); }
-        };
-
-        iterator begin() { return iterator( std::get<0>(args).begin(), std::get<1>(args).begin() ); }
-        iterator end() { return iterator( std::get<0>(args).end(), std::get<1>(args).end() ); }
-};
-
-/// performs bounds check to ensure that all arguments are of the same length.
+        group_iterate_t( const Args &... args ) : iterables( args... ) {}
+
+        using iterator = base_iterator<decltype(
+                std::make_integer_sequence<std::size_t, sizeof...(Args)>())>;
+
+        iterator begin() { return iterator::make_begin( iterables ); }
+        iterator end() { return iterator::make_end( iterables ); }
+};
+
+// Helpers for the bounds checks (the non-varatic part of group_iterate):
+static inline void runGroupBoundsCheck(size_t size0, size_t size1) {
+        assertf( size0 == size1,
+                "group iteration requires containers of the same size: <%zd, %zd>.",
+                size0, size1 );
+}
+
+static inline void runGroupBoundsCheck(size_t size0, size_t size1, size_t size2) {
+        assertf( size0 == size1 && size1 == size2,
+                "group iteration requires containers of the same size: <%zd, %zd, %zd>.",
+                size0, size1, size2 );
+}
+
+/// Performs bounds check to ensure that all arguments are of the same length.
 template< typename... Args >
 group_iterate_t<Args...> group_iterate( Args &&... args ) {
-        return group_iterate_t<Args...>(false, std::forward<Args>( args )...);
-}
-
-/// does not perform a bounds check - requires user to ensure that iteration terminates when appropriate.
+        runGroupBoundsCheck( args.size()... );
+        return group_iterate_t<Args...>( std::forward<Args>( args )... );
+}
+
+/// Does not perform a bounds check - requires user to ensure that iteration terminates when appropriate.
 template< typename... Args >
 group_iterate_t<Args...> unsafe_group_iterate( Args &&... args ) {
-        return group_iterate_t<Args...>(true, std::forward<Args>( args )...);
+        return group_iterate_t<Args...>( std::forward<Args>( args )... );
 }
 

src/GenPoly/Box.cc

@@ -58 +58 @@
 namespace GenPoly {
         namespace {
-                FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
+                FunctionType *makeAdapterType( FunctionType const *adaptee, const TyVarMap &tyVars );
 
                 class BoxPass {
@@ -68 +68 @@
                 /// Adds layout-generation functions to polymorphic types.
                 class LayoutFunctionBuilder final : public WithDeclsToAdd, public WithVisitorRef<LayoutFunctionBuilder>, public WithShortCircuiting {
-                        // Current level of nested functions:
-                        unsigned int functionNesting = 0;
                 public:
-                        void previsit( FunctionDecl *functionDecl );
                         void previsit( StructDecl *structDecl );
                         void previsit( UnionDecl *unionDecl );
@@ -100 +97 @@
                         void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
                         /// passes extra type parameters into a polymorphic function application
-                        void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
+                        /// Returns an iterator to the first argument after the added
+                        /// arguments, which are added at the beginning.
+                        std::list< Expression *>::iterator passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
-                        Expression *addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg );
-                        /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
-                        void replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params );
-                        /// Replaces a polymorphic type with its concrete equivalant under the current environment (returns itself if concrete).
-                        /// If `doClone` is set to false, will not clone interior types
-                        Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
+                        /// The new out-parameter is the new first parameter.
+                        Expression *addRetParam( ApplicationExpr *appExpr, Type *retType );
                         /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
-                        Expression *addDynRetParam( ApplicationExpr *appExpr, Type *polyType, std::list< Expression *>::iterator &arg );
-                        Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
-                        void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
-                        void boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
-                        void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars );
+                        Expression *addDynRetParam( ApplicationExpr *appExpr, Type *polyType );
+                        /// Converts a function call into a call of the adapter with the
+                        /// original function as the first argument (all other arguments
+                        /// are pushed back). May adjust return value.
+                        Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function );
+                        /// Modifies the `arg`, replacing it with a boxed expression
+                        /// that matches `formal` under the current TyVarMap.
+                        void boxParam( Expression *&arg, Type *formal, const TyVarMap &exprTyVars );
+                        /// Box an argument of `appExpr` for each parameter in `function`
+                        /// starting at `arg`.
+                        /// `exprTyVars` is the function's type variables.
+                        void boxParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *function, const TyVarMap &exprTyVars );
+                        /// Boxes each assertion and inserts them into `appExpr` at
+                        /// `arg`. `exprTyVars` is the function's type variables.
+                        void addInferredParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *functionType, const TyVarMap &tyVars );
                         /// Stores assignment operators from assertion list in local map of assignment operations
                         void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
-                        FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
+                        /// Creates an adapter definition from `adaptee` to `realType`, using
+                        /// `mangleName` as the base name for the adapter. `tyVars` is the map of
+                        /// type variables for the function type of the adapted expression.
+                        FunctionDecl *makeAdapter( FunctionType const *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
                         /// Replaces intrinsic operator functions with their arithmetic desugaring
                         Expression *handleIntrinsics( ApplicationExpr *appExpr );
@@ -182 +190 @@
                         ObjectDecl *makeVar( const std::string &name, Type *type, Initializer *init = 0 );
                         /// returns true if the type has a dynamic layout; such a layout will be stored in appropriately-named local variables when the function returns
-                        bool findGeneric( Type *ty );
+                        bool findGeneric( Type const *ty );
                         /// adds type parameters to the layout call; will generate the appropriate parameters if needed
                         void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
@@ -221 +229 @@
         } // anonymous namespace
 
-        /// version of mutateAll with special handling for translation unit so you can check the end of the prelude when debugging
-        template< typename MutatorType >
-        inline void mutateTranslationUnit( std::list< Declaration* > &translationUnit, MutatorType &mutator ) {
-                bool seenIntrinsic = false;
-                SemanticErrorException errors;
-                for ( typename std::list< Declaration* >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
-                        try {
-                                if ( *i ) {
-                                        if ( (*i)->get_linkage() == LinkageSpec::Intrinsic ) {
-                                                seenIntrinsic = true;
-                                        } else if ( seenIntrinsic ) {
-                                                seenIntrinsic = false; // break on this line when debugging for end of prelude
-                                        }
-
-                                        *i = dynamic_cast< Declaration* >( (*i)->acceptMutator( mutator ) );
-                                        assert( *i );
-                                } // if
-                        } catch( SemanticErrorException &e ) {
-                                errors.append( e );
-                        } // try
-                } // for
-                if ( ! errors.isEmpty() ) {
-                        throw errors;
-                } // if
-        }
-
         void box( std::list< Declaration *>& translationUnit ) {
                 PassVisitor<LayoutFunctionBuilder> layoutBuilder;
@@ -263 +245 @@
         ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
 
-        void LayoutFunctionBuilder::previsit( FunctionDecl *functionDecl ) {
-                visit_children = false;
-                maybeAccept( functionDecl->get_functionType(), *visitor );
-                ++functionNesting;
-                maybeAccept( functionDecl->get_statements(), *visitor );
-                --functionNesting;
-        }
-
         /// Get a list of type declarations that will affect a layout function
         std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) {
                 std::list< TypeDecl * > otypeDecls;
 
-                for ( std::list< TypeDecl* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
-                        if ( (*decl)->isComplete() ) {
-                                otypeDecls.push_back( *decl );
+                for ( TypeDecl * const decl : decls ) {
+                        if ( decl->isComplete() ) {
+                                otypeDecls.push_back( decl );
                         }
                 }
@@ -288 +262 @@
                 BasicType sizeAlignType( Type::Qualifiers(), BasicType::LongUnsignedInt );
 
-                for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
-                        TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
+                for ( TypeDecl * const param : otypeParams ) {
+                        TypeInstType paramType( Type::Qualifiers(), param->get_name(), param );
                         std::string paramName = mangleType( &paramType );
                         layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( paramName ), Type::StorageClasses(), LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
@@ -297 +271 @@
 
         /// Builds a layout function declaration
-        FunctionDecl *buildLayoutFunctionDecl( AggregateDecl *typeDecl, unsigned int functionNesting, FunctionType *layoutFnType ) {
+        FunctionDecl *buildLayoutFunctionDecl( AggregateDecl *typeDecl, bool isInFunction, FunctionType *layoutFnType ) {
                 // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
                 // because each unit generates copies of the default routines for each aggregate.
                 FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
-                                                                                                         functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
+                                                                                                         isInFunction ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
                                                                                                          LinkageSpec::AutoGen, layoutFnType, new CompoundStmt(),
                                                                                                          std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
                 layoutDecl->fixUniqueId();
                 return layoutDecl;
-        }
-
-        /// Makes a unary operation
-        Expression *makeOp( const std::string &name, Expression *arg ) {
-                UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->args.push_back( arg );
-                return expr;
         }
 
@@ -380 +347 @@
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, functionNesting, layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl, isInFunction(), layoutFnType );
 
                 // calculate struct layout in function body
@@ -387 +354 @@
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 0 ) ) ) );
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
-                unsigned long n_members = 0;
-                bool firstMember = true;
-                for ( Declaration* member : structDecl->get_members() ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( member );
+                for ( auto index_member : enumerate( structDecl->members ) ) {
+                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( index_member.val );
                         assert( dwt );
                         Type *memberType = dwt->get_type();
 
-                        if ( firstMember ) {
-                                firstMember = false;
-                        } else {
+                        if ( 0 < index_member.idx ) {
                                 // make sure all members after the first (automatically aligned at 0) are properly padded for alignment
                                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( memberType->clone() ) ) );
@@ -402 +365 @@
 
                         // place current size in the current offset index
-                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from_ulong( n_members ) ) ),
+                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from_ulong( index_member.idx ) ) ),
                                                                               derefVar( sizeParam ) ) );
-                        ++n_members;
 
                         // add member size to current size
@@ -439 +401 @@
 
                 // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, functionNesting, layoutFnType );
+                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl, isInFunction(), layoutFnType );
 
                 // calculate union layout in function body
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
                 addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
-                for ( std::list< Declaration* >::const_iterator member = unionDecl->get_members().begin(); member != unionDecl->get_members().end(); ++member ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
+                for ( Declaration * const member : unionDecl->members ) {
+                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( member );
                         assert( dwt );
                         Type *memberType = dwt->get_type();
@@ -464 +426 @@
 
         namespace {
-                std::string makePolyMonoSuffix( FunctionType * function, const TyVarMap &tyVars ) {
+                std::string makePolyMonoSuffix( FunctionType const * function, const TyVarMap &tyVars ) {
                         std::stringstream name;
 
@@ -473 +435 @@
                         // to take those polymorphic types as pointers. Therefore, there can be two different functions
                         // with the same mangled name, so we need to further mangle the names.
-                        for ( std::list< DeclarationWithType *>::iterator retval = function->get_returnVals().begin(); retval != function->get_returnVals().end(); ++retval ) {
-                                if ( isPolyType( (*retval)->get_type(), tyVars ) ) {
+                        for ( DeclarationWithType const * const ret : function->returnVals ) {
+                                if ( isPolyType( ret->get_type(), tyVars ) ) {
                                         name << "P";
                                 } else {
@@ -481 +443 @@
                         }
                         name << "_";
-                        std::list< DeclarationWithType *> &paramList = function->get_parameters();
-                        for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-                                if ( isPolyType( (*arg)->get_type(), tyVars ) ) {
+                        for ( DeclarationWithType const * const arg : function->parameters ) {
+                                if ( isPolyType( arg->get_type(), tyVars ) ) {
                                         name << "P";
                                 } else {
@@ -492 +453 @@
                 }
 
-                std::string mangleAdapterName( FunctionType * function, const TyVarMap &tyVars ) {
+                std::string mangleAdapterName( FunctionType const * function, const TyVarMap &tyVars ) {
                         return SymTab::Mangler::mangle( function ) + makePolyMonoSuffix( function, tyVars );
                 }
@@ -499 +460 @@
                         return "_adapter" + mangleName;
                 }
+
+                /// Replaces a polymorphic type with its concrete equivalant under the current environment (returns itself if concrete).
+                /// If `doClone` is set to false, will not clone interior types
+                Type *replaceWithConcrete( Type *type, TypeSubstitution const * env, bool doClone = true );
 
                 Pass1::Pass1() : tempNamer( "_temp" ) {}
@@ -524 +489 @@
 
                                 std::list< DeclarationWithType *> &paramList = functionType->parameters;
-                                std::list< FunctionType *> functions;
-                                for ( Type::ForallList::iterator tyVar = functionType->forall.begin(); tyVar != functionType->forall.end(); ++tyVar ) {
-                                        for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
-                                                findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter );
+                                std::list< FunctionType const *> functions;
+                                for ( TypeDecl * const tyVar : functionType->forall ) {
+                                        for ( DeclarationWithType * const assert : tyVar->assertions ) {
+                                                findFunction( assert->get_type(), functions, scopeTyVars, needsAdapter );
                                         } // for
                                 } // for
-                                for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-                                        findFunction( (*arg)->get_type(), functions, scopeTyVars, needsAdapter );
+                                for ( DeclarationWithType * const arg : paramList ) {
+                                        findFunction( arg->get_type(), functions, scopeTyVars, needsAdapter );
                                 } // for
 
-                                for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
-                                        std::string mangleName = mangleAdapterName( *funType, scopeTyVars );
+                                for ( FunctionType const * const funType : functions ) {
+                                        std::string mangleName = mangleAdapterName( funType, scopeTyVars );
                                         if ( adapters.find( mangleName ) == adapters.end() ) {
                                                 std::string adapterName = makeAdapterName( mangleName );
-                                                adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), nullptr ) ) );
+                                                adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, nullptr, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), nullptr ) ) );
                                         } // if
                                 } // for
@@ -593 +558 @@
                 }
 
-                void Pass1::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
+                std::list< Expression *>::iterator Pass1::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, const TyVarMap &exprTyVars ) {
+                        assert( env );
+                        std::list< Expression *>::iterator arg = appExpr->args.begin();
                         // pass size/align for type variables
-                        for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
+                        for ( std::pair<std::string, TypeDecl::Data> const & tyParam : exprTyVars ) {
                                 ResolvExpr::EqvClass eqvClass;
-                                assert( env );
-                                if ( tyParm->second.isComplete ) {
-                                        Type *concrete = env->lookup( tyParm->first );
-                                        if ( concrete ) {
-                                                arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
-                                                arg++;
-                                                arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) );
-                                                arg++;
-                                        } else {
-                                                // xxx - should this be an assertion?
-                                                SemanticError( appExpr, toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ) );
-                                        } // if
+                                if ( tyParam.second.isComplete ) {
+                                        Type *concrete = env->lookup( tyParam.first );
+                                        // If there is an unbound type variable, it should have detected already.
+                                        assertf( concrete, "Unbound type variable: %s in: %s",
+                                                toCString( tyParam.first ), toCString( *env ) );
+
+                                        arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
+                                        arg++;
+                                        arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) );
+                                        arg++;
                                 } // if
                         } // for
 
                         // add size/align for generic types to parameter list
-                        if ( ! appExpr->get_function()->result ) return;
+                        if ( ! appExpr->get_function()->result ) return arg;
                         FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
                         assert( funcType );
 
+                        // These iterators don't advance in unison.
                         std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin();
                         std::list< Expression* >::const_iterator fnArg = arg;
@@ -623 +589 @@
                         // a polymorphic return type may need to be added to the argument list
                         if ( polyRetType ) {
-                                Type *concRetType = replaceWithConcrete( appExpr, polyRetType );
+                                Type *concRetType = replaceWithConcrete( polyRetType, env );
                                 passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
                                 ++fnArg; // skip the return parameter in the argument list
@@ -634 +600 @@
                                 passArgTypeVars( appExpr, (*fnParm)->get_type(), argType, arg, exprTyVars, seenTypes );
                         }
+                        return arg;
                 }
 
@@ -642 +609 @@
                 }
 
-                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addRetParam( ApplicationExpr *appExpr, Type *retType ) {
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.
@@ -662 +629 @@
                                 paramExpr = new AddressExpr( paramExpr );
                         } // if
-                        arg = appExpr->args.insert( arg, paramExpr ); // add argument to function call
-                        arg++;
+                        // Add argument to function call.
+                        appExpr->args.push_front( paramExpr );
                         // Build a comma expression to call the function and emulate a normal return.
                         CommaExpr *commaExpr = new CommaExpr( appExpr, retExpr );
@@ -671 +638 @@
                 }
 
-                void Pass1::replaceParametersWithConcrete( ApplicationExpr *appExpr, std::list< Expression* >& params ) {
-                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
-                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                /// Replaces all the type parameters of a generic type with their concrete equivalents under the current environment
+                void replaceParametersWithConcrete( std::list< Expression* >& params, TypeSubstitution const * env ) {
+                        for ( Expression * const param : params ) {
+                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( param );
                                 assertf(paramType, "Aggregate parameters should be type expressions");
-                                paramType->set_type( replaceWithConcrete( appExpr, paramType->get_type(), false ) );
-                        }
-                }
-
-                Type *Pass1::replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone ) {
+                                paramType->set_type( replaceWithConcrete( paramType->get_type(), env, false ) );
+                        }
+                }
+
+                // See forward definition.
+                Type *replaceWithConcrete( Type *type, TypeSubstitution const * env, bool doClone ) {
+                        assert( env );
                         if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
                                 Type *concrete = env->lookup( typeInst->get_name() );
@@ -690 +660 @@
                                         structType = structType->clone();
                                 }
-                                replaceParametersWithConcrete( appExpr, structType->get_parameters() );
+                                replaceParametersWithConcrete( structType->get_parameters(), env );
                                 return structType;
                         } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
@@ -696 +666 @@
                                         unionType = unionType->clone();
                                 }
-                                replaceParametersWithConcrete( appExpr, unionType->get_parameters() );
+                                replaceParametersWithConcrete( unionType->get_parameters(), env );
                                 return unionType;
                         }
@@ -702 +672 @@
                 }
 
-                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType, std::list< Expression *>::iterator &arg ) {
-                        assert( env );
-                        Type *concrete = replaceWithConcrete( appExpr, dynType );
+                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType ) {
+                        Type *concrete = replaceWithConcrete( dynType, env );
                         // add out-parameter for return value
-                        return addRetParam( appExpr, concrete, arg );
-                }
-
-                Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
+                        return addRetParam( appExpr, concrete );
+                }
+
+                Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function ) {
                         Expression *ret = appExpr;
 //                      if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
-                        if ( isDynRet( function, tyVars ) ) {
-                                ret = addRetParam( appExpr, function->returnVals.front()->get_type(), arg );
+                        if ( isDynRet( function, scopeTyVars ) ) {
+                                ret = addRetParam( appExpr, function->returnVals.front()->get_type() );
                         } // if
-                        std::string mangleName = mangleAdapterName( function, tyVars );
+                        std::string mangleName = mangleAdapterName( function, scopeTyVars );
                         std::string adapterName = makeAdapterName( mangleName );
 
@@ -724 +693 @@
 
                         return ret;
-                }
-
-                void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-                        assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
-                        if ( ! needsBoxing( param, arg->result, exprTyVars, env ) ) return;
-
-                        if ( arg->get_lvalue() ) {
-                                // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
-                                // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
-                                //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
-                                //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
-                                //              return;
-                                //      }
-                                // }
-                                arg =  generalizedLvalue( new AddressExpr( arg ) );
-                                if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
-                                        // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
-                                        arg = new CastExpr( arg, param->clone() );
-                                }
-                        } else {
-                                // use type computed in unification to declare boxed variables
-                                Type * newType = param->clone();
-                                if ( env ) env->apply( newType );
-                                ObjectDecl *newObj = ObjectDecl::newObject( tempNamer.newName(), newType, nullptr );
-                                newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
-                                stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
-                                UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
-                                assign->get_args().push_back( new VariableExpr( newObj ) );
-                                assign->get_args().push_back( arg );
-                                stmtsToAddBefore.push_back( new ExprStmt( assign ) );
-                                arg = new AddressExpr( new VariableExpr( newObj ) );
-                        } // if
                 }
 
@@ -791 +728 @@
                 }
 
-                void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
-                        for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->parameters.end(); ++param, ++arg ) {
-                                assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
-                                addCast( *arg, (*param)->get_type(), exprTyVars );
-                                boxParam( (*param)->get_type(), *arg, exprTyVars );
+                void Pass1::boxParam( Expression *&arg, Type *param, const TyVarMap &exprTyVars ) {
+                        assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
+                        addCast( arg, param, exprTyVars );
+                        if ( ! needsBoxing( param, arg->result, exprTyVars, env ) ) return;
+
+                        if ( arg->get_lvalue() ) {
+                                // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
+                                //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
+                                //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
+                                //              return;
+                                //      }
+                                // }
+                                arg = generalizedLvalue( new AddressExpr( arg ) );
+                                if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
+                                        // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
+                                        arg = new CastExpr( arg, param->clone() );
+                                }
+                        } else {
+                                // use type computed in unification to declare boxed variables
+                                Type * newType = param->clone();
+                                if ( env ) env->apply( newType );
+                                ObjectDecl *newObj = makeTemporary( newType );
+                                // TODO: is this right??? (Why wouldn't it be?)
+                                newObj->get_type()->get_qualifiers() = Type::Qualifiers();
+                                // TODO: why doesn't this just use initialization syntax?
+                                // (Possibly to ensure code is run at the right time.)
+                                UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+                                assign->get_args().push_back( new VariableExpr( newObj ) );
+                                assign->get_args().push_back( arg );
+                                stmtsToAddBefore.push_back( new ExprStmt( assign ) );
+                                arg = new AddressExpr( new VariableExpr( newObj ) );
+                        } // if
+                }
+
+                void Pass1::boxParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *function, const TyVarMap &exprTyVars ) {
+                        for ( DeclarationWithType * param : function->parameters ) {
+                                assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
+                                boxParam( *arg, param->get_type(), exprTyVars );
+                                ++arg;
                         } // for
                 }
 
-                void Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
+                void Pass1::addInferredParams( ApplicationExpr *appExpr, std::list< Expression *>::iterator arg, FunctionType *functionType, const TyVarMap &tyVars ) {
                         std::list< Expression *>::iterator cur = arg;
-                        for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
-                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
-                                        InferredParams::const_iterator inferParam = appExpr->inferParams.find( (*assert)->get_uniqueId() );
-                                        assertf( inferParam != appExpr->inferParams.end(), "addInferredParams missing inferred parameter: %s in: %s", toString( *assert ).c_str(), toString( appExpr ).c_str() );
+                        for ( TypeDecl * const tyVar : functionType->forall ) {
+                                for ( DeclarationWithType * const assert : tyVar->assertions ) {
+                                        InferredParams::const_iterator inferParam = appExpr->inferParams.find( assert->get_uniqueId() );
+                                        assertf( inferParam != appExpr->inferParams.end(), "addInferredParams missing inferred parameter: %s in: %s", toString( assert ).c_str(), toString( appExpr ).c_str() );
                                         Expression *newExpr = inferParam->second.expr->clone();
-                                        addCast( newExpr, (*assert)->get_type(), tyVars );
-                                        boxParam( (*assert)->get_type(), newExpr, tyVars );
+                                        boxParam( newExpr, assert->get_type(), tyVars );
                                         appExpr->get_args().insert( cur, newExpr );
                                 } // for
@@ -824 +795 @@
                 }
 
-                FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars ) {
+                FunctionType *makeAdapterType( FunctionType const *adaptee, const TyVarMap &tyVars ) {
                         // actually make the adapter type
                         FunctionType *adapter = adaptee->clone();
@@ -834 +805 @@
                 }
 
-                Expression *makeAdapterArg( DeclarationWithType *param, DeclarationWithType *arg, DeclarationWithType *realParam, const TyVarMap &tyVars ) {
+                Expression *makeAdapterArg(
+                                DeclarationWithType *param,
+                                DeclarationWithType const *arg,
+                                DeclarationWithType const *realParam,
+                                const TyVarMap &tyVars ) {
                         assert( param );
                         assert( arg );
-                        if ( isPolyType( realParam->get_type(), tyVars ) ) {
-                                if ( ! isPolyType( arg->get_type() ) ) {
-                                        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                        deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
-                                        deref->result = arg->get_type()->clone();
-                                        return deref;
-                                } // if
+                        if ( isPolyType( realParam->get_type(), tyVars )
+                                        && ! isPolyType( arg->get_type() ) ) {
+                                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
+                                deref->result = arg->get_type()->clone();
+                                return deref;
                         } // if
                         return new VariableExpr( param );
                 }
 
-                void addAdapterParams( ApplicationExpr *adapteeApp, std::list< DeclarationWithType *>::iterator arg, std::list< DeclarationWithType *>::iterator param, std::list< DeclarationWithType *>::iterator paramEnd, std::list< DeclarationWithType *>::iterator realParam, const TyVarMap &tyVars ) {
+                void addAdapterParams(
+                                ApplicationExpr *adapteeApp,
+                                std::list< DeclarationWithType *>::const_iterator arg,
+                                std::list< DeclarationWithType *>::const_iterator param,
+                                std::list< DeclarationWithType *>::const_iterator paramEnd,
+                                std::list< DeclarationWithType *>::const_iterator realParam,
+                                const TyVarMap &tyVars ) {
                         UniqueName paramNamer( "_p" );
                         for ( ; param != paramEnd; ++param, ++arg, ++realParam ) {
@@ -859 +839 @@
                 }
 
-                FunctionDecl *Pass1::makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
+                FunctionDecl *Pass1::makeAdapter( FunctionType const *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ) {
                         FunctionType *adapterType = makeAdapterType( adaptee, tyVars );
                         adapterType = ScrubTyVars::scrub( adapterType, tyVars );
@@ -876 +856 @@
                         Statement *bodyStmt;
 
-                        Type::ForallList::iterator tyArg = realType->get_forall().begin();
-                        Type::ForallList::iterator tyParam = adapterType->get_forall().begin();
-                        Type::ForallList::iterator realTyParam = adaptee->get_forall().begin();
-                        for ( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) {
-                                assert( tyArg != realType->get_forall().end() );
-                                std::list< DeclarationWithType *>::iterator assertArg = (*tyArg)->get_assertions().begin();
-                                std::list< DeclarationWithType *>::iterator assertParam = (*tyParam)->get_assertions().begin();
-                                std::list< DeclarationWithType *>::iterator realAssertParam = (*realTyParam)->get_assertions().begin();
-                                for ( ; assertParam != (*tyParam)->get_assertions().end(); ++assertArg, ++assertParam, ++realAssertParam ) {
-                                        assert( assertArg != (*tyArg)->get_assertions().end() );
-                                        adapteeApp->get_args().push_back( makeAdapterArg( *assertParam, *assertArg, *realAssertParam, tyVars ) );
+                        for ( auto tys : group_iterate( realType->forall, adapterType->forall, adaptee->forall ) ) {
+                                TypeDecl * tyArg = std::get<0>( tys );
+                                TypeDecl * tyParam = std::get<1>( tys );
+                                TypeDecl * realTyParam = std::get<2>( tys );
+                                for ( auto asserts : group_iterate( tyArg->assertions, tyParam->assertions, realTyParam->assertions ) ) {
+                                        DeclarationWithType * assertArg = std::get<0>( asserts );
+                                        DeclarationWithType * assertParam = std::get<1>( asserts );
+                                        DeclarationWithType * realAssertParam = std::get<2>( asserts );
+                                        adapteeApp->args.push_back( makeAdapterArg( assertParam, assertArg, realAssertParam, tyVars ) );
                                 } // for
                         } // for
 
-                        std::list< DeclarationWithType *>::iterator arg = realType->get_parameters().begin();
-                        std::list< DeclarationWithType *>::iterator param = adapterType->get_parameters().begin();
-                        std::list< DeclarationWithType *>::iterator realParam = adaptee->get_parameters().begin();
+                        std::list< DeclarationWithType *>::const_iterator arg = realType->parameters.begin();
+                        std::list< DeclarationWithType *>::const_iterator param = adapterType->parameters.begin();
+                        std::list< DeclarationWithType *>::const_iterator realParam = adaptee->parameters.begin();
                         param++;                // skip adaptee parameter in the adapter type
                         if ( realType->get_returnVals().empty() ) {
@@ -898 +876 @@
                                 addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
                                 bodyStmt = new ExprStmt( adapteeApp );
-                        } else if ( isDynType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
+                        } else if ( isDynType( adaptee->returnVals.front()->get_type(), tyVars ) ) {
                                 // return type T
                                 if ( (*param)->get_name() == "" ) {
@@ -923 +901 @@
                 void Pass1::passAdapters( ApplicationExpr * appExpr, FunctionType * functionType, const TyVarMap & exprTyVars ) {
                         // collect a list of function types passed as parameters or implicit parameters (assertions)
-                        std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
-                        std::list< FunctionType *> functions;
-                        for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
-                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
-                                        findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter );
+                        std::list<FunctionType const *> functions;
+                        for ( TypeDecl * const tyVar : functionType->get_forall() ) {
+                                for ( DeclarationWithType * const assert : tyVar->get_assertions() ) {
+                                        findFunction( assert->get_type(), functions, exprTyVars, needsAdapter );
                                 } // for
                         } // for
-                        for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-                                findFunction( (*arg)->get_type(), functions, exprTyVars, needsAdapter );
+                        for ( DeclarationWithType * const arg : functionType->get_parameters() ) {
+                                findFunction( arg->get_type(), functions, exprTyVars, needsAdapter );
                         } // for
 
@@ -938 +915 @@
                         std::set< std::string > adaptersDone;
 
-                        for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
-                                FunctionType *originalFunction = (*funType)->clone();
-                                FunctionType *realFunction = (*funType)->clone();
+                        for ( FunctionType const * const funType : functions ) {
+                                FunctionType *originalFunction = funType->clone();
+                                FunctionType *realFunction = funType->clone();
                                 std::string mangleName = SymTab::Mangler::mangle( realFunction );
 
@@ -958 +935 @@
                                         if ( adapter == adapters.end() ) {
                                                 // adapter has not been created yet in the current scope, so define it
-                                                FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
+                                                FunctionDecl *newAdapter = makeAdapter( funType, realFunction, mangleName, exprTyVars );
                                                 std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
                                                 adapter = answer.first;
@@ -972 +949 @@
 
                 Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, Type *polyType, bool isIncr ) {
-                        NameExpr *opExpr;
-                        if ( isIncr ) {
-                                opExpr = new NameExpr( "?+=?" );
-                        } else {
-                                opExpr = new NameExpr( "?-=?" );
-                        } // if
+                        NameExpr *opExpr = new NameExpr( ( isIncr ) ? "?+=?" : "?-=?" );
                         UntypedExpr *addAssign = new UntypedExpr( opExpr );
                         if ( AddressExpr *address = dynamic_cast< AddressExpr *>( appExpr->get_args().front() ) ) {
@@ -1120 +1092 @@
                 Expression *Pass1::postmutate( ApplicationExpr *appExpr ) {
                         // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
-                        // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
-                        //      std::cerr << i->first << " ";
+                        // for ( auto tyVar : scopeTyVars ) {
+                        //      std::cerr << tyVar.first << " ";
                         // }
                         // std::cerr << "\n";
@@ -1134 +1106 @@
 
                         Expression *ret = appExpr;
-
-                        std::list< Expression *>::iterator arg = appExpr->get_args().begin();
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
@@ -1156 +1126 @@
                                 // std::cerr << "dynRetType: " << dynRetType << std::endl;
                                 Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
-                                ret = addDynRetParam( appExpr, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
+                                ret = addDynRetParam( appExpr, concRetType ); // xxx - used to use dynRetType instead of concRetType
                         } else if ( needsAdapter( function, scopeTyVars ) && ! needsAdapter( function, exprTyVars) ) { // xxx - exprTyVars is used above...?
                                 // xxx - the ! needsAdapter check may be incorrect. It seems there is some situation where an adapter is applied where it shouldn't be, and this fixes it for some cases. More investigation is needed.
@@ -1164 +1134 @@
                                 // std::cerr << *env << std::endl;
                                 // change the application so it calls the adapter rather than the passed function
-                                ret = applyAdapter( appExpr, function, arg, scopeTyVars );
+                                ret = applyAdapter( appExpr, function );
                         } // if
-                        arg = appExpr->get_args().begin();
-
-                        Type *concRetType = replaceWithConcrete( appExpr, dynRetType );
-                        passTypeVars( appExpr, concRetType, arg, exprTyVars ); // xxx - used to use dynRetType instead of concRetType; this changed so that the correct type paramaters are passed for return types (it should be the concrete type's parameters, not the formal type's)
-                        addInferredParams( appExpr, function, arg, exprTyVars );
-
-                        arg = paramBegin;
-
-                        boxParams( appExpr, function, arg, exprTyVars );
+
+                        Type *concRetType = replaceWithConcrete( dynRetType, env );
+                        std::list< Expression *>::iterator arg =
+                                passTypeVars( appExpr, concRetType, exprTyVars ); // xxx - used to use dynRetType instead of concRetType; this changed so that the correct type paramaters are passed for return types (it should be the concrete type's parameters, not the formal type's)
+                        addInferredParams( appExpr, arg, function, exprTyVars );
+
+                        // This needs to point at the original first argument.
+                        boxParams( appExpr, paramBegin, function, exprTyVars );
+
                         passAdapters( appExpr, function, exprTyVars );
 
@@ -1180 +1150 @@
                 }
 
-                Expression * Pass1::postmutate( UntypedExpr *expr ) {
+                bool isPolyDeref( UntypedExpr const * expr, TyVarMap const & scopeTyVars, TypeSubstitution const * env ) {
                         if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
-                                if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
+                                if ( auto name = dynamic_cast<NameExpr const *>( expr->function ) ) {
                                         if ( name->name == "*?" ) {
-                                                Expression *ret = expr->args.front();
-                                                expr->args.clear();
-                                                delete expr;
-                                                return ret;
+                                                return true;
                                         } // if
                                 } // if
                         } // if
+                        return false;
+                }
+
+                Expression * Pass1::postmutate( UntypedExpr *expr ) {
+                        if ( isPolyDeref( expr, scopeTyVars, env ) ) {
+                                Expression *ret = expr->args.front();
+                                expr->args.clear();
+                                delete expr;
+                                return ret;
+                        }
                         return expr;
                 }
@@ -1200 +1177 @@
                         bool needs = false;
                         if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->arg ) ) {
-                                if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
-                                        if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
-                                                if ( name->name == "*?" ) {
-                                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->args.front() ) ) {
-                                                                assert( appExpr->function->result );
-                                                                FunctionType *function = getFunctionType( appExpr->function->result );
-                                                                assert( function );
-                                                                needs = needsAdapter( function, scopeTyVars );
-                                                        } // if
-                                                } // if
+                                if ( isPolyDeref( expr, scopeTyVars, env ) ) {
+                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->args.front() ) ) {
+                                                assert( appExpr->function->result );
+                                                FunctionType *function = getFunctionType( appExpr->function->result );
+                                                assert( function );
+                                                needs = needsAdapter( function, scopeTyVars );
                                         } // if
                                 } // if
@@ -1260 +1233 @@
                 void Pass2::addAdapters( FunctionType *functionType ) {
                         std::list< DeclarationWithType *> &paramList = functionType->parameters;
-                        std::list< FunctionType *> functions;
-                        for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-                                Type *orig = (*arg)->get_type();
+                        std::list< FunctionType const *> functions;
+                        for ( DeclarationWithType * const arg : functionType->parameters ) {
+                                Type *orig = arg->get_type();
                                 findAndReplaceFunction( orig, functions, scopeTyVars, needsAdapter );
-                                (*arg)->set_type( orig );
+                                arg->set_type( orig );
                         }
                         std::set< std::string > adaptersDone;
-                        for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
-                                std::string mangleName = mangleAdapterName( *funType, scopeTyVars );
+                        for ( FunctionType const * const funType : functions ) {
+                                std::string mangleName = mangleAdapterName( funType, scopeTyVars );
                                 if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
                                         std::string adapterName = makeAdapterName( mangleName );
                                         // adapter may not be used in body, pass along with unused attribute.
-                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) );
+                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) );
                                         adaptersDone.insert( adaptersDone.begin(), mangleName );
                                 }
@@ -1349 +1322 @@
                         ObjectDecl newPtr( "", Type::StorageClasses(), LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
-                        for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
+                        for ( TypeDecl * const tyParam : funcType->get_forall() ) {
                                 ObjectDecl *sizeParm, *alignParm;
                                 // add all size and alignment parameters to parameter list
-                                if ( (*tyParm)->isComplete() ) {
-                                        TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm );
+                                if ( tyParam->isComplete() ) {
+                                        TypeInstType parmType( Type::Qualifiers(), tyParam->get_name(), tyParam );
                                         std::string parmName = mangleType( &parmType );
 
@@ -1367 +1340 @@
                                 }
                                 // move all assertions into parameter list
-                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
+                                for ( DeclarationWithType * const assert : tyParam->get_assertions() ) {
                                         // assertion parameters may not be used in body, pass along with unused attribute.
-                                        (*assert)->get_attributes().push_back( new Attribute( "unused" ) );
-                                        inferredParams.push_back( *assert );
-                                }
-                                (*tyParm)->get_assertions().clear();
+                                        assert->get_attributes().push_back( new Attribute( "unused" ) );
+                                        inferredParams.push_back( assert );
+                                }
+                                tyParam->get_assertions().clear();
                         }
 
                         // add size/align for generic parameter types to parameter list
                         std::set< std::string > seenTypes; // sizeofName for generic types we've seen
-                        for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) {
-                                Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars );
+                        for ( DeclarationWithType * const fnParam : funcType->get_parameters() ) {
+                                Type *polyType = isPolyType( fnParam->get_type(), scopeTyVars );
                                 if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
                                         std::string typeName = mangleType( polyType );
@@ -1482 +1455 @@
 
                         if(!expect_func_type) {
-                                GuardAction( [this]() {
-                                        knownLayouts.endScope();
-                                        knownOffsets.endScope();
-                                });
                                 // If this is the first function type we see
                                 // Then it's the type of the declaration and we care about it
-                                knownLayouts.beginScope();
-                                knownOffsets.beginScope();
+                                GuardScope( *this );
                         }
 
@@ -1497 +1465 @@
 
                         // make sure that any type information passed into the function is accounted for
-                        for ( std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin(); fnParm != funcType->get_parameters().end(); ++fnParm ) {
+                        for ( DeclarationWithType * const fnParam : funcType->get_parameters() ) {
                                 // condition here duplicates that in Pass2::mutate( FunctionType* )
-                                Type *polyType = isPolyType( (*fnParm)->get_type(), scopeTyVars );
+                                Type *polyType = isPolyType( fnParam->get_type(), scopeTyVars );
                                 if ( polyType && ! dynamic_cast< TypeInstType* >( polyType ) ) {
                                         knownLayouts.insert( mangleType( polyType ) );
@@ -1507 +1475 @@
 
                 /// converts polymorphic type T into a suitable monomorphic representation, currently: __attribute__((aligned(8)) char[size_T]
-                Type * polyToMonoType( Type * declType ) {
+                Type * polyToMonoType( Type const * declType ) {
                         Type * charType = new BasicType( Type::Qualifiers(), BasicType::Kind::Char);
                         Expression * size = new NameExpr( sizeofName( mangleType(declType) ) );
@@ -1572 +1540 @@
                 /// Finds the member in the base list that matches the given declaration; returns its index, or -1 if not present
                 long findMember( DeclarationWithType *memberDecl, std::list< Declaration* > &baseDecls ) {
-                        long i = 0;
-                        for(std::list< Declaration* >::const_iterator decl = baseDecls.begin(); decl != baseDecls.end(); ++decl, ++i ) {
-                                if ( memberDecl->get_name() != (*decl)->get_name() )
+                        for ( auto pair : enumerate( baseDecls ) ) {
+                                Declaration * decl = pair.val;
+                                size_t i = pair.idx;
+                                if ( memberDecl->get_name() != decl->get_name() )
                                         continue;
 
                                 if ( memberDecl->get_name().empty() ) {
                                         // plan-9 field: match on unique_id
-                                        if ( memberDecl->get_uniqueId() == (*decl)->get_uniqueId() )
+                                        if ( memberDecl->get_uniqueId() == decl->get_uniqueId() )
                                                 return i;
                                         else
@@ -1585 +1554 @@
                                 }
 
-                                DeclarationWithType *declWithType = strict_dynamic_cast< DeclarationWithType* >( *decl );
+                                DeclarationWithType *declWithType = strict_dynamic_cast< DeclarationWithType* >( decl );
 
                                 if ( memberDecl->get_mangleName().empty() || declWithType->get_mangleName().empty() ) {
@@ -1603 +1572 @@
 
                 /// Returns an index expression into the offset array for a type
-                Expression *makeOffsetIndex( Type *objectType, long i ) {
+                Expression *makeOffsetIndex( Type const *objectType, long i ) {
                         ConstantExpr *fieldIndex = new ConstantExpr( Constant::from_ulong( i ) );
                         UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) );
@@ -1696 +1665 @@
 
                 void PolyGenericCalculator::addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams ) {
-                        for ( std::list< Type* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
-                                if ( findGeneric( *param ) ) {
+                        for ( Type * const param : otypeParams ) {
+                                if ( findGeneric( param ) ) {
                                         // push size/align vars for a generic parameter back
-                                        std::string paramName = mangleType( *param );
+                                        std::string paramName = mangleType( param );
                                         layoutCall->get_args().push_back( new NameExpr( sizeofName( paramName ) ) );
                                         layoutCall->get_args().push_back( new NameExpr( alignofName( paramName ) ) );
                                 } else {
-                                        layoutCall->get_args().push_back( new SizeofExpr( (*param)->clone() ) );
-                                        layoutCall->get_args().push_back( new AlignofExpr( (*param)->clone() ) );
+                                        layoutCall->get_args().push_back( new SizeofExpr( param->clone() ) );
+                                        layoutCall->get_args().push_back( new AlignofExpr( param->clone() ) );
                                 }
                         }
@@ -1710 +1679 @@
 
                 /// returns true if any of the otype parameters have a dynamic layout and puts all otype parameters in the output list
-                bool findGenericParams( std::list< TypeDecl* > &baseParams, std::list< Expression* > &typeParams, std::list< Type* > &out ) {
+                bool findGenericParams( std::list< TypeDecl* > const &baseParams, std::list< Expression* > const &typeParams, std::list< Type* > &out ) {
                         bool hasDynamicLayout = false;
 
-                        std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin();
-                        std::list< Expression* >::const_iterator typeParam = typeParams.begin();
-                        for ( ; baseParam != baseParams.end() && typeParam != typeParams.end(); ++baseParam, ++typeParam ) {
+                        for ( auto paramPair : group_iterate( baseParams, typeParams ) ) {
+                                TypeDecl * baseParam = std::get<0>( paramPair );
+                                Expression * typeParam = std::get<1>( paramPair );
                                 // skip non-otype parameters
-                                if ( ! (*baseParam)->isComplete() ) continue;
-                                TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( *typeParam );
+                                if ( ! baseParam->isComplete() ) continue;
+                                TypeExpr *typeExpr = dynamic_cast< TypeExpr* >( typeParam );
                                 assert( typeExpr && "all otype parameters should be type expressions" );
 
@@ -1725 +1694 @@
                                 if ( isPolyType( type ) ) hasDynamicLayout = true;
                         }
-                        assert( baseParam == baseParams.end() && typeParam == typeParams.end() );
 
                         return hasDynamicLayout;
                 }
 
-                bool PolyGenericCalculator::findGeneric( Type *ty ) {
+                bool PolyGenericCalculator::findGeneric( Type const *ty ) {
                         ty = replaceTypeInst( ty, env );
 
-                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
+                        if ( auto typeInst = dynamic_cast< TypeInstType const * >( ty ) ) {
                                 if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
                                         // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
@@ -1739 +1707 @@
                                 }
                                 return false;
-                        } else if ( StructInstType *structTy = dynamic_cast< StructInstType* >( ty ) ) {
+                        } else if ( auto structTy = dynamic_cast< StructInstType const * >( ty ) ) {
                                 // check if this type already has a layout generated for it
                                 std::string typeName = mangleType( ty );
@@ -1746 +1714 @@
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
                                 std::list< Type* > otypeParams;
-                                if ( ! findGenericParams( *structTy->get_baseParameters(), structTy->get_parameters(), otypeParams ) ) return false;
+                                if ( ! findGenericParams( *structTy->get_baseParameters(), structTy->parameters, otypeParams ) ) return false;
 
                                 // insert local variables for layout and generate call to layout function
@@ -1776 +1744 @@
 
                                 return true;
-                        } else if ( UnionInstType *unionTy = dynamic_cast< UnionInstType* >( ty ) ) {
+                        } else if ( auto unionTy = dynamic_cast< UnionInstType const * >( ty ) ) {
                                 // check if this type already has a layout generated for it
                                 std::string typeName = mangleType( ty );
@@ -1783 +1751 @@
                                 // check if any of the type parameters have dynamic layout; if none do, this type is (or will be) monomorphized
                                 std::list< Type* > otypeParams;
-                                if ( ! findGenericParams( *unionTy->get_baseParameters(), unionTy->get_parameters(), otypeParams ) ) return false;
+                                if ( ! findGenericParams( *unionTy->get_baseParameters(), unionTy->parameters, otypeParams ) ) return false;
 
                                 // insert local variables for layout and generate call to layout function
@@ -1881 +1849 @@
                                         // build initializer list for offset array
                                         std::list< Initializer* > inits;
-                                        for ( std::list< Declaration* >::const_iterator member = baseMembers.begin(); member != baseMembers.end(); ++member ) {
-                                                if ( DeclarationWithType *memberDecl = dynamic_cast< DeclarationWithType* >( *member ) ) {
-                                                        inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
-                                                } else {
-                                                        assertf( false, "Requesting offset of Non-DWT member: %s", toString( *member ).c_str() );
-                                                }
+                                        for ( Declaration * const member : baseMembers ) {
+                                                DeclarationWithType *memberDecl = dynamic_cast< DeclarationWithType* >( member );
+                                                assertf( memberDecl, "Requesting offset of Non-DWT member: %s", toString( member ).c_str() );
+                                                inits.push_back( new SingleInit( new OffsetofExpr( ty->clone(), memberDecl ) ) );
                                         }
 
@@ -1965 +1931 @@
 // compile-command: "make install" //
 // End: //
+

src/GenPoly/FindFunction.cc

@@ -29 +29 @@
         class FindFunction : public WithGuards, public WithVisitorRef<FindFunction>, public WithShortCircuiting {
           public:
-                FindFunction( std::list< FunctionType* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate );
+                FindFunction( std::list< FunctionType const* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate );
 
                 void premutate( FunctionType * functionType );
@@ -37 +37 @@
                 void handleForall( const Type::ForallList &forall );
 
-                std::list< FunctionType* > &functions;
+                std::list< FunctionType const * > & functions;
                 TyVarMap tyVars;
                 bool replaceMode;
@@ -43 +43 @@
         };
 
-        void findFunction( Type *type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
+        void findFunction( Type *type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
                 PassVisitor<FindFunction> finder( functions, tyVars, false, predicate );
                 type->acceptMutator( finder );
         }
 
-        void findAndReplaceFunction( Type *&type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
+        void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
                 PassVisitor<FindFunction> finder( functions, tyVars, true, predicate );
                 type = type->acceptMutator( finder );
         }
 
-        FindFunction::FindFunction( std::list< FunctionType* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate )
+        FindFunction::FindFunction( std::list< FunctionType const * > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate )
                 : functions( functions ), tyVars( tyVars ), replaceMode( replaceMode ), predicate( predicate ) {
         }

src/GenPoly/FindFunction.h

@@ -27 +27 @@
 
         /// recursively walk `type`, placing all functions that match `predicate` under `tyVars` into `functions`
-        void findFunction( Type *type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
+        void findFunction( Type *type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
         /// like `findFunction`, but also replaces the function type with void ()(void)
-        void findAndReplaceFunction( Type *&type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
+        void findAndReplaceFunction( Type *&type, std::list< FunctionType const * > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
 } // namespace GenPoly
 

src/GenPoly/GenPoly.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Oct  7 15:25:00 2022
-// Update Count     : 16
+// Last Modified On : Mon Oct 24 15:19:00 2022
+// Update Count     : 17
 //
 
@@ -118 +118 @@
         }
 
+        const Type* replaceTypeInst( const Type* type, const TypeSubstitution* env ) {
+                if ( ! env ) return type;
+                if ( auto typeInst = dynamic_cast< const TypeInstType* >( type ) ) {
+                        Type *newType = env->lookup( typeInst->get_name() );
+                        if ( newType ) return newType;
+                }
+                return type;
+        }
+
         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)) {
+                if ( auto typeInst = dynamic_cast<const ast::TypeInstType*>(type) ) {
                         auto newType = env->lookup(typeInst);
                         if (newType) return newType;
@@ -194 +203 @@
 
         if ( auto inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
-                if ( typeVars.find( inst->typeString() ) != typeVars.end() ) return type;
+                if ( typeVars.find( *inst ) != typeVars.end() ) return type;
         } else if ( auto array = dynamic_cast< const ast::ArrayType * >( type ) ) {
                 return isPolyType( array->base, subst );
@@ -227 +236 @@
 
         if ( auto inst = dynamic_cast<ast::TypeInstType const *>( type ) ) {
-                auto var = typeVars.find( inst->name );
+                auto var = typeVars.find( *inst );
                 if ( var != typeVars.end() && var->second.isComplete ) {
-
+                        return inst;
                 }
         } else if ( auto inst = dynamic_cast<ast::StructInstType const *>( type ) ) {
@@ -784 +793 @@
 
 void addToTypeVarMap( const ast::TypeInstType * type, TypeVarMap & typeVars ) {
-        typeVars.insert( type->typeString(), ast::TypeDecl::Data( type->base ) );
+        typeVars.insert( *type, ast::TypeDecl::Data( type->base ) );
 }
 
@@ -816 +825 @@
         }
 
-void printTypeVarMap( std::ostream &os, const TypeVarMap & typeVars ) {
-        for ( auto const & pair : typeVars ) {
-                os << pair.first << " (" << pair.second << ") ";
-        } // for
-        os << std::endl;
-}
-
 } // namespace GenPoly
 

src/GenPoly/GenPoly.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Oct  7 15:06:00 2022
-// Update Count     : 9
+// Last Modified On : Mon Oct 24 15:18:00 2022
+// Update Count     : 11
 //
 
@@ -22 +22 @@
 #include "AST/Decl.hpp"           // for TypeDecl::Data
 #include "AST/Fwd.hpp"            // for ApplicationExpr, BaseInstType, Func...
+#include "AST/Type.hpp"           // for TypeInstType::TypeEnvKey
 #include "SymTab/Mangler.h"       // for Mangler
 #include "SynTree/Declaration.h"  // for TypeDecl::Data, AggregateDecl, Type...
@@ -28 +29 @@
 namespace GenPoly {
 
-        // TODO Via some tricks this works for ast::TypeDecl::Data as well.
         typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
-        using TypeVarMap = ErasableScopedMap< std::string, ast::TypeDecl::Data >;
+        using TypeVarMap = ErasableScopedMap< ast::TypeInstType::TypeEnvKey, ast::TypeDecl::Data >;
 
         /// Replaces a TypeInstType by its referrent in the environment, if applicable
         Type* replaceTypeInst( Type* type, const TypeSubstitution* env );
+        const Type* replaceTypeInst( const Type* type, const TypeSubstitution* env );
+        const ast::Type * replaceTypeInst( const ast::Type *, const ast::TypeSubstitution * );
 
         /// returns polymorphic type if is polymorphic type, NULL otherwise; will look up substitution in env if provided
@@ -53 +55 @@
         /// true iff function has dynamic-layout return type under the type variable map generated from its forall-parameters
         ReferenceToType *isDynRet( FunctionType *function );
+        const ast::BaseInstType *isDynRet( const ast::FunctionType * func );
 
         /// A function needs an adapter if it returns a dynamic-layout value or if any of its parameters have dynamic-layout type
@@ -112 +115 @@
         /// Prints type variable map
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap );
-        void printTypeVarMap( std::ostream &os, const TypeVarMap & typeVars );
 
         /// Gets the mangled name of this type; alias for SymTab::Mangler::mangleType().
-        inline std::string mangleType( Type *ty ) { return SymTab::Mangler::mangleType( ty ); }
+        inline std::string mangleType( const Type *ty ) { return SymTab::Mangler::mangleType( ty ); }
 
         /// Gets the name of the sizeof parameter for the type, given its mangled name
@@ -128 +130 @@
         /// Gets the name of the layout function for a given aggregate type, given its declaration
         inline std::string layoutofName( AggregateDecl *decl ) { return std::string( "_layoutof_" ) + decl->get_name(); }
+        inline std::string layoutofName( ast::AggregateDecl const * decl ) {
+                return std::string( "_layoutof_" ) + decl->name;
+        }
 
 } // namespace GenPoly

src/GenPoly/InstantiateGenericNew.cpp

@@ -10 +10 @@
 // Created On       : Tue Aug 16 10:51:00 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Sep 13 16:03:00 2022
-// Update Count     : 0
+// Last Modified On : Mon Oct 31 16:48:00 2022
+// Update Count     : 1
 //
 
@@ -378 +378 @@
                 //   Ptr(int) p;
                 //   int i;
+                // The original expression:
                 //   p.x = &i;
-                // becomes
-                //   int *& _dtype_static_member_0 = (int **)&p.x;
-                //   _dtype_static_member_0 = &i;
+                // Becomes the expression/declaration:
+                //   int *& _dtype_static_member_0;
+                //   (_dtype_static_member_0 = (int**)&p.x,
+                //    _dtype_static_member_0) = &i;
+
+                // The declaration is simple:
                 static UniqueName tmpNamer( "_dtype_static_member_" );
-                ast::Expr * init = new ast::CastExpr( location,
-                        new ast::AddressExpr( location, memberExpr ),
-                        new ast::PointerType( ast::deepCopy( concType ) ),
-                        ast::ExplicitCast
-                );
                 ast::ObjectDecl * tmp = new ast::ObjectDecl( location,
                         tmpNamer.newName(),
                         new ast::ReferenceType( concType ),
-                        new ast::SingleInit( location, init ),
+                        nullptr,
                         ast::Storage::Classes(),
                         ast::Linkage::C
                 );
                 stmtsToAddBefore.push_back( new ast::DeclStmt( location, tmp ) );
-                return new ast::VariableExpr( location, tmp );
+
+                // The expression is more complex, uses references and reference /
+                // pointer parity. But breaking it up risks reordering.
+                return new ast::CommaExpr( location,
+                        ast::UntypedExpr::createAssign( location,
+                                new ast::VariableExpr( location, tmp ),
+                                new ast::CastExpr( location,
+                                        new ast::AddressExpr( location, memberExpr ),
+                                        new ast::PointerType( ast::deepCopy( concType ) ),
+                                        ast::ExplicitCast
+                                )
+                        ),
+                        new ast::VariableExpr( location, tmp )
+                );
         } else {
                 // Here, it can simply add a cast to actual types.
@@ -476 +488 @@
 };
 
-// I think this and the UnionInstType can be made into a template function.
 ast::Type const * GenericInstantiator::postvisit(
                 ast::StructInstType const * inst ) {

src/GenPoly/ScrubTyVars.cc

@@ -20 +20 @@
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::const_it...
 #include "ScrubTyVars.h"
-#include "SymTab/Mangler.h"             // for mangle, typeMode
+#include "SymTab/Mangler.h"             // for mangleType
 #include "SynTree/Declaration.h"        // for TypeDecl, TypeDecl::Data, Typ...
 #include "SynTree/Expression.h"         // for Expression (ptr only), NameExpr
@@ -195 +195 @@
         }
 
-        auto typeVar = typeVars->find( type->name );
+        auto typeVar = typeVars->find( *type );
         if ( typeVar == typeVars->end() ) {
                 return type;
@@ -227 +227 @@
         if ( dynType ) {
                 return new ast::NameExpr( expr->location,
-                        sizeofName( Mangle::mangle( dynType, Mangle::typeMode() ) ) );
+                        sizeofName( Mangle::mangleType( dynType ) ) );
         } else {
                 return expr;
@@ -237 +237 @@
         if ( dynType ) {
                 return new ast::NameExpr( expr->location,
-                        alignofName( Mangle::mangle( dynType, Mangle::typeMode() ) ) );
+                        alignofName( Mangle::mangleType( dynType ) ) );
         } else {
                 return expr;

src/Parser/DeclarationNode.cc

@@ -27 +27 @@
 #include "SynTree/LinkageSpec.h"   // for Spec, linkageName, Cforall
 #include "SynTree/Attribute.h"     // for Attribute
-#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, Declaration
+#include "SynTree/Declaration.h"   // for TypeDecl, ObjectDecl, InlineMemberDecl, Declaration
 #include "SynTree/Expression.h"    // for Expression, ConstantExpr
 #include "SynTree/Statement.h"     // for AsmStmt
@@ -1165 +1165 @@
                 SemanticError( this, "invalid function specifier for " );
         } // if
+        if ( enumInLine ) {
+                return new InlineMemberDecl( *name, storageClasses, linkage, nullptr );
+        } // if
         assertf( name, "ObjectDecl must a have name\n" );
         return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );

src/Parser/ExpressionNode.cc

@@ -519 +519 @@
                 }
         }
-        auto ret =  new QualifiedNameExpr( newDecl, name->name );
-        if ( auto e = dynamic_cast<EnumDecl*>(newDecl) ) {
-                auto enumInst = new EnumInstType( Type::Qualifiers(), e );
-                auto obj = new ObjectDecl( name->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, enumInst, nullptr );
-        }
-        return ret;
+        return new QualifiedNameExpr( newDecl, name->name );
 }
 

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Oct 18 16:22:15 2022
-// Update Count     : 937
+// Last Modified On : Wed Nov  2 21:27:07 2022
+// Update Count     : 939
 //
 
@@ -168 +168 @@
         Ctor, Dtor,
 }; // OperKinds
+
+enum class EnumHiding { Visible, Hide };
 
 struct LabelNode {

src/Parser/TypeData.cc

@@ -925 +925 @@
         for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->enumInLine ) {
-                        // Tell the compiler this is a inline value placeholder
-                        ObjectDecl * member = dynamic_cast< ObjectDecl* >(* members);
-                        member->enumInLine = true;
-                }
-                if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
+                        // Do Nothing
+                } else if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
                         SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
                 } else if ( cur->has_enumeratorValue() ) {

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Oct 14 14:04:43 2022
-// Update Count     : 5751
+// Last Modified On : Wed Nov  2 21:31:21 2022
+// Update Count     : 5810
 //
 
@@ -278 +278 @@
 
 // Types declaration for productions
+
 %union {
         Token tok;
@@ -290 +291 @@
         CondCtl * ifctl;
         ForCtrl * fctl;
-        enum OperKinds compop;
+        OperKinds compop;
         LabelNode * label;
         InitializerNode * in;
@@ -296 +297 @@
         std::string * str;
         bool flag;
+        EnumHiding hide;
         CatchStmt::Kind catch_kind;
         GenericExpr * genexpr;
@@ -364 +366 @@
 %type<constant> string_literal
 %type<str> string_literal_list
+
+%type<hide> hide_opt                                    visible_hide_opt
 
 // expressions
@@ -2553 +2557 @@
         | ENUM attribute_list_opt identifier
                 { typedefTable.makeTypedef( *$3 ); }
-          '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( $3, $6, true, false )->addQualifiers( $2 ); }
+          hide_opt '{' enumerator_list comma_opt '}'
+          { $$ = DeclarationNode::newEnum( $3, $7, true, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt typedef_name                          // unqualified type name
-          '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( $3->name, $5, true, false )->addQualifiers( $2 ); }
+          hide_opt '{' enumerator_list comma_opt '}'
+                { $$ = DeclarationNode::newEnum( $3->name, $6, true, false )->addQualifiers( $2 ); }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
                 {
@@ -2574 +2578 @@
                         typedefTable.makeTypedef( *$6 );
                 }
-          '{' enumerator_list comma_opt '}'
-                {
-                        $$ = DeclarationNode::newEnum( $6, $10, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
+          hide_opt '{' enumerator_list comma_opt '}'
+                {
+                        $$ = DeclarationNode::newEnum( $6, $11, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
                 }
         | ENUM '(' ')' attribute_list_opt identifier attribute_list_opt
-          '{' enumerator_list comma_opt '}'
-                {
-                        $$ = DeclarationNode::newEnum( $5, $8, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
-                }
-        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
-                {
-                        $$ = DeclarationNode::newEnum( $6->name, $9, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
-                }
-        | ENUM '(' ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
-                {
-                        $$ = DeclarationNode::newEnum( $5->name, $8, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
+          hide_opt '{' enumerator_list comma_opt '}'
+                {
+                        $$ = DeclarationNode::newEnum( $5, $9, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
+                }
+        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt
+          hide_opt '{' enumerator_list comma_opt '}'
+                {
+                        $$ = DeclarationNode::newEnum( $6->name, $10, true, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
+                }
+        | ENUM '(' ')' attribute_list_opt typedef_name attribute_list_opt
+          hide_opt '{' enumerator_list comma_opt '}'
+                {
+                        $$ = DeclarationNode::newEnum( $5->name, $9, true, true, nullptr )->addQualifiers( $4 )->addQualifiers( $6 );
                 }
         | enum_type_nobody
+        ;
+
+hide_opt:
+        // empty
+                { $$ = EnumHiding::Visible; }
+        | '!'
+                { $$ = EnumHiding::Hide; }
         ;
 
@@ -2602 +2615 @@
 
 enumerator_list:
-        identifier_or_type_name enumerator_value_opt
-                { $$ = DeclarationNode::newEnumValueGeneric( $1, $2 ); }
+        visible_hide_opt identifier_or_type_name enumerator_value_opt
+                { $$ = DeclarationNode::newEnumValueGeneric( $2, $3 ); }
         | INLINE type_name
                 { $$ = DeclarationNode::newEnumInLine( *$2->type->symbolic.name ); }
-        | enumerator_list ',' identifier_or_type_name enumerator_value_opt
-                { $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( $3, $4 ) ); }
+        | enumerator_list ',' visible_hide_opt identifier_or_type_name enumerator_value_opt
+                { $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( $4, $5 ) ); }
         | enumerator_list ',' INLINE type_name enumerator_value_opt
                 { $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ) ); }
+        ;
+
+visible_hide_opt:
+        hide_opt
+        | '^'
+                { $$ = EnumHiding::Visible; }
         ;
 

src/ResolvExpr/CommonType.cc

@@ -991 +991 @@
                                 add_qualifiers( result, type2->qualifiers );
                         } else {
-                                // xxx - does unifying a ref with typed enumInst makes sense?
                                 if (!dynamic_cast<const ast::EnumInstType *>(type2))
                                         result = commonType( type2, ref, tenv, need, have, open, widen, symtab );
@@ -1010 +1009 @@
 
                 void postvisit( const ast::EnumInstType * enumInst ) {
-                        // reuse BasicType/EnumInstType common type by swapping
-                        // xxx - is this already handled by unify?
                         if (!dynamic_cast<const ast::EnumInstType *>(type2))
                                 result = commonType( type2, enumInst, tenv, need, have, open, widen, symtab);

src/ResolvExpr/ConversionCost.cc

@@ -720 +720 @@
                 costCalc( baseType, dst, srcIsLvalue, symtab, env );
         } else {
-                (void)enumInstType;
                 static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
                 cost = costCalc( integer, dst, srcIsLvalue, symtab, env );

src/ResolvExpr/SatisfyAssertions.cpp

@@ -268 +268 @@
                 ast::ptr< ast::Type > resType = cand.expr->result;
                 cand.env.apply( resType );
-                return Mangle::mangle( resType, Mangle::typeMode() );
+                return Mangle::mangleType( resType );
         }
 

src/SymTab/Mangler.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:40:29 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 11 21:56:06 2021
-// Update Count     : 74
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct 21 16:18:00 2022
+// Update Count     : 75
 //
 #include "Mangler.h"
@@ -418 +418 @@
                         void postvisit( const ast::QualifiedType * qualType );
 
-                        std::string get_mangleName() { return mangleName; }
+                        /// The result is the current constructed mangled name.
+                        std::string result() const { return mangleName; }
                   private:
                         std::string mangleName;         ///< Mangled name being constructed
@@ -444 +445 @@
         } // namespace
 
-
         std::string mangle( const ast::Node * decl, Mangle::Mode mode ) {
-                ast::Pass<Mangler_new> mangler( mode );
-                maybeAccept( decl, mangler );
-                return mangler.core.get_mangleName();
+                return ast::Pass<Mangler_new>::read( decl, mode );
         }
 
@@ -689 +687 @@
                                         } // for
                                         for ( auto & assert : ptype->assertions ) {
-                                                ast::Pass<Mangler_new> sub_mangler(
-                                                        mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
-                                                assert->var->accept( sub_mangler );
-                                                assertionNames.push_back( sub_mangler.core.get_mangleName() );
+                                                assertionNames.push_back( ast::Pass<Mangler_new>::read(
+                                                        assert->var.get(),
+                                                        mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums ) );
                                                 acount++;
                                         } // for

src/SymTab/Mangler.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:44:03 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:45:30 2017
-// Update Count     : 15
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Oct 27 11:58:00 2022
+// Update Count     : 16
 //
 
@@ -22 +22 @@
 
 #include "AST/Bitfield.hpp"
-#include "AST/Fwd.hpp"
 #include "SynTree/SynTree.h"  // for Types
 #include "SynTree/Visitor.h"  // for Visitor, maybeAccept
@@ -33 +32 @@
 // * Currently name compression is not implemented.
 
+namespace ast {
+        class Node;
+}
 namespace ResolvExpr {
         class TypeEnvironment;
@@ -101 +103 @@
         using Mode = bitfield<mangle_flags>;
 
-        static inline Mode typeMode() { return NoOverrideable | Type; }
+        /// Mangle declaration name.
+        std::string mangle( const ast::Node * decl, Mode mode = {} );
 
-        /// Mangle declaration name
-        std::string mangle( const ast::Node * decl, Mode mode = {} );
+        /// Most common mangle configuration for types.
+        static inline std::string mangleType( const ast::Node * type ) {
+                return mangle( type, { NoOverrideable | Type } );
+        }
 
         namespace Encoding {

src/SymTab/Validate.cc

@@ -47 +47 @@
 #include <utility>                     // for pair
 
-#include "AST/Chain.hpp"
-#include "AST/Decl.hpp"
-#include "AST/Node.hpp"
-#include "AST/Pass.hpp"
-#include "AST/SymbolTable.hpp"
-#include "AST/Type.hpp"
-#include "AST/TypeSubstitution.hpp"
 #include "CodeGen/CodeGenerator.h"     // for genName
 #include "CodeGen/OperatorTable.h"     // for isCtorDtor, isCtorDtorAssign
@@ -1326 +1319 @@
         }
 
-namespace {
-        /// Replaces enum types by int, and function/array types in function parameter and return
-        /// lists by appropriate pointers
-        /*
-        struct EnumAndPointerDecay_new {
-                const ast::EnumDecl * previsit( const ast::EnumDecl * enumDecl ) {
-                        // set the type of each member of the enumeration to be EnumConstant
-                        for ( unsigned i = 0; i < enumDecl->members.size(); ++i ) {
-                                // build new version of object with EnumConstant
-                                ast::ptr< ast::ObjectDecl > obj =
-                                        enumDecl->members[i].strict_as< ast::ObjectDecl >();
-                                obj.get_and_mutate()->type =
-                                        new ast::EnumInstType{ enumDecl->name, ast::CV::Const };
-
-                                // set into decl
-                                ast::EnumDecl * mut = mutate( enumDecl );
-                                mut->members[i] = obj.get();
-                                enumDecl = mut;
-                        }
-                        return enumDecl;
-                }
-
-                static const ast::FunctionType * fixFunctionList(
-                        const ast::FunctionType * func,
-                        std::vector< ast::ptr< ast::DeclWithType > > ast::FunctionType::* field,
-                        ast::ArgumentFlag isVarArgs = ast::FixedArgs
-                ) {
-                        const auto & dwts = func->* field;
-                        unsigned nvals = dwts.size();
-                        bool hasVoid = false;
-                        for ( unsigned i = 0; i < nvals; ++i ) {
-                                func = ast::mutate_field_index( func, field, i, fixFunction( dwts[i], hasVoid ) );
-                        }
-
-                        // the only case in which "void" is valid is where it is the only one in the list
-                        if ( hasVoid && ( nvals > 1 || isVarArgs ) ) {
-                                SemanticError(
-                                        dwts.front()->location, func, "invalid type void in function type" );
-                        }
-
-                        // one void is the only thing in the list, remove it
-                        if ( hasVoid ) {
-                                func = ast::mutate_field(
-                                        func, field, std::vector< ast::ptr< ast::DeclWithType > >{} );
-                        }
-
-                        return func;
-                }
-
-                const ast::FunctionType * previsit( const ast::FunctionType * func ) {
-                        func = fixFunctionList( func, &ast::FunctionType::params, func->isVarArgs );
-                        return fixFunctionList( func, &ast::FunctionType::returns );
-                }
-        };
-
-        /// expand assertions from a trait instance, performing appropriate type variable substitutions
-        void expandAssertions(
-                const ast::TraitInstType * inst, std::vector< ast::ptr< ast::DeclWithType > > & out
-        ) {
-                assertf( inst->base, "Trait instance not linked to base trait: %s", toCString( inst ) );
-
-                // build list of trait members, substituting trait decl parameters for instance parameters
-                ast::TypeSubstitution sub{
-                        inst->base->params.begin(), inst->base->params.end(), inst->params.begin() };
-                // deliberately take ast::ptr by-value to ensure this does not mutate inst->base
-                for ( ast::ptr< ast::Decl > decl : inst->base->members ) {
-                        auto member = decl.strict_as< ast::DeclWithType >();
-                        sub.apply( member );
-                        out.emplace_back( member );
-                }
-        }
-
-        /// Associates forward declarations of aggregates with their definitions
-        class LinkReferenceToTypes_new final
-        : public ast::WithSymbolTable, public ast::WithGuards, public
-          ast::WithVisitorRef<LinkReferenceToTypes_new>, public ast::WithShortCircuiting {
-
-                // these maps of uses of forward declarations of types need to have the actual type
-                // declaration switched in * after * they have been traversed. To enable this in the
-                // ast::Pass framework, any node that needs to be so mutated has mutate() called on it
-                // before it is placed in the map, properly updating its parents in the usual traversal,
-                // then can have the actual mutation applied later
-                using ForwardEnumsType = std::unordered_multimap< std::string, ast::EnumInstType * >;
-                using ForwardStructsType = std::unordered_multimap< std::string, ast::StructInstType * >;
-                using ForwardUnionsType = std::unordered_multimap< std::string, ast::UnionInstType * >;
-
-                const CodeLocation & location;
-                const ast::SymbolTable * localSymtab;
-
-                ForwardEnumsType forwardEnums;
-                ForwardStructsType forwardStructs;
-                ForwardUnionsType forwardUnions;
-
-                /// true if currently in a generic type body, so that type parameter instances can be
-                /// renamed appropriately
-                bool inGeneric = false;
-
-        public:
-                /// contstruct using running symbol table
-                LinkReferenceToTypes_new( const CodeLocation & loc )
-                : location( loc ), localSymtab( &symtab ) {}
-
-                /// construct using provided symbol table
-                LinkReferenceToTypes_new( const CodeLocation & loc, const ast::SymbolTable & syms )
-                : location( loc ), localSymtab( &syms ) {}
-
-                const ast::Type * postvisit( const ast::TypeInstType * typeInst ) {
-                        // ensure generic parameter instances are renamed like the base type
-                        if ( inGeneric && typeInst->base ) {
-                                typeInst = ast::mutate_field(
-                                        typeInst, &ast::TypeInstType::name, typeInst->base->name );
-                        }
-
-                        if (
-                                auto typeDecl = dynamic_cast< const ast::TypeDecl * >(
-                                        localSymtab->lookupType( typeInst->name ) )
-                        ) {
-                                typeInst = ast::mutate_field( typeInst, &ast::TypeInstType::kind, typeDecl->kind );
-                        }
-
-                        return typeInst;
-                }
-
-                const ast::Type * postvisit( const ast::EnumInstType * inst ) {
-                        const ast::EnumDecl * decl = localSymtab->lookupEnum( inst->name );
-                        // not a semantic error if the enum is not found, just an implicit forward declaration
-                        if ( decl ) {
-                                inst = ast::mutate_field( inst, &ast::EnumInstType::base, decl );
-                        }
-                        if ( ! decl || ! decl->body ) {
-                                // forward declaration
-                                auto mut = mutate( inst );
-                                forwardEnums.emplace( inst->name, mut );
-                                inst = mut;
-                        }
-                        return inst;
-                }
-
-                void checkGenericParameters( const ast::BaseInstType * inst ) {
-                        for ( const ast::Expr * param : inst->params ) {
-                                if ( ! dynamic_cast< const ast::TypeExpr * >( param ) ) {
-                                        SemanticError(
-                                                location, inst, "Expression parameters for generic types are currently "
-                                                "unsupported: " );
-                                }
-                        }
-                }
-
-                const ast::StructInstType * postvisit( const ast::StructInstType * inst ) {
-                        const ast::StructDecl * decl = localSymtab->lookupStruct( inst->name );
-                        // not a semantic error if the struct is not found, just an implicit forward declaration
-                        if ( decl ) {
-                                inst = ast::mutate_field( inst, &ast::StructInstType::base, decl );
-                        }
-                        if ( ! decl || ! decl->body ) {
-                                // forward declaration
-                                auto mut = mutate( inst );
-                                forwardStructs.emplace( inst->name, mut );
-                                inst = mut;
-                        }
-                        checkGenericParameters( inst );
-                        return inst;
-                }
-
-                const ast::UnionInstType * postvisit( const ast::UnionInstType * inst ) {
-                        const ast::UnionDecl * decl = localSymtab->lookupUnion( inst->name );
-                        // not a semantic error if the struct is not found, just an implicit forward declaration
-                        if ( decl ) {
-                                inst = ast::mutate_field( inst, &ast::UnionInstType::base, decl );
-                        }
-                        if ( ! decl || ! decl->body ) {
-                                // forward declaration
-                                auto mut = mutate( inst );
-                                forwardUnions.emplace( inst->name, mut );
-                                inst = mut;
-                        }
-                        checkGenericParameters( inst );
-                        return inst;
-                }
-
-                const ast::Type * postvisit( const ast::TraitInstType * traitInst ) {
-                        // handle other traits
-                        const ast::TraitDecl * traitDecl = localSymtab->lookupTrait( traitInst->name );
-                        if ( ! traitDecl )       {
-                                SemanticError( location, "use of undeclared trait " + traitInst->name );
-                        }
-                        if ( traitDecl->params.size() != traitInst->params.size() ) {
-                                SemanticError( location, traitInst, "incorrect number of trait parameters: " );
-                        }
-                        traitInst = ast::mutate_field( traitInst, &ast::TraitInstType::base, traitDecl );
-
-                        // need to carry over the "sized" status of each decl in the instance
-                        for ( unsigned i = 0; i < traitDecl->params.size(); ++i ) {
-                                auto expr = traitInst->params[i].as< ast::TypeExpr >();
-                                if ( ! expr ) {
-                                        SemanticError(
-                                                traitInst->params[i].get(), "Expression parameters for trait instances "
-                                                "are currently unsupported: " );
-                                }
-
-                                if ( auto inst = expr->type.as< ast::TypeInstType >() ) {
-                                        if ( traitDecl->params[i]->sized && ! inst->base->sized ) {
-                                                // traitInst = ast::mutate_field_index(
-                                                //      traitInst, &ast::TraitInstType::params, i,
-                                                //      ...
-                                                // );
-                                                ast::TraitInstType * mut = ast::mutate( traitInst );
-                                                ast::chain_mutate( mut->params[i] )
-                                                        ( &ast::TypeExpr::type )
-                                                                ( &ast::TypeInstType::base )->sized = true;
-                                                traitInst = mut;
-                                        }
-                                }
-                        }
-
-                        return traitInst;
-                }
-
-                void previsit( const ast::QualifiedType * ) { visit_children = false; }
-
-                const ast::Type * postvisit( const ast::QualifiedType * qualType ) {
-                        // linking only makes sense for the "oldest ancestor" of the qualified type
-                        return ast::mutate_field(
-                                qualType, &ast::QualifiedType::parent, qualType->parent->accept( * visitor ) );
-                }
-
-                const ast::Decl * postvisit( const ast::EnumDecl * enumDecl ) {
-                        // visit enum members first so that the types of self-referencing members are updated
-                        // properly
-                        if ( ! enumDecl->body ) return enumDecl;
-
-                        // update forward declarations to point here
-                        auto fwds = forwardEnums.equal_range( enumDecl->name );
-                        if ( fwds.first != fwds.second ) {
-                                auto inst = fwds.first;
-                                do {
-                                        // forward decl is stored * mutably * in map, can thus be updated
-                                        inst->second->base = enumDecl;
-                                } while ( ++inst != fwds.second );
-                                forwardEnums.erase( fwds.first, fwds.second );
-                        }
-
-                        // ensure that enumerator initializers are properly set
-                        for ( unsigned i = 0; i < enumDecl->members.size(); ++i ) {
-                                auto field = enumDecl->members[i].strict_as< ast::ObjectDecl >();
-                                if ( field->init ) {
-                                        // need to resolve enumerator initializers early so that other passes that
-                                        // determine if an expression is constexpr have appropriate information
-                                        auto init = field->init.strict_as< ast::SingleInit >();
-
-                                        enumDecl = ast::mutate_field_index(
-                                                enumDecl, &ast::EnumDecl::members, i,
-                                                ast::mutate_field( field, &ast::ObjectDecl::init,
-                                                        ast::mutate_field( init, &ast::SingleInit::value,
-                                                                ResolvExpr::findSingleExpression(
-                                                                        init->value, new ast::BasicType{ ast::BasicType::SignedInt },
-                                                                        symtab ) ) ) );
-                                }
-                        }
-
-                        return enumDecl;
-                }
-
-                /// rename generic type parameters uniquely so that they do not conflict with user defined
-                /// function forall parameters, e.g. the T in Box and the T in f, below
-                ///   forall(otype T)
-                ///   struct Box {
-                ///     T x;
-                ///   };
-                ///   forall(otype T)
-                ///   void f(Box(T) b) {
-                ///     ...
-                ///   }
-                template< typename AggrDecl >
-                const AggrDecl * renameGenericParams( const AggrDecl * aggr ) {
-                        GuardValue( inGeneric );
-                        inGeneric = ! aggr->params.empty();
-
-                        for ( unsigned i = 0; i < aggr->params.size(); ++i ) {
-                                const ast::TypeDecl * td = aggr->params[i];
-
-                                aggr = ast::mutate_field_index(
-                                        aggr, &AggrDecl::params, i,
-                                        ast::mutate_field( td, &ast::TypeDecl::name, "__" + td->name + "_generic_" ) );
-                        }
-                        return aggr;
-                }
-
-                const ast::StructDecl * previsit( const ast::StructDecl * structDecl ) {
-                        return renameGenericParams( structDecl );
-                }
-
-                void postvisit( const ast::StructDecl * structDecl ) {
-                        // visit struct members first so that the types of self-referencing members are
-                        // updated properly
-                        if ( ! structDecl->body ) return;
-
-                        // update forward declarations to point here
-                        auto fwds = forwardStructs.equal_range( structDecl->name );
-                        if ( fwds.first != fwds.second ) {
-                                auto inst = fwds.first;
-                                do {
-                                        // forward decl is stored * mutably * in map, can thus be updated
-                                        inst->second->base = structDecl;
-                                } while ( ++inst != fwds.second );
-                                forwardStructs.erase( fwds.first, fwds.second );
-                        }
-                }
-
-                const ast::UnionDecl * previsit( const ast::UnionDecl * unionDecl ) {
-                        return renameGenericParams( unionDecl );
-                }
-
-                void postvisit( const ast::UnionDecl * unionDecl ) {
-                        // visit union members first so that the types of self-referencing members are updated
-                        // properly
-                        if ( ! unionDecl->body ) return;
-
-                        // update forward declarations to point here
-                        auto fwds = forwardUnions.equal_range( unionDecl->name );
-                        if ( fwds.first != fwds.second ) {
-                                auto inst = fwds.first;
-                                do {
-                                        // forward decl is stored * mutably * in map, can thus be updated
-                                        inst->second->base = unionDecl;
-                                } while ( ++inst != fwds.second );
-                                forwardUnions.erase( fwds.first, fwds.second );
-                        }
-                }
-
-                const ast::Decl * postvisit( const ast::TraitDecl * traitDecl ) {
-                        // set the "sized" status for the special "sized" trait
-                        if ( traitDecl->name == "sized" ) {
-                                assertf( traitDecl->params.size() == 1, "Built-in trait 'sized' has incorrect "
-                                        "number of parameters: %zd", traitDecl->params.size() );
-
-                                traitDecl = ast::mutate_field_index(
-                                        traitDecl, &ast::TraitDecl::params, 0,
-                                        ast::mutate_field(
-                                                traitDecl->params.front().get(), &ast::TypeDecl::sized, true ) );
-                        }
-
-                        // move assertions from type parameters into the body of the trait
-                        std::vector< ast::ptr< ast::DeclWithType > > added;
-                        for ( const ast::TypeDecl * td : traitDecl->params ) {
-                                for ( const ast::DeclWithType * assn : td->assertions ) {
-                                        auto inst = dynamic_cast< const ast::TraitInstType * >( assn->get_type() );
-                                        if ( inst ) {
-                                                expandAssertions( inst, added );
-                                        } else {
-                                                added.emplace_back( assn );
-                                        }
-                                }
-                        }
-                        if ( ! added.empty() ) {
-                                auto mut = mutate( traitDecl );
-                                for ( const ast::DeclWithType * decl : added ) {
-                                        mut->members.emplace_back( decl );
-                                }
-                                traitDecl = mut;
-                        }
-
-                        return traitDecl;
-                }
-        };
-
-        /// Replaces array and function types in forall lists by appropriate pointer type and assigns
-        /// each object and function declaration a unique ID
-        class ForallPointerDecay_new {
-                const CodeLocation & location;
-        public:
-                ForallPointerDecay_new( const CodeLocation & loc ) : location( loc ) {}
-
-                const ast::ObjectDecl * previsit( const ast::ObjectDecl * obj ) {
-                        // ensure that operator names only apply to functions or function pointers
-                        if (
-                                CodeGen::isOperator( obj->name )
-                                && ! dynamic_cast< const ast::FunctionType * >( obj->type->stripDeclarator() )
-                        ) {
-                                SemanticError( obj->location, toCString( "operator ", obj->name.c_str(), " is not "
-                                        "a function or function pointer." )  );
-                        }
-
-                        // ensure object has unique ID
-                        if ( obj->uniqueId ) return obj;
-                        auto mut = mutate( obj );
-                        mut->fixUniqueId();
-                        return mut;
-                }
-
-                const ast::FunctionDecl * previsit( const ast::FunctionDecl * func ) {
-                        // ensure function has unique ID
-                        if ( func->uniqueId ) return func;
-                        auto mut = mutate( func );
-                        mut->fixUniqueId();
-                        return mut;
-                }
-
-                /// Fix up assertions -- flattens assertion lists, removing all trait instances
-                template< typename node_t, typename parent_t >
-                static const node_t * forallFixer(
-                        const CodeLocation & loc, const node_t * node,
-                        ast::FunctionType::ForallList parent_t::* forallField
-                ) {
-                        for ( unsigned i = 0; i < (node->* forallField).size(); ++i ) {
-                                const ast::TypeDecl * type = (node->* forallField)[i];
-                                if ( type->assertions.empty() ) continue;
-
-                                std::vector< ast::ptr< ast::DeclWithType > > asserts;
-                                asserts.reserve( type->assertions.size() );
-
-                                // expand trait instances into their members
-                                for ( const ast::DeclWithType * assn : type->assertions ) {
-                                        auto traitInst =
-                                                dynamic_cast< const ast::TraitInstType * >( assn->get_type() );
-                                        if ( traitInst ) {
-                                                // expand trait instance to all its members
-                                                expandAssertions( traitInst, asserts );
-                                        } else {
-                                                // pass other assertions through
-                                                asserts.emplace_back( assn );
-                                        }
-                                }
-
-                                // apply FixFunction to every assertion to check for invalid void type
-                                for ( ast::ptr< ast::DeclWithType > & assn : asserts ) {
-                                        bool isVoid = false;
-                                        assn = fixFunction( assn, isVoid );
-                                        if ( isVoid ) {
-                                                SemanticError( loc, node, "invalid type void in assertion of function " );
-                                        }
-                                }
-
-                                // place mutated assertion list in node
-                                auto mut = mutate( type );
-                                mut->assertions = move( asserts );
-                                node = ast::mutate_field_index( node, forallField, i, mut );
-                        }
-                        return node;
-                }
-
-                const ast::FunctionType * previsit( const ast::FunctionType * ftype ) {
-                        return forallFixer( location, ftype, &ast::FunctionType::forall );
-                }
-
-                const ast::StructDecl * previsit( const ast::StructDecl * aggrDecl ) {
-                        return forallFixer( aggrDecl->location, aggrDecl, &ast::StructDecl::params );
-                }
-
-                const ast::UnionDecl * previsit( const ast::UnionDecl * aggrDecl ) {
-                        return forallFixer( aggrDecl->location, aggrDecl, &ast::UnionDecl::params );
-                }
-        };
-        */
-} // anonymous namespace
-
-/*
-const ast::Type * validateType(
-                const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
-        // ast::Pass< EnumAndPointerDecay_new > epc;
-        ast::Pass< LinkReferenceToTypes_new > lrt{ loc, symtab };
-        ast::Pass< ForallPointerDecay_new > fpd{ loc };
-
-        return type->accept( lrt )->accept( fpd );
-}
-*/
-
 } // namespace SymTab
 

src/SynTree/Declaration.h

@@ -449 +449 @@
 };
 
+
+class InlineMemberDecl : public DeclarationWithType {
+        typedef DeclarationWithType Parent;
+  public:
+        Type * type;
+
+        InlineMemberDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Type * type,
+                                const std::list< Attribute * > attributes = std::list< Attribute * >(), Type::FuncSpecifiers fs = Type::FuncSpecifiers() );
+        InlineMemberDecl( const InlineMemberDecl & other );
+        virtual ~InlineMemberDecl();
+
+        virtual Type * get_type() const override { return type; }
+        virtual void set_type(Type * newType) override { type = newType; }
+
+        static InlineMemberDecl * newInlineMemberDecl( const std::string & name, Type * type );
+
+        virtual InlineMemberDecl * clone() const override { return new InlineMemberDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual DeclarationWithType * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
+
+};
+
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
 

src/SynTree/Mutator.h

@@ -36 +36 @@
         virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) = 0;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) = 0;
+        virtual DeclarationWithType * mutate( InlineMemberDecl * InlineMemberDecl ) = 0;
 
         virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) = 0;

src/SynTree/SynTree.h

@@ -38 +38 @@
 class DirectiveDecl;
 class StaticAssertDecl;
+class InlineMemberDecl;
 
 class Statement;

src/SynTree/Visitor.h

@@ -49 +49 @@
         virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
         virtual void visit( const StaticAssertDecl * assertDecl ) = 0;
+        virtual void visit( InlineMemberDecl * node ) { visit( const_cast<const InlineMemberDecl *>(node) ); }
+        virtual void visit( const InlineMemberDecl * valueDecl ) = 0;
 
         virtual void visit( CompoundStmt * node ) { visit( const_cast<const CompoundStmt *>(node) ); }

src/SynTree/module.mk

@@ -42 +42 @@
       SynTree/Initializer.cc \
       SynTree/Initializer.h \
+      SynTree/InlineMemberDecl.cc \
       SynTree/Label.h \
       SynTree/LinkageSpec.cc \

src/Validate/EnumAndPointerDecay.cpp

@@ -21 +21 @@
 #include "AST/Type.hpp"
 #include "SymTab/FixFunction.h"
+#include "Validate/NoIdSymbolTable.hpp"
 
 namespace Validate {
@@ -26 +27 @@
 namespace {
 
-struct EnumAndPointerDecayCore final : public ast::WithCodeLocation {
+struct EnumAndPointerDecayCore final : public WithNoIdSymbolTable, public ast::WithCodeLocation {
         ast::EnumDecl const * previsit( ast::EnumDecl const * decl );
         ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl );
@@ -39 +40 @@
         // Set the type of each member of the enumeration to be EnumContant.
         auto mut = ast::mutate( decl );
-        for ( ast::ptr<ast::Decl> & member : mut->members ) {
-                ast::ObjectDecl const * object = member.strict_as<ast::ObjectDecl>();
-                member = ast::mutate_field( object, &ast::ObjectDecl::type,
-                        new ast::EnumInstType( decl, ast::CV::Const ) );
+        std::vector<ast::ptr<ast::Decl>> buffer;
+        for ( auto member : decl->members ) {
+                if ( ast::ObjectDecl const * object = member.as<ast::ObjectDecl>() ) {
+                        buffer.push_back( ast::mutate_field( object,
+                                &ast::ObjectDecl::type,
+                                new ast::EnumInstType( decl, ast::CV::Const ) ) );
+                } else if ( auto value = member.as<ast::InlineMemberDecl>() ) {
+                        if ( auto targetEnum = symtab.lookupEnum( value->name ) ) {
+                                for ( auto enumMember : targetEnum->members ) {
+                                        auto enumObject = enumMember.strict_as<ast::ObjectDecl>();
+                                        buffer.push_back( new ast::ObjectDecl(
+                                                // Get the location from the "inline" declaration.
+                                                value->location,
+                                                enumObject->name,
+                                                // Construct a new EnumInstType as the type.
+                                                new ast::EnumInstType( decl, ast::CV::Const ),
+                                                enumObject->init,
+                                                enumObject->storage,
+                                                enumObject->linkage,
+                                                enumObject->bitfieldWidth,
+                                                {},
+                                                enumObject->funcSpec
+                                        ) );
+                                }
+                        }
+                }
         }
+        mut->members = buffer;
         return mut;
 }

src/Validate/LinkReferenceToTypes.cpp

@@ -185 +185 @@
                                 decl = mut;
                         }
+                        // visit the base
                 } else if ( auto ptr = decl->base.as<ast::PointerType>() ) {
                         if ( auto base = ptr->base.as<ast::TypeInstType>() ) {
@@ -203 +204 @@
 
         // The following section 
-        auto mut = ast::mutate( decl );
-        std::vector<ast::ptr<ast::Decl>> buffer;
-        for ( auto it = decl->members.begin(); it != decl->members.end(); ++it) {
-                auto member = (*it).as<ast::ObjectDecl>();
-                if ( member->enumInLine ) {
-                        auto targetEnum = symtab.lookupEnum( member->name );
-                        if ( targetEnum ) {                     
-                                for ( auto singleMamber : targetEnum->members ) {
-                                        auto tm = singleMamber.as<ast::ObjectDecl>();
-                                        auto t = new ast::ObjectDecl(
-                                                member->location, // use the "inline" location
-                                                tm->name,
-                                                new ast::EnumInstType( decl, ast::CV::Const ),
-                                                // Construct a new EnumInstType as the type
-                                                tm->init,
-                                                tm->storage,
-                                                tm->linkage,
-                                                tm->bitfieldWidth,
-                                                {}, // enum member doesn't have attribute
-                                                tm->funcSpec
-                                        );
-                                        t->importValue = true;
-                                        buffer.push_back(t);
-                                }
-                        }
-                } else {
-                        auto search_it = std::find_if( buffer.begin(), buffer.end(), [member](ast::ptr<ast::Decl> cur) {
-                                auto curAsObjDecl = cur.as<ast::ObjectDecl>();
-                                return (curAsObjDecl->importValue) && (curAsObjDecl->name == member->name);
-                        });
-                        if ( search_it != buffer.end() ) {
-                                buffer.erase( search_it ); // Found an import enum value that has the same name
-                                // override the imported value
-                        }
-                        buffer.push_back( *it );
-                }
-        }
-        mut->members = buffer;
-        decl = mut;
 
         ForwardEnumsType::iterator fwds = forwardEnums.find( decl->name );

src/Virtual/ExpandCasts.cc

@@ -295 +295 @@
         // returns the previous declaration for error messages.
         ast::ObjectDecl const * insert( ast::ObjectDecl const * typeIdDecl ) {
-                std::string const & mangledName =
-                                Mangle::mangle( typeIdDecl->type, Mangle::typeMode() );
+                std::string mangledName = Mangle::mangleType( typeIdDecl->type );
                 ast::ObjectDecl const *& value = instances[ mangledName ];
                 if ( value ) {
@@ -310 +309 @@
 
         ast::ObjectDecl const * lookup( ast::Type const * typeIdType ) {
-                std::string const & mangledName =
-                                Mangle::mangle( typeIdType, Mangle::typeMode() );
+                std::string mangledName = Mangle::mangleType( typeIdType );
                 auto const it = instances.find( mangledName );
                 return ( instances.end() == it ) ? nullptr : it->second;