Changes in / [dbf5e18:847ab8f]

Location:

src

Files:

• AST/Util.cpp (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• Parser/parser.yy (modified) (4 diffs)
• 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.
@@ -138 +127 @@
         }
 
-        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(), "?=?", {td},
+                        assign = new ast::FunctionDecl(CodeLocation(), "?=?", {},
                         { new ast::ObjectDecl(CodeLocation(), "_dst", new ast::ReferenceType(new ast::TypeInstType("T", td))),
                           new ast::ObjectDecl(CodeLocation(), "_src", new ast::TypeInstType("T", td))},

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jul 12 23:06:44 2023
-// Update Count     : 6389
+// Last Modified On : Wed Jul 12 06:14:16 2023
+// Update Count     : 6382
 //
 
@@ -1868 +1868 @@
 
 KR_parameter_list:
-        c_declaration ';'
-                { $$ = $1; }
-        | KR_parameter_list c_declaration ';'
-                { $$ = $1->appendList( $2 ); }
+        push c_declaration pop ';'
+                { $$ = $2; }
+        | KR_parameter_list push c_declaration pop ';'
+                { $$ = $1->appendList( $3 ); }
         ;
 
@@ -2033 +2033 @@
                         } else $$ = $3->addType( $2 )->addTypedef(); // watchout frees $2 and $3
                 }
-        | typedef_declaration ',' declarator
-                {
-                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "typedef_declaration 2" );
-                        $$ = $1->appendList( $1->cloneBaseType( $3 )->addTypedef() );
+        | typedef_declaration pop ',' push declarator
+                {
+                        typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname, "typedef_declaration 2" );
+                        $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
                 }
         | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
@@ -2052 +2052 @@
                         SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
                 }
-        | typedef_expression ',' identifier '=' assignment_expression
+        | typedef_expression pop ',' push identifier '=' assignment_expression
                 {
                         SemanticError( yylloc, "TYPEDEF expression is deprecated, use typeof(...) instead." ); $$ = nullptr;

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 {
@@ -50 +51 @@
 }
 
-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;
+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();
 }
 
@@ -98 +96 @@
                                         decl->get_type() ) ) {
                                 auto moreAsserts = expandTrait( traitInst );
-                                splice( assertions, moreAsserts );
+                                append( assertions, moreAsserts );
                         } else {
                                 assertions.push_back( decl );
@@ -110 +108 @@
         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,
@@ -126 +123 @@
                 mut->assertions = expandAssertions( decl->assertions );
                 // Update the assertion list on the type as well.
-                return updateAssertions( mut );
+                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;
         }
 
@@ -150 +154 @@
                 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;
@@ -184 +187 @@
         }
 
-        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() ) {
@@ -208 +204 @@
 };
 
-struct OperatorChecker final {
+struct OberatorChecker final {
         void previsit( const ast::ObjectDecl * obj ) {
-                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." ) );
+                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." ) );
+                        }
+                }
         }
 };
@@ -236 +234 @@
         ast::Pass<TraitExpander>::run( transUnit );
         ast::Pass<AssertionFunctionFixer>::run( transUnit );
-        ast::Pass<OperatorChecker>::run( transUnit );
+        ast::Pass<OberatorChecker>::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 : Fri Jul 14  9:19:00 2023
-// Update Count     : 3
+// Last Modified On : Tue Sep 20 16:17:00 2022
+// Update Count     : 2
 //
 
@@ -27 +27 @@
 struct LinkTypesCore : public WithNoIdSymbolTable,
                 public ast::WithCodeLocation,
-                public ast::WithDeclsToAdd<>,
                 public ast::WithGuards,
                 public ast::WithShortCircuiting,
@@ -64 +63 @@
         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 ) {
@@ -108 +80 @@
 ast::EnumInstType const * LinkTypesCore::postvisit( ast::EnumInstType const * type ) {
         ast::EnumDecl const * decl = symtab.lookupEnum( type->name );
+        ast::EnumInstType * mut = ast::mutate( type );
         // 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 );
-
-        // Just linking in the node.
-        mut->base = decl;
-
-        if ( !decl->body ) {
+        if ( decl ) {
+                // Just linking in the node.
+                mut->base = decl;
+        }
+        if ( !decl || !decl->body ) {
                 forwardEnums[ mut->name ].push_back( mut );
         }
@@ -133 +94 @@
 ast::StructInstType const * LinkTypesCore::postvisit( ast::StructInstType const * type ) {
         ast::StructDecl const * decl = symtab.lookupStruct( type->name );
+        ast::StructInstType * mut = ast::mutate( type );
         // 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 );
-
-        // Just linking in the node.
-        mut->base = decl;
-
-        if ( !decl->body ) {
+        if ( decl ) {
+                // Just linking in the node.
+                mut->base = decl;
+        }
+        if ( !decl || !decl->body ) {
                 forwardStructs[ mut->name ].push_back( mut );
         }
@@ -157 +108 @@
 ast::UnionInstType const * LinkTypesCore::postvisit( ast::UnionInstType const * type ) {
         ast::UnionDecl const * decl = symtab.lookupUnion( type->name );
+        ast::UnionInstType * mut = ast::mutate( type );
         // 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 );
-
-        // Just linking in the node.
-        mut->base = decl;
-
-        if ( !decl->body ) {
+        if ( decl ) {
+                // Just linking in the node.
+                mut->base = decl;
+        }
+        if ( !decl || !decl->body ) {
                 forwardUnions[ mut->name ].push_back( mut );
         }
@@ -278 +219 @@
 
 ast::StructDecl const * LinkTypesCore::previsit( ast::StructDecl const * decl ) {
-        enterNamespace();
         return renameGenericParams( decl );
 }
@@ -297 +237 @@
 
 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"
 
@@ -293 +294 @@
                 aggrDecl->name, ast::Storage::Classes(), type, aggrDecl->linkage );
         // Add the implicit typedef to the AST.
-        declsToAddAfter.push_back( ast::deepCopy( typeDecl.get() ) );
+        declsToAddBefore.push_back( ast::deepCopy( typeDecl.get() ) );
         // Shore the name in the map of names.
         typedefNames[ aggrDecl->name ] =
@@ -315 +316 @@
         auto mut = ast::mutate( decl );
 
-        std::list<ast::ptr<ast::Decl>> members;
+        std::vector<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() ) {
-                        members.splice( members.end(), declsToAddBefore );
+                        for ( auto declToAdd : declsToAddBefore ) {
+                                members.push_back( declToAdd );
+                        }
+                        declsToAddBefore.clear();
                 }
                 members.push_back( newMember );
-                if ( !declsToAddAfter.empty() ) {
-                        members.splice( members.end(), declsToAddAfter );
-                }
-        }
-        assert( declsToAddBefore.empty() );
+        }
         assert( declsToAddAfter.empty() );
         if ( !errors.isEmpty() ) { throw errors; }