Changeset 29f9e20 for src/SymTab

Timestamp:

Jun 14, 2018, 4:43:52 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

c5d7701

Parents:

589a70b

Message:

Reorganize validate passes and reduce scope of HoistStruct? pass

File:

• src/SymTab/Validate.cc (modified) (7 diffs)

src/SymTab/Validate.cc

@@ -80 +80 @@
 
 namespace SymTab {
+        struct LinkNestedTypes final : public WithDeclsToAdd {
+                void previsit( AggregateDecl * aggr );
+
+                void previsit( SizeofExpr * );
+                void previsit( AlignofExpr * );
+                void previsit( UntypedOffsetofExpr * );
+                void handleType( Type * );
+        };
+
         struct HoistStruct final : public WithDeclsToAdd, public WithGuards {
                 /// Flattens nested struct types
                 static void hoistStruct( std::list< Declaration * > &translationUnit );
 
-                void previsit( EnumInstType * enumInstType );
-                void previsit( StructInstType * structInstType );
-                void previsit( UnionInstType * unionInstType );
                 void previsit( StructDecl * aggregateDecl );
                 void previsit( UnionDecl * aggregateDecl );
@@ -263 +269 @@
                 PassVisitor<FindSpecialDeclarations> finder;
                 PassVisitor<LabelAddressFixer> labelAddrFixer;
-
+                PassVisitor<LinkNestedTypes> nestedTypes;
+
+                acceptAll( translationUnit, nestedTypes );
                 EliminateTypedef::eliminateTypedef( translationUnit );
-                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                 ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
                 acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                 acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
                 VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
@@ -294 +302 @@
         }
 
+
+        void LinkNestedTypes::previsit( AggregateDecl * aggr ) {
+                for ( auto it = aggr->members.begin(); it != aggr->members.end(); ) {
+                        auto current = it++;
+                        Declaration * member = *current;
+                        if ( AggregateDecl * child = dynamic_cast<AggregateDecl *>( member ) ) {
+                                child->parent = aggr;
+                        }
+                }
+        }
+
+        void LinkNestedTypes::handleType( Type * type ) {
+                // some type declarations are buried in expressions and not easy to hoist during parsing; hoist them here
+                AggregateDecl * aggr = nullptr;
+                if ( StructInstType * inst = dynamic_cast< StructInstType * >( type ) ) {
+                        aggr = inst->baseStruct;
+                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( type ) ) {
+                        aggr = inst->baseUnion;
+                } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( type ) ) {
+                        aggr = inst->baseEnum;
+                }
+                if ( aggr && aggr->body ) {
+                        declsToAddBefore.push_front( aggr );
+                }
+        }
+
+        void LinkNestedTypes::previsit( SizeofExpr * expr ) {
+                handleType( expr->type );
+        }
+
+        void LinkNestedTypes::previsit( AlignofExpr * expr ) {
+                handleType( expr->type );
+        }
+
+        void LinkNestedTypes::previsit( UntypedOffsetofExpr * expr ) {
+                handleType( expr->type );
+        }
+
+
         void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
                 PassVisitor<HoistStruct> hoister;
@@ -316 +363 @@
         }
 
-        void HoistStruct::previsit( EnumInstType * inst ) {
-                if ( inst->baseEnum && inst->baseEnum->body ) {
-                        declsToAddBefore.push_front( inst->baseEnum );
-                }
-        }
-
-        void HoistStruct::previsit( StructInstType * inst ) {
-                if ( inst->baseStruct && inst->baseStruct->body ) {
-                        declsToAddBefore.push_front( inst->baseStruct );
-                }
-        }
-
-        void HoistStruct::previsit( UnionInstType * inst ) {
-                if ( inst->baseUnion && inst->baseUnion->body ) {
-                        declsToAddBefore.push_front( inst->baseUnion );
-                }
-        }
-
         void HoistStruct::previsit( StaticAssertDecl * assertDecl ) {
                 if ( parentAggr ) {
@@ -398 +427 @@
                 // it's not a semantic error if the enum is not found, just an implicit forward declaration
                 if ( st ) {
-                        //assert( ! enumInst->get_baseEnum() || enumInst->get_baseEnum()->get_members().empty() || ! st->get_members().empty() );
                         enumInst->baseEnum = st;
                 } // if
-                if ( ! st || st->members.empty() ) {
+                if ( ! st || ! st->body ) {
                         // use of forward declaration
                         forwardEnums[ enumInst->name ].push_back( enumInst );
@@ -419 +447 @@
                 // it's not a semantic error if the struct is not found, just an implicit forward declaration
                 if ( st ) {
-                        //assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
                         structInst->baseStruct = st;
                 } // if
-                if ( ! st || st->members.empty() ) {
+                if ( ! st || ! st->body ) {
                         // use of forward declaration
                         forwardStructs[ structInst->name ].push_back( structInst );
@@ -435 +462 @@
                         unionInst->baseUnion = un;
                 } // if
-                if ( ! un || un->members.empty() ) {
+                if ( ! un || ! un->body ) {
                         // use of forward declaration
                         forwardUnions[ unionInst->name ].push_back( unionInst );