Changeset 2a301ff for src/AST/Util.cpp

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

File:

• src/AST/Util.cpp (modified) (5 diffs)

src/AST/Util.cpp

@@ -20 +20 @@
 #include "Pass.hpp"
 #include "TranslationUnit.hpp"
+#include "Common/utility.h"
+#include "GenPoly/ScopedSet.h"
 
 #include <vector>
+
+using GenPoly::ScopedSet;
 
 namespace ast {
@@ -102 +106 @@
 }
 
+/// 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 +142 @@
         }
 
+        void previsit( const VariableExpr * node ) {
+                previsit( (const ParseNode *)node );
+                noFloatingNode( node, &VariableExpr::var );
+        }
+
         void previsit( const MemberExpr * node ) {
                 previsit( (const ParseNode *)node );
@@ -132 +152 @@
         }
 
+        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 );
+        }
+
         void postvisit( const Node * node ) {
                 no_strong_cycles.postvisit( node );
@@ -137 +177 @@
 };
 
+/// Checks that referred to nodes are in scope.
+/// This checks many readonly pointers to see if the declaration they are
+/// referring to is in scope by the structural rules of code.
+// Any escapes marked with a bug should be removed once the bug is fixed.
+struct InScopeCore : public ast::WithShortCircuiting {
+        ScopedSet<DeclWithType const *> typedDecls;
+        ScopedSet<TypeDecl const *> typeDecls;
+        // These 3 are really hard to check, because uses that originally ref. at
+        // a forward declaration can be rewired to point a later full definition.
+        ScopedSet<StructDecl const *> structDecls;
+        ScopedSet<UnionDecl const *> unionDecls;
+        ScopedSet<EnumDecl const *> enumDecls;
+        ScopedSet<TraitDecl const *> traitDecls;
+
+        bool isInGlobal = false;
+
+        void beginScope() {
+                typedDecls.beginScope();
+                typeDecls.beginScope();
+                structDecls.beginScope();
+                unionDecls.beginScope();
+                enumDecls.beginScope();
+                traitDecls.beginScope();
+        }
+
+        void endScope() {
+                typedDecls.endScope();
+                typeDecls.endScope();
+                structDecls.endScope();
+                unionDecls.endScope();
+                enumDecls.endScope();
+                traitDecls.endScope();
+        }
+
+        void previsit( ApplicationExpr const * expr ) {
+                // All isInGlobal manipulation is just to isolate this check.
+                // The invalid compound literals lead to bad ctor/dtors. [#280]
+                VariableExpr const * func = nullptr;
+                CastExpr const * cast = nullptr;
+                VariableExpr const * arg = nullptr;
+                if ( isInGlobal
+                                && 1 == expr->args.size()
+                                && ( func = expr->func.as<VariableExpr>() )
+                                && ( "?{}" == func->var->name || "^?{}" == func->var->name )
+                                && ( cast = expr->args[0].as<CastExpr>() )
+                                && ( arg = cast->arg.as<VariableExpr>() )
+                                && isPrefix( arg->var->name, "_compLit" ) ) {
+                        visit_children = false;
+                }
+        }
+
+        void previsit( VariableExpr const * expr ) {
+                if ( !expr->var ) return;
+                // bitwise assignment escape [#281]
+                if ( expr->var->location.isUnset() ) return;
+                assert( typedDecls.contains( expr->var ) );
+        }
+
+        void previsit( FunctionType const * type ) {
+                // This is to avoid checking the assertions, which can point at the
+                // function's declaration and not the enclosing function.
+                for ( auto type_param : type->forall ) {
+                        if ( type_param->formal_usage ) {
+                                visit_children = false;
+                                // We could check non-assertion fields here.
+                        }
+                }
+        }
+
+        void previsit( TypeInstType const * type ) {
+                if ( !type->base ) return;
+                assertf( type->base->isManaged(), "Floating Node" );
+
+                // bitwise assignment escape [#281]
+                if ( type->base->location.isUnset() ) return;
+                // Formal types can actually look at out of scope variables.
+                if ( type->formal_usage ) return;
+                assert( typeDecls.contains( type->base ) );
+        }
+
+        void previsit( TraitInstType const * type ) {
+                if ( !type->base ) return;
+                assert( traitDecls.contains( type->base ) );
+        }
+
+        void previsit( ObjectDecl const * decl ) {
+                typedDecls.insert( decl );
+                // There are some ill-formed compound literals. [#280]
+                // The only known problem cases are at the top level.
+                if ( isPrefix( decl->name, "_compLit" ) ) {
+                        visit_children = false;
+                }
+        }
+
+        void previsit( FunctionDecl const * decl ) {
+                typedDecls.insert( decl );
+                beginScope();
+                for ( auto & type_param : decl->type_params ) {
+                        typeDecls.insert( type_param );
+                }
+                for ( auto & assertion : decl->assertions ) {
+                        typedDecls.insert( assertion );
+                }
+                for ( auto & param : decl->params ) {
+                        typedDecls.insert( param );
+                }
+                for ( auto & ret : decl->returns ) {
+                        typedDecls.insert( ret );
+                }
+                // No special handling of withExprs.
+
+                // Part of the compound literal escape. [#280]
+                if ( "__global_init__" == decl->name
+                                || "__global_destroy__" == decl->name ) {
+                        assert( !isInGlobal );
+                        isInGlobal = true;
+                }
+        }
+
+        void postvisit( FunctionDecl const * decl ) {
+                endScope();
+                // Part of the compound literal escape. [#280]
+                if ( isInGlobal && ( "__global_init__" == decl->name
+                                || "__global_destroy__" == decl->name ) ) {
+                        isInGlobal = false;
+                }
+        }
+
+        void previsit( StructDecl const * decl ) {
+                structDecls.insert( decl );
+                beginScope();
+                for ( auto & type_param : decl->params ) {
+                        typeDecls.insert( type_param );
+                }
+        }
+
+        void postvisit( StructDecl const * ) {
+                endScope();
+        }
+
+        void previsit( UnionDecl const * decl ) {
+                unionDecls.insert( decl );
+                beginScope();
+                for ( auto & type_param : decl->params ) {
+                        typeDecls.insert( type_param );
+                }
+        }
+
+        void postvisit( UnionDecl const * ) {
+                endScope();
+        }
+
+        void previsit( EnumDecl const * decl ) {
+                enumDecls.insert( decl );
+                if ( ast::EnumDecl::EnumHiding::Visible == decl->hide ) {
+                        for ( auto & member : decl->members ) {
+                                typedDecls.insert( member.strict_as<ast::DeclWithType>() );
+                        }
+                }
+                beginScope();
+                for ( auto & type_param : decl->params ) {
+                        typeDecls.insert( type_param );
+                }
+        }
+
+        void postvisit( EnumDecl const * ) {
+                endScope();
+        }
+
+        void previsit( TraitDecl const * decl ) {
+                traitDecls.insert( decl );
+                beginScope();
+                for ( auto & type_param : decl->params ) {
+                        typeDecls.insert( type_param );
+                }
+        }
+
+        void postvisit( TraitDecl const * ) {
+                endScope();
+        }
+
+        void previsit( Designation const * ) {
+                visit_children = false;
+        }
+};
+
 } // namespace
 
 void checkInvariants( TranslationUnit & transUnit ) {
-        ast::Pass<InvariantCore>::run( transUnit );
+        Pass<InvariantCore>::run( transUnit );
+        Pass<InScopeCore>::run( transUnit );
 }