Changeset 2a301ff for src/Validate

Timestamp:

Aug 31, 2023, 11:31:15 PM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

950c58e

Parents:

92355883 (diff), 686912c (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:

Resolve conflict

Location:

src/Validate

Files:

• Autogen.cpp (modified) (1 diff)
• FixQualifiedTypes.cpp (modified) (1 diff)
• ForallPointerDecay.cpp (modified) (9 diffs)
• ForallPointerDecay.hpp (modified) (1 diff)
• GenericParameter.cpp (modified) (5 diffs)
• LinkReferenceToTypes.cpp (modified) (9 diffs)
• NoIdSymbolTable.hpp (modified) (1 diff)
• ReplaceTypedef.cpp (modified) (4 diffs)

src/Validate/Autogen.cpp

@@ -532 +532 @@
                 )
         );
-        return genImplicitCall(
+        auto stmt = genImplicitCall(
                 srcParam, dstSelect, location, func->name,
                 field, direction
         );
+        // This could return the above directly, except the generated code is
+        // built using the structure's members and that means all the scoped
+        // names (the forall parameters) are incorrect. This corrects them.
+        if ( stmt && !decl->params.empty() ) {
+                ast::DeclReplacer::TypeMap oldToNew;
+                for ( auto pair : group_iterate( decl->params, func->type_params ) ) {
+                        oldToNew.emplace( std::get<0>(pair), std::get<1>(pair) );
+                }
+                auto node = ast::DeclReplacer::replace( stmt, oldToNew );
+                stmt = strict_dynamic_cast<const ast::Stmt *>( node );
+        }
+        return stmt;
 }
 

src/Validate/FixQualifiedTypes.cpp

@@ -89 +89 @@
         }
 
-        ast::Expr const * postvisit( ast::QualifiedNameExpr const * t) {
+        ast::Expr const * postvisit( ast::QualifiedNameExpr const * t ) {
                 assert( location );
-                if ( t->type_decl ) {
-                auto enumName = t->type_decl->name;
-                const ast::EnumDecl * enumDecl = symtab.lookupEnum( enumName );
-                        for ( ast::ptr<ast::Decl> const & member : enumDecl->members ) {
-                                if ( auto memberAsObj = member.as<ast::ObjectDecl>() ) {
-                                        if ( memberAsObj->name == t->name ) {
-                                                return new ast::VariableExpr( t->location, memberAsObj );
-                                        }
-                                } else {
-                                        assertf( false, "unhandled qualified child type");
+                if ( !t->type_decl ) return t;
+
+                auto enumName = t->type_decl->name;
+                const ast::EnumDecl * enumDecl = symtab.lookupEnum( enumName );
+                for ( ast::ptr<ast::Decl> const & member : enumDecl->members ) {
+                        if ( auto memberAsObj = member.as<ast::ObjectDecl>() ) {
+                                if ( memberAsObj->name == t->name ) {
+                                        return new ast::VariableExpr( t->location, memberAsObj );
                                 }
+                        } else {
+                                assertf( false, "unhandled qualified child type" );
                         }
+                }
 
-                auto var = new ast::ObjectDecl( t->location, t->name,
-                        new ast::EnumInstType(enumDecl, ast::CV::Const), nullptr, {}, ast::Linkage::Cforall );
-                        var->mangleName = Mangle::mangle( var );
-                        return new ast::VariableExpr( t->location, var );
-        }
-
-                return t;
+                auto var = new ast::ObjectDecl( t->location, t->name,
+                        new ast::EnumInstType( enumDecl, ast::CV::Const ),
+                        nullptr, {}, ast::Linkage::Cforall );
+                var->mangleName = Mangle::mangle( var );
+                return new ast::VariableExpr( t->location, var );
         }
 

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 );
+}
+
+void fixUniqueIds( ast::TranslationUnit & transUnit ) {
         ast::Pass<UniqueFixCore>::run( transUnit );
 }

src/Validate/ForallPointerDecay.hpp

@@ -27 +27 @@
 
 /// Cleans up assertion lists and expands traits.
-/// Also checks that operator names are used properly on functions and
-/// assigns unique IDs. This is a "legacy" pass.
+/// Also checks that operator names are used properly on functions.
+/// This is a "legacy" pass.
+/// Must happen before auto-gen routines are added.
+void decayForallPointers( ast::TranslationUnit & transUnit );
+
+/// Sets uniqueIds on any declarations that do not have one set.
 /// Must be after implement concurrent keywords; because uniqueIds must be
 /// set on declaration before resolution.
-/// Must happen before auto-gen routines are added.
-void decayForallPointers( ast::TranslationUnit & transUnit );
+void fixUniqueIds( ast::TranslationUnit & transUnit );
 
 /// Expand all traits in an assertion list.

src/Validate/GenericParameter.cpp

@@ -16 +16 @@
 #include "GenericParameter.hpp"
 
-#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Expr.hpp"
@@ -165 +164 @@
 
 struct TranslateDimensionCore :
-                public WithNoIdSymbolTable, public ast::WithGuards {
+                public WithNoIdSymbolTable, public ast::WithGuards,
+                public ast::WithVisitorRef<TranslateDimensionCore> {
 
         // SUIT: Struct- or Union- InstType
@@ -190 +190 @@
 
         const ast::TypeDecl * postvisit( const ast::TypeDecl * decl );
+        const ast::Type * postvisit( const ast::FunctionType * type );
+        const ast::Type * postvisit( const ast::TypeInstType * type );
+
         const ast::Expr * postvisit( const ast::DimensionExpr * expr );
         const ast::Expr * postvisit( const ast::Expr * expr );
@@ -195 +198 @@
 };
 
+// Declaration of type variable: forall( [N] )  ->  forall( N & | sized( N ) )
 const ast::TypeDecl * TranslateDimensionCore::postvisit(
                 const ast::TypeDecl * decl ) {
@@ -206 +210 @@
         }
         return decl;
+}
+
+// Makes postvisit( TypeInstType ) get called on the entries of the function declaration's type's forall list.
+// Pass.impl.hpp's visit( FunctionType ) does not consider the forall entries to be child nodes.
+// Workaround is: during the current TranslateDimension pass, manually visit down there.
+const ast::Type * TranslateDimensionCore::postvisit(
+                const ast::FunctionType * type ) {
+        visitor->maybe_accept( type, &ast::FunctionType::forall );
+        return type;
+}
+
+// Use of type variable, assuming `forall( [N] )` in scope:  void (*)( foo( /*dimension*/ N ) & )  ->  void (*)( foo( /*dtype*/ N ) & )
+const ast::Type * TranslateDimensionCore::postvisit(
+                const ast::TypeInstType * type ) {
+        if ( type->kind == ast::TypeDecl::Dimension ) {
+                auto mutType = ast::mutate( type );
+                mutType->kind = ast::TypeDecl::Dtype;
+                return mutType;
+        }
+        return type;
 }
 

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 ) {
@@ -81 +109 @@
         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.
-        if ( decl ) {
-                // Just linking in the node.
-                auto mut = ast::mutate( type );
-                mut->base = decl;
-                type = mut;
-        }
-        if ( !decl || !decl->body ) {
-                auto mut = ast::mutate( type );
+        // 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 ) {
                 forwardEnums[ mut->name ].push_back( mut );
-                type = mut;
-        }
-        return type;
+        }
+        return mut;
 }
 
