Changeset dbf5e18 for src/Validate

Timestamp:

Jul 17, 2023, 9:24:46 AM (2 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

7ed01be

Parents:

847ab8f (diff), 0d7fc00 (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/Validate

Files:

• ForallPointerDecay.cpp (modified) (9 diffs)
• LinkReferenceToTypes.cpp (modified) (8 diffs)
• ReplaceTypedef.cpp (modified) (4 diffs)

src/Validate/ForallPointerDecay.cpp

@@ -23 +23 @@
 #include "Common/CodeLocation.h"
 #include "Common/ToString.hpp"
+#include "Common/utility.h"
 #include "SymTab/FixFunction.h"
-
-#include "AST/Print.hpp"
 
 namespace Validate {
@@ -51 +50 @@
 }
 
-template<typename T>
-void append( std::vector<T> & dst, std::vector<T> & src ) {
-        dst.reserve( dst.size() + src.size() );
-        for ( auto el : src ) {
-                dst.emplace_back( std::move( el ) );
-        }
-        src.clear();
+ast::FunctionDecl * updateAssertions( ast::FunctionDecl * decl ) {
+        auto type = ast::mutate( decl->type.get() );
+        type->assertions.clear();
+        type->assertions.reserve( decl->assertions.size() );
+        for ( auto & assertion : decl->assertions ) {
+                type->assertions.emplace_back(
+                        new ast::VariableExpr( decl->location, assertion ) );
+        }
+        decl->type = type;
+        return decl;
 }
 
@@ -96 +98 @@
                                         decl->get_type() ) ) {
                                 auto moreAsserts = expandTrait( traitInst );
-                                append( assertions, moreAsserts );
+                                splice( assertions, moreAsserts );
                         } else {
                                 assertions.push_back( decl );
@@ -108 +110 @@
         static TypeDeclVec expandTypeDecls( const TypeDeclVec & old ) {
                 TypeDeclVec typeDecls;
+                typeDecls.reserve( old.size() );
                 for ( const ast::TypeDecl * typeDecl : old ) {
                         typeDecls.push_back( ast::mutate_field( typeDecl,
@@ -123 +126 @@
                 mut->assertions = expandAssertions( decl->assertions );
                 // Update the assertion list on the type as well.
-                auto mutType = ast::mutate( mut->type.get() );
-                mutType->assertions.clear();
-                for ( auto & assertion : mut->assertions ) {
-                        mutType->assertions.emplace_back(
-                                new ast::VariableExpr( mut->location, assertion ) );
-                }
-                mut->type = mutType;
-                return mut;
+                return updateAssertions( mut );
         }
 
@@ -154 +150 @@
                 const std::vector<ast::ptr<ast::DeclWithType>> & assertions ) {
         std::vector<ast::ptr<ast::DeclWithType>> ret;
+        ret.reserve( assertions.size() );
         for ( const auto & assn : assertions ) {
                 bool isVoid = false;
@@ -187 +184 @@
         }
 
+        const ast::FunctionDecl * postvisit( const ast::FunctionDecl * decl ) {
+                if ( decl->assertions.empty() ) {
+                        return decl;
+                }
+                return updateAssertions( mutate( decl ) );
+        }
+
         const ast::StructDecl * previsit( const ast::StructDecl * decl ) {
                 if ( decl->params.empty() ) {
@@ -204 +208 @@
 };
 
-struct OberatorChecker final {
+struct OperatorChecker final {
         void previsit( const ast::ObjectDecl * obj ) {
-                if ( CodeGen::isOperator( obj->name ) ) {
-                        auto type = obj->type->stripDeclarator();
-                        if ( ! dynamic_cast< const ast::FunctionType * >( type ) ) {
-                                SemanticError( obj->location,
-                                        toCString( "operator ", obj->name.c_str(), " is not "
-                                        "a function or function pointer." ) );
-                        }
-                }
+                if ( !CodeGen::isOperator( obj->name ) ) return;
+                auto type = obj->type->stripDeclarator();
+                if ( dynamic_cast< const ast::FunctionType * >( type ) ) return;
+                SemanticError( obj->location,
+                        toCString( "operator ", obj->name.c_str(), " is not "
+                        "a function or function pointer." ) );
         }
 };
@@ -234 +236 @@
         ast::Pass<TraitExpander>::run( transUnit );
         ast::Pass<AssertionFunctionFixer>::run( transUnit );
-        ast::Pass<OberatorChecker>::run( transUnit );
+        ast::Pass<OperatorChecker>::run( transUnit );
         ast::Pass<UniqueFixCore>::run( transUnit );
 }

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 declsToAddAfter once traversal is
+        /// outside of any namespaces.
+        void addDeclAfterOutside( ast::Decl const * );
 };
+
+void LinkTypesCore::enterNamespace() {
+        if ( inNamespace ) return;
+        inNamespace = true;
+        GuardAction( [this](){
+                inNamespace = false;
+                declsToAddAfter.splice( declsToAddAfter.begin(), declsToAddOutside );
+        } );
+}
+
+void LinkTypesCore::addDeclAfterOutside( ast::Decl const * decl ) {
+        if ( inNamespace ) {
+                declsToAddOutside.emplace_back( decl );
+        } else {
+                declsToAddAfter.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 );
+                ast::EnumDecl * mut = new ast::EnumDecl( *location, type->name );
+                mut->linkage = ast::Linkage::Compiler;
+                decl = mut;
+                symtab.addEnum( decl );
+                addDeclAfterOutside( 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 +133 @@
 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 );
+                ast::StructDecl * mut = new ast::StructDecl( *location, type->name );
+                mut->linkage = ast::Linkage::Compiler;
+                decl = mut;
+                symtab.addStruct( decl );
+                addDeclAfterOutside( 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 +157 @@
 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 );
+                ast::UnionDecl * mut = new ast::UnionDecl( *location, type->name );
+                mut->linkage = ast::Linkage::Compiler;
+                decl = mut;
+                symtab.addUnion( decl );
+                addDeclAfterOutside( 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 +278 @@
 
 ast::StructDecl const * LinkTypesCore::previsit( ast::StructDecl const * decl ) {
+        enterNamespace();
         return renameGenericParams( decl );
 }
@@ -237 +297 @@
 
 ast::UnionDecl const * LinkTypesCore::previsit( ast::UnionDecl const * decl ) {
+        enterNamespace();
         return renameGenericParams( decl );
 }

src/Validate/ReplaceTypedef.cpp

@@ -20 +20 @@
 #include "Common/ScopedMap.h"
 #include "Common/UniqueName.h"
-#include "Common/utility.h"
 #include "ResolvExpr/Unify.h"
 
@@ -294 +293 @@
                 aggrDecl->name, ast::Storage::Classes(), type, aggrDecl->linkage );
         // Add the implicit typedef to the AST.
-        declsToAddBefore.push_back( ast::deepCopy( typeDecl.get() ) );
+        declsToAddAfter.push_back( ast::deepCopy( typeDecl.get() ) );
         // Shore the name in the map of names.
         typedefNames[ aggrDecl->name ] =
@@ -316 +315 @@
         auto mut = ast::mutate( decl );
 
-        std::vector<ast::ptr<ast::Decl>> members;
+        std::list<ast::ptr<ast::Decl>> members;
         // Unroll accept_all for decl->members so that implicit typedefs for
         // nested types are added to the aggregate body.
         for ( ast::ptr<ast::Decl> const & member : mut->members ) {
+                assert( declsToAddBefore.empty() );
                 assert( declsToAddAfter.empty() );
                 ast::Decl const * newMember = nullptr;
@@ -328 +328 @@
                 }
                 if ( !declsToAddBefore.empty() ) {
-                        for ( auto declToAdd : declsToAddBefore ) {
-                                members.push_back( declToAdd );
-                        }
-                        declsToAddBefore.clear();
+                        members.splice( members.end(), declsToAddBefore );
                 }
                 members.push_back( newMember );
-        }
+                if ( !declsToAddAfter.empty() ) {
+                        members.splice( members.end(), declsToAddAfter );
+                }
+        }
+        assert( declsToAddBefore.empty() );
         assert( declsToAddAfter.empty() );
         if ( !errors.isEmpty() ) { throw errors; }