Changeset b7c53a9d for src/Validate/LinkReferenceToTypes.cpp

Timestamp:

Jul 14, 2023, 9:32:31 AM (15 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

402a1e7

Parents:

4acf56d

Message:

Added a new invariant check and the fixes required to make it pass. Not the new check is by no means exaustive (it doesn't even check every readonly pointer) but it should catch the most common/problematic cases.

File:

• src/Validate/LinkReferenceToTypes.cpp (modified) (8 diffs)

src/Validate/LinkReferenceToTypes.cpp

@@ -10 +10 @@
 // Created On       : Thr Apr 21 11:41:00 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Sep 20 16:17:00 2022
-// Update Count     : 2
+// Last Modified On : Fri Jul 14  9:19:00 2023
+// Update Count     : 3
 //
 
@@ -27 +27 @@
 struct LinkTypesCore : public WithNoIdSymbolTable,
                 public ast::WithCodeLocation,
+                public ast::WithDeclsToAdd<>,
                 public ast::WithGuards,
                 public ast::WithShortCircuiting,
@@ -63 +64 @@
         template<typename AggrDecl>
         AggrDecl const * renameGenericParams( AggrDecl const * decl );
+
+        // This cluster is used to add declarations (before) but outside of
+        // any "namespaces" which would qualify the names.
+        bool inNamespace = false;
+        std::list<ast::ptr<ast::Decl>> declsToAddOutside;
+        /// The "leaveNamespace" is handled by guard.
+        void enterNamespace();
+        /// Puts the decl on the back of declsToAddBefore once traversal is
+        /// outside of any namespaces.
+        void addDeclBeforeOutside( ast::Decl const * );
 };
+
+void LinkTypesCore::enterNamespace() {
+        if ( inNamespace ) return;
+        inNamespace = true;
+        GuardAction( [this](){
+                inNamespace = false;
+                declsToAddBefore.splice( declsToAddBefore.begin(), declsToAddOutside );
+        } );
+}
+
+void LinkTypesCore::addDeclBeforeOutside( ast::Decl const * decl ) {
+        if ( inNamespace ) {
+                declsToAddOutside.emplace_back( decl );
+        } else {
+                declsToAddBefore.emplace_back( decl );
+        }
+}
 
 ast::TypeInstType const * LinkTypesCore::postvisit( ast::TypeInstType const * type ) {
@@ -80 +108 @@
 ast::EnumInstType const * LinkTypesCore::postvisit( ast::EnumInstType const * type ) {
         ast::EnumDecl const * decl = symtab.lookupEnum( type->name );
+        // It's not a semantic error if the enum is not found, just an implicit forward declaration.
+        // The unset code location is used to detect imaginary declarations.
+        // (They may never be used for enumerations.)
+        if ( !decl || decl->location.isUnset() ) {
+                assert( location );
+                decl = new ast::EnumDecl( *location, type->name );
+                symtab.addEnum( decl );
+                addDeclBeforeOutside( decl );
+        }
+
         ast::EnumInstType * mut = ast::mutate( type );
-        // It's not a semantic error if the enum is not found, just an implicit forward declaration.
-        if ( decl ) {
-                // Just linking in the node.
-                mut->base = decl;
-        }
-        if ( !decl || !decl->body ) {
+
+        // Just linking in the node.
+        mut->base = decl;
+
+        if ( !decl->body ) {
                 forwardEnums[ mut->name ].push_back( mut );
         }
@@ -94 +131 @@
 ast::StructInstType const * LinkTypesCore::postvisit( ast::StructInstType const * type ) {
         ast::StructDecl const * decl = symtab.lookupStruct( type->name );
+        // It's not a semantic error if the struct is not found, just an implicit forward declaration.
+        // The unset code location is used to detect imaginary declarations.
+        if ( !decl || decl->location.isUnset() ) {
+                assert( location );
+                decl = new ast::StructDecl( *location, type->name );
+                symtab.addStruct( decl );
+                addDeclBeforeOutside( decl );
+        }
+
         ast::StructInstType * mut = ast::mutate( type );
-        // It's not a semantic error if the struct is not found, just an implicit forward declaration.
-        if ( decl ) {
-                // Just linking in the node.
-                mut->base = decl;
-        }
-        if ( !decl || !decl->body ) {
+
+        // Just linking in the node.
+        mut->base = decl;
+
+        if ( !decl->body ) {
                 forwardStructs[ mut->name ].push_back( mut );
         }
@@ -108 +153 @@
 ast::UnionInstType const * LinkTypesCore::postvisit( ast::UnionInstType const * type ) {
         ast::UnionDecl const * decl = symtab.lookupUnion( type->name );
+        // It's not a semantic error if the union is not found, just an implicit forward declaration.
+        // The unset code location is used to detect imaginary declarations.
+        if ( !decl || decl->location.isUnset() ) {
+                assert( location );
+                decl = new ast::UnionDecl( *location, type->name );
+                symtab.addUnion( decl );
+                addDeclBeforeOutside( decl );
+        }
+
         ast::UnionInstType * mut = ast::mutate( type );
-        // It's not a semantic error if the union is not found, just an implicit forward declaration.
-        if ( decl ) {
-                // Just linking in the node.
-                mut->base = decl;
-        }
-        if ( !decl || !decl->body ) {
+
+        // Just linking in the node.
+        mut->base = decl;
+
+        if ( !decl->body ) {
                 forwardUnions[ mut->name ].push_back( mut );
         }
@@ -219 +272 @@
 
 ast::StructDecl const * LinkTypesCore::previsit( ast::StructDecl const * decl ) {
+        enterNamespace();
         return renameGenericParams( decl );
 }
@@ -237 +291 @@
 
 ast::UnionDecl const * LinkTypesCore::previsit( ast::UnionDecl const * decl ) {
+        enterNamespace();
         return renameGenericParams( decl );
 }