Changeset f45772e for src

Timestamp:

Oct 8, 2023, 9:14:31 AM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

92211d9

Parents:

2261bcc (diff), 9689e54 (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:

• CodeGen/LinkOnce.cc (modified) (5 diffs)
• CodeGen/LinkOnce.h (modified) (2 diffs)
• GenPoly/BoxNew.cpp (modified) (25 diffs)
• GenPoly/InstantiateGeneric.h (modified) (2 diffs)
• GenPoly/InstantiateGenericNew.cpp (modified) (1 diff)
• Validate/NoIdSymbolTable.hpp (modified) (1 diff)
• main.cc (modified) (1 diff)

src/CodeGen/LinkOnce.cc

@@ -10 +10 @@
 // Created On       : Thur May 13 10:10:00 2021
 // Last Modified By : Andrew Beach
-// Last Modified On : Thur May 13 14:39:00 2021
-// Update Count     : 0
+// Last Modified On : Wed Oct  4 10:52:00 2023
+// Update Count     : 1
 //
 
@@ -18 +18 @@
 #include <algorithm>
 
+#include "AST/Attribute.hpp"
+#include "AST/Decl.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Pass.hpp"
 #include "Common/PassVisitor.h"       // for PassVisitor, WithShortCircuiting
 
 namespace CodeGen {
 
-static bool is_cfa_linkonce( Attribute const * attr ) {
+namespace {
+
+bool is_cfa_linkonce_old( Attribute const * attr ) {
         return std::string("cfa_linkonce") == attr->name;
 }
 
-static bool is_section_attribute( Attribute const * attr ) {
+bool is_section_attribute_old( Attribute const * attr ) {
         return std::string("section") == attr->name;
 }
@@ -39 +45 @@
                 std::list< Attribute * > & attributes = decl->attributes;
                 // See if we can find the element:
-                auto found = std::find_if(attributes.begin(), attributes.end(), is_cfa_linkonce );
+                auto found = std::find_if(attributes.begin(), attributes.end(), is_cfa_linkonce_old );
                 if ( attributes.end() != found ) {
                         // Remove any other sections:
-                        attributes.remove_if( is_section_attribute );
+                        attributes.remove_if( is_section_attribute_old );
                         // Iterator to the cfa_linkonce attribute should still be valid.
                         Attribute * attribute = *found;
@@ -63 +69 @@
 };
 
+bool is_cfa_linkonce( ast::Attribute const * attr ) {
+        return "cfa_linkonce" == attr->name;
+}
+
+bool is_section_attribute( ast::Attribute const * attr ) {
+        return "section" == attr->name;
+}
+
+struct LinkOnceCore : public ast::WithShortCircuiting {
+        void previsit( ast::Decl const * ) {
+                visit_children = false;
+        }
+
+        ast::DeclWithType const * postvisit( ast::DeclWithType const * decl ) {
+                // Check to see if we have to mutate, because should be uncommon.
+                {
+                        auto & attributes = decl->attributes;
+                        auto found = std::find_if( attributes.begin(), attributes.end(),
+                                        is_cfa_linkonce );
+                        if ( attributes.end() == found ) return decl;
+                }
+                auto mutDecl = mutate( decl );
+                auto & attributes = mutDecl->attributes;
+
+                // Remove all conflicting section attributes.
+                erase_if( attributes, is_section_attribute );
+
+                // Get the attribute, and overwrite it as a section attribute.
+                auto found = std::find_if( attributes.begin(), attributes.end(),
+                                is_cfa_linkonce );
+                assert( attributes.end() != found );
+                ast::Attribute * attribute = found->get_and_mutate();
+                assert( attribute->params.empty() );
+                assert( !decl->mangleName.empty() );
+
+                attribute->name = "section";
+                attribute->params.push_back(
+                        ast::ConstantExpr::from_string( mutDecl->location,
+                                ".gnu.linkonce." + decl->mangleName
+                        )
+                );
+
+                // Unconditionnaly add "visibility(default)" to anything with
+                // .gnu.linkonce visibility is a mess otherwise.
+                attributes.push_back( new ast::Attribute( "visibility", {
+                        ast::ConstantExpr::from_string( mutDecl->location, "default" )
+                } ) );
+                return mutDecl;
+        }
+};
+
+} // namespace
+
 void translateLinkOnce( std::list< Declaration *> & translationUnit ) {
         PassVisitor<LinkOnceVisitorCore> translator;
@@ -68 +127 @@
 }
 
+void translateLinkOnce( ast::TranslationUnit & translationUnit ) {
+        ast::Pass<LinkOnceCore>::run( translationUnit );
 }
+
+} // namespace CodeGen

src/CodeGen/LinkOnce.h

@@ -10 +10 @@
 // Created On       : Thur May 13 10:06:00 2021
 // Last Modified By : Andrew Beach
-// Last Modified On : Thur May 13 14:38:00 2021
-// Update Count     : 0
+// Last Modified On : Wed Oct  4 10:52:00 2023
+// Update Count     : 1
 //
 
@@ -23 +23 @@
 
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 
 namespace CodeGen {
 
 void translateLinkOnce( std::list< Declaration *> & translationUnit );
+void translateLinkOnce( ast::TranslationUnit & translationUnit );
 /* Convert the cfa_linkonce attribute on top level declaration into
  * a special section declaration (.gnu.linkonce) so that it may be defined

src/GenPoly/BoxNew.cpp

@@ -77 +77 @@
 };
 
-// Formally takeOtypeOnly
 /// Get all sized type declarations; those that affect a layout function.
 ast::vector<ast::TypeDecl> takeSizedParams(
@@ -510 +509 @@
                 ast::FunctionType const * function,
                 TypeVarMap const & typeVars ) {
-        // TODO
-        // NOTE: This function previously used isPolyObj, which failed to produce
-        // the correct thing in some situations. It's not clear to [Rob Schluntz]
-        // why this wasn't working.
-
         // If the return type or a parameter type involved polymorphic types,
         // then the adapter will need to take those polymorphic types as pointers.
@@ -587 +581 @@
         ast::FunctionType const * type = decl->type;
         if ( isDynRet( type ) && decl->linkage != ast::Linkage::C ) {
-                //retval = type->returns.front();
                 retval = decl->returns.front();
 
@@ -748 +741 @@
 ast::Expr const * CallAdapter::postvisit( ast::UntypedExpr const * expr ) {
         if ( isPolyDeref( expr, scopeTypeVars, typeSubs ) ) {
-                // TODO Pretty sure this is just a memory management change.
-                // Also, I don't understand what this is doing.
-                //ast::Expr const * ret = expr->args.front();
-                //expr->args.clear();
-                //return ret;
                 return expr->args.front();
         }
@@ -1063 +1051 @@
                 ast::ptr<ast::Type> newType = ast::deepCopy( param );
                 if ( typeSubs ) typeSubs->apply( newType );
-                // TODO: Is this right? (Why wouldn't it be?)
-                // I think this is to make sure we can write to the temporary.
-                //newType.get_and_mutate()->qt = ast::CV::Qualifiers();
-                //reset_qualifiers( newType );
                 ast::ObjectDecl * newObj = makeTemporary( location, newType );
                 auto assign = ast::UntypedExpr::createCall( location, "?=?", {
@@ -1245 +1229 @@
                         }
                         return new ast::ObjectDecl( location, pNamer.newName(), param );
-                } ), // params
+                } ),
                 map_range<ast::vector<ast::DeclWithType>>( adapterType->returns,
                                 [&rNamer, &location]( ast::ptr<ast::Type> const & retval ) {
                         return new ast::ObjectDecl( location, rNamer.newName(), retval );
-                } ), // returns
+                } ),
                 nullptr, // stmts
-                ast::Storage::Classes(), // storage
-                ast::Linkage::C // linkage
-                // attrs
-                // fs
-                // isVarArgs
+                {}, // storage
+                ast::Linkage::C
         );
 
@@ -1314 +1295 @@
         // Returns a polymorphic type.
         } else if ( isDynType( adaptee->returns.front(), typeVars ) ) {
-                if ( "" == (*paramDecl)->name ) {
-                        // TODO: Is it easier to make sure it has a name in the first
-                        // place? - I believe this is done, however, I could remove the
-                        // condition and just rename for clarity.
-                        assertf( false, "Wasn't expecting to get here." );
-                        auto mutParam = paramDecl->get_and_mutate();
-                        mutParam->name = "_ret";
-                        mutParam->linkage = ast::Linkage::C;
-                }
                 ast::UntypedExpr * assign = new ast::UntypedExpr( location,
                         new ast::NameExpr( location, "?=?" ) );
@@ -1546 +1518 @@
 
 // --------------------------------------------------------------------------
-/// Creates the adapter functions. TODO
+/// Modifies declarations to accept implicit parameters.
 /// * Move polymorphic returns in function types to pointer-type parameters.
 /// * Adds type size and assertion parameters to parameter lists.
-struct DeclAdapter final :
-                public BoxPass,
-                public ast::WithGuards {
-        void handleAggrDecl();
-
-        void previsit( ast::StructDecl const * decl );
-        void previsit( ast::UnionDecl const * decl );
-        void previsit( ast::TraitDecl const * decl );
-        void previsit( ast::TypeDecl const * decl );
-        void previsit( ast::PointerType const * type );
-        void previsit( ast::FunctionType const * type );
+struct DeclAdapter final {
         ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl );
-        ast::DeclWithType const * postvisit( ast::FunctionDecl const * decl );
-        void previsit( ast::CompoundStmt const * stmt );
+        ast::FunctionDecl const * postvisit( ast::FunctionDecl const * decl );
 private:
-        ast::FunctionDecl * addAdapters( ast::FunctionDecl * decl );
-
-        std::map<UniqueId, std::string> adapterName;
+        void addAdapters( ast::FunctionDecl * decl, TypeVarMap & localTypeVars );
 };
 
-// at must point within [dst.begin(), dst.end()].
-template< typename T >
-void spliceAt( std::vector< T > & dst, typename std::vector< T >::iterator at,
-                std::vector< T > & src ) {
-        std::vector< T > tmp;
-        tmp.reserve( dst.size() + src.size() );
-        typename std::vector< T >::iterator it = dst.begin();
-        while ( it != at ) {
-                assert( it != dst.end() );
-                tmp.emplace_back( std::move( *it ) );
-                ++it;
-        }
-        for ( T & x : src ) { tmp.emplace_back( std::move( x ) ); }
-        while ( it != dst.end() ) {
-                tmp.emplace_back( std::move( *it ) );
-                ++it;
-        }
-
-        dst.clear();
-        src.clear();
-        tmp.swap( dst );
-}
-
-void DeclAdapter::previsit( ast::StructDecl const * ) {
-        // Prevent type vars from leaking into the containing scope.
-        GuardScope( scopeTypeVars );
-}
-
-void DeclAdapter::previsit( ast::UnionDecl const * ) {
-        // Prevent type vars from leaking into the containing scope.
-        GuardScope( scopeTypeVars );
-}
-
-void DeclAdapter::previsit( ast::TraitDecl const * ) {
-        // Prevent type vars from leaking into the containing scope.
-        GuardScope( scopeTypeVars );
-}
-
-void DeclAdapter::previsit( ast::TypeDecl const * decl ) {
-        addToTypeVarMap( decl, scopeTypeVars );
-}
-
-void DeclAdapter::previsit( ast::PointerType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
-}
-
-// TODO: I think this code is redundent.
-void DeclAdapter::previsit( ast::FunctionType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+// size/align/offset parameters may not be used, so add the unused attribute.
+ast::ObjectDecl * makeObj(
+                CodeLocation const & location, std::string const & name ) {
+        return new ast::ObjectDecl( location, name,
+                makeSizeAlignType(),
+                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr,
+                { new ast::Attribute( "unused" ) } );
+}
+
+ast::ObjectDecl * makePtr(
+                CodeLocation const & location, std::string const & name ) {
+        return new ast::ObjectDecl( location, name,
+                new ast::PointerType( makeSizeAlignType() ),
+                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr );
 }
 
 ast::FunctionDecl const * DeclAdapter::previsit( ast::FunctionDecl const * decl ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( decl, scopeTypeVars );
+        TypeVarMap localTypeVars = { ast::TypeData() };
+        makeTypeVarMap( decl, localTypeVars );
 
         auto mutDecl = mutate( decl );
@@ -1639 +1561 @@
 
         // Add size/align and assertions for type parameters to parameter list.
-        std::vector<ast::ptr<ast::DeclWithType>>::iterator last = mutDecl->params.begin();
-        std::vector<ast::ptr<ast::DeclWithType>> inferredParams;
-        // size/align/offset parameters may not be used in body, pass along with unused attribute.
-        // TODO: These should be created with proper location and name.
-        // TODO: makeSizeAlign[Out]Type are the same as these types, but they may
-        // be logically different.
-        ast::ObjectDecl newObj( mutDecl->location, "",
-                new ast::BasicType( ast::BasicType::LongUnsignedInt ),
-                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr,
-                { new ast::Attribute( "unused" ) } );
-        ast::ObjectDecl newPtr( mutDecl->location, "",
-                new ast::PointerType( new ast::BasicType( ast::BasicType::LongUnsignedInt ) ),
-                nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr );
+        ast::vector<ast::DeclWithType> inferredParams;
+        ast::vector<ast::DeclWithType> layoutParams;
         for ( ast::ptr<ast::TypeDecl> & typeParam : mutDecl->type_params ) {
                 auto mutParam = mutate( typeParam.get() );
                 // Add all size and alignment parameters to parameter list.
                 if ( mutParam->isComplete() ) {
-                        //ast::TypeInstType paramType( typeParam->name, typeParam );
                         ast::TypeInstType paramType( mutParam );
                         std::string paramName = Mangle::mangleType( &paramType );
 
-                        ast::ObjectDecl * sizeParam = ast::deepCopy( &newObj );
-                        sizeParam->location = typeParam->location;
-                        sizeParam->name = sizeofName( paramName );
-                        last = mutDecl->params.insert( last, sizeParam );
-                        ++last;
-
-                        ast::ObjectDecl * alignParam = ast::deepCopy( &newObj );
-                        alignParam->location = typeParam->location;
-                        alignParam->name = alignofName( paramName );
-                        last = mutDecl->params.insert( last, alignParam );
-                        ++last;
+                        auto sizeParam = makeObj( typeParam->location, sizeofName( paramName ) );
+                        layoutParams.emplace_back( sizeParam );
+
+                        auto alignParam = makeObj( typeParam->location, alignofName( paramName ) );
+                        layoutParams.emplace_back( alignParam );
                 }
                 // TODO: These should possibly all be gone.
@@ -1696 +1600 @@
         // Add size/align for generic parameter types to parameter list.
         std::set<std::string> seenTypes;
-        std::vector<ast::ptr<ast::DeclWithType>> otypeParams;
+        ast::vector<ast::DeclWithType> otypeParams;
         for ( ast::ptr<ast::DeclWithType> & funcParam : mutDecl->params ) {
-                ast::Type const * polyType = isPolyType( funcParam->get_type(), scopeTypeVars );
+                ast::Type const * polyType = isPolyType( funcParam->get_type(), localTypeVars );
                 if ( !polyType || dynamic_cast<ast::TypeInstType const *>( polyType ) ) {
                         continue;
@@ -1704 +1608 @@
                 std::string typeName = Mangle::mangleType( polyType );
                 if ( seenTypes.count( typeName ) ) continue;
-
-                ast::ObjectDecl * sizeParam = ast::deepCopy( &newObj );
-                sizeParam->location = funcParam->location;
-                sizeParam->name = sizeofName( typeName );
+                seenTypes.insert( typeName );
+
+                auto sizeParam = makeObj( funcParam->location, sizeofName( typeName ) );
                 otypeParams.emplace_back( sizeParam );
 
-                ast::ObjectDecl * alignParam = ast::deepCopy( &newObj );
-                alignParam->location = funcParam->location;
-                alignParam->name = alignofName( typeName );
+                auto alignParam = makeObj( funcParam->location, alignofName( typeName ) );
                 otypeParams.emplace_back( alignParam );
 
+                // Zero-length arrays are illegal in C, so empty structs have no
+                // offset array.
                 if ( auto * polyStruct =
-                                dynamic_cast<ast::StructInstType const *>( polyType ) ) {
-                        // Zero-length arrays are illegal in C, so empty structs have no
-                        // offset array.
-                        if ( !polyStruct->base->members.empty() ) {
-                                ast::ObjectDecl * offsetParam = ast::deepCopy( &newPtr );
-                                offsetParam->location = funcParam->location;
-                                offsetParam->name = offsetofName( typeName );
-                                otypeParams.emplace_back( offsetParam );
-                        }
-                }
-                seenTypes.insert( typeName );
-        }
-
-        // TODO: A unified way of putting these together might be nice.
-        // Put the list together: adapters (in helper) otype parameters,
-        // inferred params., layout params. (done) and finally explicit params.
-        spliceBegin( inferredParams, otypeParams );
-        spliceAt( mutDecl->params, last, inferredParams );
-        mutDecl = addAdapters( mutDecl );
+                                dynamic_cast<ast::StructInstType const *>( polyType ) ;
+                                polyStruct && !polyStruct->base->members.empty() ) {
+                        auto offsetParam = makePtr( funcParam->location, offsetofName( typeName ) );
+                        otypeParams.emplace_back( offsetParam );
+                }
+        }
+
+        // Prepend each argument group. From last group to first. addAdapters
+        // does do the same, it just does it itself and see all other parameters.
+        spliceBegin( mutDecl->params, inferredParams );
+        spliceBegin( mutDecl->params, otypeParams );
+        spliceBegin( mutDecl->params, layoutParams );
+        addAdapters( mutDecl, localTypeVars );
 
         return mutDecl;
 }
 
-ast::DeclWithType const * DeclAdapter::postvisit(
+ast::FunctionDecl const * DeclAdapter::postvisit(
                 ast::FunctionDecl const * decl ) {
         ast::FunctionDecl * mutDecl = mutate( decl );
@@ -1773 +1670 @@
 }
 
-void DeclAdapter::previsit( ast::CompoundStmt const * ) {
-        GuardScope( scopeTypeVars );
-        // TODO: It is entirely possible the scope doesn't need to spread
-        // across multiple functions. Otherwise, find a better clear.
-        std::set<TypeVarMap::key_type> keys;
-        for ( auto pair : const_cast<TypeVarMap const &>( scopeTypeVars ) ) {
-                keys.insert( pair.first );
-        }
-        for ( auto key : keys ) {
-                scopeTypeVars.erase( key );
-        }
-}
-
-// It actually does mutate in-place, but does the return for consistency.
-ast::FunctionDecl * DeclAdapter::addAdapters( ast::FunctionDecl * mutDecl ) {
-        std::vector<ast::ptr<ast::FunctionType>> functions;
+void DeclAdapter::addAdapters(
+                ast::FunctionDecl * mutDecl, TypeVarMap & localTypeVars ) {
+        ast::vector<ast::FunctionType> functions;
         for ( ast::ptr<ast::DeclWithType> & arg : mutDecl->params ) {
                 ast::Type const * type = arg->get_type();
-                type = findAndReplaceFunction( type, functions, scopeTypeVars, needsAdapter );
+                type = findAndReplaceFunction( type, functions, localTypeVars, needsAdapter );
                 arg.get_and_mutate()->set_type( type );
         }
         std::set<std::string> adaptersDone;
         for ( ast::ptr<ast::FunctionType> const & func : functions ) {
-                std::string mangleName = mangleAdapterName( func, scopeTypeVars );
+                std::string mangleName = mangleAdapterName( func, localTypeVars );
                 if ( adaptersDone.find( mangleName ) != adaptersDone.end() ) {
                         continue;
@@ -1804 +1688 @@
                 mutDecl->params.insert( mutDecl->params.begin(), new ast::ObjectDecl(
                         mutDecl->location, adapterName,
-                        new ast::PointerType( makeAdapterType( func, scopeTypeVars ) ),
+                        new ast::PointerType( makeAdapterType( func, localTypeVars ) ),
                         nullptr, {}, {}, nullptr,
                         { new ast::Attribute( "unused" ) } ) );
                 adaptersDone.insert( adaptersDone.begin(), mangleName );
         }
-        return mutDecl;
 }
 
@@ -1926 +1809 @@
         /// Namer for VLA (variable length array) buffers.
         UniqueName bufNamer;
-        /// AddressExpr argument is MemberExpr? (TODO: What?)
-        ast::Expr const * addrMember = nullptr;
+        /// If the argument of an AddressExpr is MemberExpr, it is stored here.
+        ast::MemberExpr const * addrMember = nullptr;
         /// Used to avoid recursing too deep in type declarations.
         bool expect_func_type = false;
@@ -1959 +1842 @@
         beginTypeScope( decl->type );
 
-        // - Tried inserting this code.
-        // Make sure that any type information passed into the function is
-        // accounted for.
-        // TODO: For some reason going through decl->params/->get_type() does
-        // not work. Possibly something is not getting updated.
+        // TODO: Going though dec->params does not work for some reason.
         for ( ast::ptr<ast::Type> const & funcParam : decl->type->params ) {
                 // Condition here duplicates that in `DeclAdapter::previsit( FunctionDecl const * )`
@@ -2019 +1898 @@
 ast::StructDecl const * PolyGenericCalculator::previsit(
                 ast::StructDecl const * decl ) {
-        //return strict_dynamic_cast<ast::StructDecl *>( mutateMembers( decl ) );
         auto mutDecl = mutate( decl );
         mutateMembers( mutDecl );
@@ -2027 +1905 @@
 ast::UnionDecl const * PolyGenericCalculator::previsit(
                 ast::UnionDecl const * decl ) {
-        //return strict_dynamic_cast<ast::UnionDecl *>( mutateMembers( decl ) );
         auto mutDecl = mutate( decl );
         mutateMembers( mutDecl );
@@ -2088 +1965 @@
         auto mutDecl = mutate( decl );
 
-        //mutDecl->attributes.remove_if( matchAndMove );
-        // TODO: This common helper might work, but does not officially support
-        // side effects.
+        // Forally, side effects are not safe in this function. But it works.
         erase_if( mutDecl->attributes, matchAndMove );
 
@@ -2198 +2073 @@
         // the substitution manually. For some reason this is not currently the
         // case. This requires more investigation.
-        ast::Type const * memberType = deepCopy( expr->member->get_type() );
+        ast::ptr<ast::Type> memberType = deepCopy( expr->member->get_type() );
         ast::TypeSubstitution sub = genericSubstitution( objectType );
-        auto result = sub.apply( memberType );
-        memberType = result.node.get(); // .release();
+        sub.apply( memberType );
+
         // Not all members of a polymorphic type are themselves of a polymorphic
         // type; in this cas the member expression should be wrapped and
@@ -2217 +2092 @@
 
 void PolyGenericCalculator::previsit( ast::AddressExpr const * expr ) {
-        // Is the argument a MemberExpr before mutating?
         GuardValue( addrMember ) = expr->arg.as<ast::MemberExpr>();
 }
@@ -2233 +2107 @@
         // MemberExpr was converted to pointer + offset; and it is not valid C to
         // take the address of an addition, so stript the address-of.
-        // TODO: should expr->arg->result be changed to expr->result?
-        ast::Expr * ret = mutate( expr->arg.get() );
-        ret->env = expr->env;
-        return ret;
+        // It also preserves the env value.
+        return ast::mutate_field( expr->arg.get(), &ast::Expr::env, expr->env );
 }
 
@@ -2572 +2444 @@
                 public BoxPass,
                 public ast::WithGuards {
-        template<typename decl_t>
-        decl_t const * handleDecl( decl_t const * decl, ast::Type const * type );
+        void guardTypeVarMap( ast::Type const * type ) {
+                GuardScope( scopeTypeVars );
+                makeTypeVarMap( type, scopeTypeVars );
+        }
 
         ast::ObjectDecl const * previsit( ast::ObjectDecl const * decl );
@@ -2585 +2459 @@
 };
 
-template<typename decl_t>
-decl_t const * Eraser::handleDecl(
-                decl_t const * decl, ast::Type const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+ast::ObjectDecl const * Eraser::previsit( ast::ObjectDecl const * decl ) {
+        guardTypeVarMap( decl->type );
         return scrubAllTypeVars( decl );
 }
 
-ast::ObjectDecl const * Eraser::previsit( ast::ObjectDecl const * decl ) {
-        return handleDecl( decl, decl->type );
-}
-
 ast::FunctionDecl const * Eraser::previsit( ast::FunctionDecl const * decl ) {
-        return handleDecl( decl, decl->type );
+        guardTypeVarMap( decl->type );
+        return scrubAllTypeVars( decl );
 }
 
 ast::TypedefDecl const * Eraser::previsit( ast::TypedefDecl const * decl ) {
-        return handleDecl( decl, decl->base );
+        guardTypeVarMap( decl->base );
+        return scrubAllTypeVars( decl );
 }
 
@@ -2608 +2477 @@
 template<typename node_t>
 node_t const * stripGenericMembers( node_t const * decl ) {
-        if ( !decl->params.empty() ) {
-                auto mutDecl = ast::mutate( decl );
-                mutDecl->members.clear();
-                return mutDecl;
-        }
-        return decl;
+        if ( decl->params.empty() ) return decl;
+        auto mutDecl = ast::mutate( decl );
+        mutDecl->members.clear();
+        return mutDecl;
 }
 
@@ -2629 +2496 @@
 
 void Eraser::previsit( ast::PointerType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+        guardTypeVarMap( type );
 }
 
 void Eraser::previsit( ast::FunctionType const * type ) {
-        GuardScope( scopeTypeVars );
-        makeTypeVarMap( type, scopeTypeVars );
+        guardTypeVarMap( type );
 }
 

src/GenPoly/InstantiateGeneric.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// InstantiateGeneric.h --
+// InstantiateGeneric.h -- Create concrete instances of generic types.
 //
 // Author           : Aaron B. Moss
@@ -24 +24 @@
 
 namespace GenPoly {
-/// Replaces all generic types that have static layout with concrete
-/// instantiations. Types with concrete values for otype parameters will be
-/// template-expanded, while dtype and ftype parameters will be replaced by
-/// the appropriate void type.
+
 void instantiateGeneric( std::list< Declaration* > &translationUnit );
 void instantiateGeneric( ast::TranslationUnit & translationUnit );
+/// Replaces all generic types that have static layout with concrete
+/// instantiations. Sized types are replaced with the concrete argument types
+/// while unsized types are erased to a void type.
+/// This pass can cause designators to ignore the pretty print option.
+
 } // namespace GenPoly
 

src/GenPoly/InstantiateGenericNew.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// InstantiateGenericNew.cpp --
+// InstantiateGenericNew.cpp -- Create concrete instances of generic types.
 //
 // Author           : Andrew Beach

src/Validate/NoIdSymbolTable.hpp

@@ -20 +20 @@
 namespace Validate {
 
-// A SymbolTable that only has the operations used in the Translate Dimension
-// pass. More importantly, it doesn't have some methods that should no be
+// A SymbolTable that only tracks names relevant to Validate passes.
+// It tracks type names but not identifier names.
+// Some of the canonicalization that occurs before the resolver
+// affects how identifier name errors get reported to the user.
+// The Validate phase needs to chase type names,
+// but it is too early to try tracking identifier names.
+// Identifier skipping is acheived by omitting methods that should not be
 // called by the Pass template (lookupId and addId).
 class NoIdSymbolTable {
         ast::SymbolTable base;
 public:
+        // All names that are tracked (now) are eligible for collision validation (now).
+        // (Names that are only tracked later get their collision validation then.)
+        NoIdSymbolTable() : base(ast::SymbolTable::ValidateOnAdd) {}
+
 #       define FORWARD_X( func, types_and_names, just_names ) \
         inline auto func types_and_names -> decltype( base.func just_names ) { \

src/main.cc

@@ -421 +421 @@
                 DUMP( bboxp, std::move( transUnit ) );
                 PASS( "Box", GenPoly::box, transUnit );
+                PASS( "Link-Once", CodeGen::translateLinkOnce, transUnit );
 
                 translationUnit = convert( std::move( transUnit ) );
-
-                PASS( "Link-Once", CodeGen::translateLinkOnce, translationUnit );
 
                 // Code has been lowered to C, now we can start generation.