@@ -98 +134 @@
         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.
-        if ( decl ) {
-                // Just linking in the node.
-                auto mut = ast::mutate( type );
-                mut->base = decl;
-                type = mut;
-        }
-        if ( !decl || !decl->body ) {
-                auto mut = ast::mutate( type );
+        // 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 ) {
                 forwardStructs[ mut->name ].push_back( mut );
-                type = mut;
-        }
-        return type;
+        }
+        return mut;
 }
 
@@ -115 +158 @@
         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.
-        if ( decl ) {
-                // Just linking in the node.
-                auto mut = ast::mutate( type );
-                mut->base = decl;
-                type = mut;
-        }
-        if ( !decl || !decl->body ) {
-                auto mut = ast::mutate( type );
+        // 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 ) {
                 forwardUnions[ mut->name ].push_back( mut );
-                type = mut;
-        }
-        return type;
+        }
+        return mut;
 }
 
@@ -228 +278 @@
 
 ast::StructDecl const * LinkTypesCore::previsit( ast::StructDecl const * decl ) {
+        enterNamespace();
         return renameGenericParams( decl );
 }
@@ -246 +297 @@
 
 ast::UnionDecl const * LinkTypesCore::previsit( ast::UnionDecl const * decl ) {
+        enterNamespace();
         return renameGenericParams( decl );
 }
@@ -264 +316 @@
 
 ast::TraitDecl const * LinkTypesCore::postvisit( ast::TraitDecl const * decl ) {
-        auto mut = ast::mutate( decl );
-        if ( mut->name == "sized" ) {
-                // "sized" is a special trait - flick the sized status on for the type variable.
-                assertf( mut->params.size() == 1, "Built-in trait 'sized' has incorrect number of parameters: %zd", decl->params.size() );
-                ast::TypeDecl * td = mut->params.front().get_and_mutate();
-                td->sized = true;
-        }
-
         // There is some overlap with code from decayForallPointers,
         // perhaps reorganization or shared helper functions are called for.
         // Move assertions from type parameters into the body of the trait.
+        auto mut = ast::mutate( decl );
         for ( ast::ptr<ast::TypeDecl> const & td : decl->params ) {
                 auto expanded = expandAssertions( td->assertions );

src/Validate/NoIdSymbolTable.hpp

@@ -46 +46 @@
         FORWARD_1( addUnion , const ast::UnionDecl *     )
         FORWARD_1( addTrait , const ast::TraitDecl *     )
-        FORWARD_1( addStruct, const std::string &        )
-        FORWARD_1( addUnion , const std::string &        )
         FORWARD_2( addWith  , const std::vector< ast::ptr<ast::Expr> > &, const ast::Decl * )
+        FORWARD_1( addStructId, const std::string & )
+        FORWARD_1( addUnionId , const std::string & )
 
         FORWARD_1( globalLookupType, const std::string & )

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