Changeset b7c53a9d for src

Timestamp:

Jul 14, 2023, 9:32:31 AM (14 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.

Location:

src

Files:

• AST/Util.cpp (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• Validate/ForallPointerDecay.cpp (modified) (9 diffs)
• Validate/LinkReferenceToTypes.cpp (modified) (8 diffs)
• Validate/ReplaceTypedef.cpp (modified) (4 diffs)

src/AST/Util.cpp

@@ -102 +102 @@
 }
 
+/// Check for Floating Nodes:
+/// Every node should be reachable from a root (the TranslationUnit) via a
+/// chain of structural references (tracked with ptr). This cannot check all
+/// of that, it just checks if a given node's field has a strong reference.
+template<typename node_t, typename field_t>
+void noFloatingNode( const node_t * node, field_t node_t::*field_ptr ) {
+        const field_t & field = node->*field_ptr;
+        if ( nullptr == field ) return;
+        assertf( field->isManaged(), "Floating node found." );
+}
+
 struct InvariantCore {
         // To save on the number of visits: this is a kind of composed core.
@@ -127 +138 @@
         }
 
+        void previsit( const VariableExpr * node ) {
+                previsit( (const ParseNode *)node );
+                noFloatingNode( node, &VariableExpr::var );
+        }
+
         void previsit( const MemberExpr * node ) {
                 previsit( (const ParseNode *)node );
                 memberMatchesAggregate( node );
+        }
+
+        void previsit( const StructInstType * node ) {
+                previsit( (const Node *)node );
+                noFloatingNode( node, &StructInstType::base );
+        }
+
+        void previsit( const UnionInstType * node ) {
+                previsit( (const Node *)node );
+                noFloatingNode( node, &UnionInstType::base );
+        }
+
+        void previsit( const EnumInstType * node ) {
+                previsit( (const Node *)node );
+                noFloatingNode( node, &EnumInstType::base );
+        }
+
+        void previsit( const TypeInstType * node ) {
+                previsit( (const Node *)node );
+                noFloatingNode( node, &TypeInstType::base );
         }
 

src/InitTweak/InitTweak.cc

@@ -882 +882 @@
                 if (!assign) {
                         auto td = new ast::TypeDecl(CodeLocation(), "T", {}, nullptr, ast::TypeDecl::Dtype, true);
-                        assign = new ast::FunctionDecl(CodeLocation(), "?=?", {},
+                        assign = new ast::FunctionDecl(CodeLocation(), "?=?", {td},
                         { new ast::ObjectDecl(CodeLocation(), "_dst", new ast::ReferenceType(new ast::TypeInstType("T", td))),
                           new ast::ObjectDecl(CodeLocation(), "_src", new ast::TypeInstType("T", td))},

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 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 );
 }

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; }