Changes in src/GenPoly/BoxNew.cpp [5e0bba5f:61e5d99]

File:

• src/GenPoly/BoxNew.cpp (modified) (26 diffs)

src/GenPoly/BoxNew.cpp

@@ -39 +39 @@
 
 namespace {
+
+/// Common field of several sub-passes of box.
+struct BoxPass {
+        TypeVarMap scopeTypeVars;
+        BoxPass() : scopeTypeVars( ast::TypeData() ) {}
+};
+
+// TODO: Could this be a common helper somewhere?
+ast::FunctionType * makeFunctionType( ast::FunctionDecl const * decl ) {
+        ast::FunctionType * type = new ast::FunctionType(
+                decl->type->isVarArgs, decl->type->qualifiers
+        );
+        for ( auto type_param : decl->type_params ) {
+                type->forall.emplace_back( new ast::TypeInstType( type_param ) );
+        }
+        for ( auto assertion : decl->assertions ) {
+                type->assertions.emplace_back( new ast::VariableExpr(
+                        assertion->location, assertion ) );
+        }
+        for ( auto param : decl->params ) {
+                type->params.emplace_back( param->get_type() );
+        }
+        for ( auto retval : decl->returns ) {
+                type->returns.emplace_back( retval->get_type() );
+        }
+        return type;
+}
 
 // --------------------------------------------------------------------------
@@ -332 +359 @@
 /// * Adds appropriate type variables to the function calls.
 struct CallAdapter final :
+                public BoxPass,
                 public ast::WithConstTypeSubstitution,
                 public ast::WithGuards,
@@ -348 +376 @@
         ast::Expr const * postvisit( ast::AddressExpr const * expr );
         ast::ReturnStmt const * previsit( ast::ReturnStmt const * stmt );
+        void previsit( ast::PointerType const * type );
+        void previsit( ast::FunctionType const * type );
 
         void beginScope();
@@ -410 +440 @@
                 CodeLocation const & location, ast::Type const * type );
 
-        TypeVarMap scopeTypeVars;
+        /// Set of adapter functions in the current scope.
         ScopedMap< std::string, ast::DeclWithType const * > adapters;
         std::map< ast::ApplicationExpr const *, ast::Expr const * > retVals;
@@ -523 +553 @@
 
 ast::FunctionDecl const * CallAdapter::previsit( ast::FunctionDecl const * decl ) {
-        // Prevent type declaration information from leaking out.
+        if ( nullptr == decl->stmts ) {
+                // This may keep TypeDecls we don't ever want from sneaking in.
+                // Not visiting child nodes might just be faster.
+                GuardScope( scopeTypeVars );
+                return decl;
+        }
+
         GuardScope( scopeTypeVars );
-
-        if ( nullptr == decl->stmts ) {
-                return decl;
-        }
-
         GuardValue( retval );
 
@@ -631 +662 @@
         ptrdiff_t initArgCount = mutExpr->args.size();
 
-        TypeVarMap exprTypeVars;
+        TypeVarMap exprTypeVars = { ast::TypeData() };
         // TODO: Should this take into account the variables already bound in
         // scopeTypeVars ([ex] remove them from exprTypeVars)?
@@ -656 +687 @@
 
         assert( typeSubs );
+        ast::Type const * concRetType = replaceWithConcrete( dynRetType, *typeSubs );
+        // Used to use dynRetType instead of concRetType; this changed so that
+        // the correct type parameters are passed for return types (it should be
+        // the concrete type's parameters, not the formal type's).
         ast::vector<ast::Expr>::iterator argIt =
                 passTypeVars( mutExpr, function );
@@ -733 +768 @@
         }
         return stmt;
+}
+
+void CallAdapter::previsit( ast::PointerType const * type ) {
+        GuardScope( scopeTypeVars );
+        makeTypeVarMap( type, scopeTypeVars );
+}
+
+void CallAdapter::previsit( ast::FunctionType const * type ) {
+        GuardScope( scopeTypeVars );
+        makeTypeVarMap( type, scopeTypeVars );
 }
 
@@ -1382 +1427 @@
 
 ast::FunctionDecl const * DeclAdapter::previsit( ast::FunctionDecl const * decl ) {
-        TypeVarMap localTypeVars;
+        TypeVarMap localTypeVars = { ast::TypeData() };
         makeTypeVarMap( decl, localTypeVars );
 
@@ -1413 +1458 @@
                         layoutParams.emplace_back( alignParam );
                 }
-                // Assertions should be stored in the main list.
-                assert( mutParam->assertions.empty() );
+                // TODO: These should possibly all be gone.
+                // More all assertions into parameter list.
+                for ( ast::ptr<ast::DeclWithType> & assert : mutParam->assertions ) {
+                        // Assertion parameters may not be used in body,
+                        // pass along with unused attribute.
+                        assert.get_and_mutate()->attributes.push_back(
+                                new ast::Attribute( "unused" ) );
+                        inferredParams.push_back( assert );
+                }
+                mutParam->assertions.clear();
                 typeParam = mutParam;
         }
+        // TODO: New version of inner loop.
         for ( ast::ptr<ast::DeclWithType> & assert : mutDecl->assertions ) {
                 // Assertion parameters may not be used in body,
@@ -1431 +1485 @@
         spliceBegin( mutDecl->params, layoutParams );
         addAdapters( mutDecl, localTypeVars );
-
-        // Now have to update the type to match the declaration.
-        ast::FunctionType * type = new ast::FunctionType(
-                mutDecl->type->isVarArgs, mutDecl->type->qualifiers );
-        for ( auto type_param : mutDecl->type_params ) {
-                type->forall.emplace_back( new ast::TypeInstType( type_param ) );
-        }
-        for ( auto param : mutDecl->params ) {
-                type->params.emplace_back( param->get_type() );
-        }
-        for ( auto retval : mutDecl->returns ) {
-                type->returns.emplace_back( retval->get_type() );
-        }
-        mutDecl->type = type;
 
         return mutDecl;
@@ -1478 +1518 @@
                 }
         }
+        // TODO: Can this be updated as we go along?
+        mutDecl->type = makeFunctionType( mutDecl );
         return mutDecl;
 }
@@ -1533 +1575 @@
         assertf( it != adapters.end(), "Could not correct floating node." );
         return ast::mutate_field( expr, &ast::VariableExpr::var, it->second );
+
 }
 
@@ -1544 +1587 @@
 /// * Inserts dynamic calculation of polymorphic type layouts where needed.
 struct PolyGenericCalculator final :
+                public BoxPass,
                 public ast::WithConstTypeSubstitution,
                 public ast::WithDeclsToAdd<>,
@@ -1551 +1595 @@
         PolyGenericCalculator();
 
+        void previsit( ast::ObjectDecl const * decl );
         void previsit( ast::FunctionDecl const * decl );
         void previsit( ast::TypedefDecl const * decl );
@@ -1557 +1602 @@
         ast::StructDecl const * previsit( ast::StructDecl const * decl );
         ast::UnionDecl const * previsit( ast::UnionDecl const * decl );
+        void previsit( ast::PointerType const * type );
+        void previsit( ast::FunctionType const * type );
         ast::DeclStmt const * previsit( ast::DeclStmt const * stmt );
         ast::Expr const * postvisit( ast::MemberExpr const * expr );
@@ -1588 +1635 @@
         /// C sizeof().
         ast::Expr const * genSizeof( CodeLocation const &, ast::Type const * );
+
         /// Enters a new scope for type-variables,
         /// adding the type variables from the provided type.
         void beginTypeScope( ast::Type const * );
-
-        /// The type variables and polymorphic parameters currently in scope.
-        TypeVarMap scopeTypeVars;
+        /// Enters a new scope for known layouts and offsets, and queues exit calls.
+        void beginGenericScope();
+
         /// Set of generic type layouts known in the current scope,
         /// indexed by sizeofName.
@@ -1604 +1652 @@
         /// If the argument of an AddressExpr is MemberExpr, it is stored here.
         ast::MemberExpr const * addrMember = nullptr;
+        /// Used to avoid recursing too deep in type declarations.
+        bool expect_func_type = false;
 };
 
@@ -1625 +1675 @@
 }
 
+void PolyGenericCalculator::previsit( ast::ObjectDecl const * decl ) {
+        beginTypeScope( decl->type );
+}
+
 void PolyGenericCalculator::previsit( ast::FunctionDecl const * decl ) {
-        GuardScope( *this );
+        beginGenericScope();
         beginTypeScope( decl->type );
 }
@@ -1642 +1696 @@
                 ast::TypeDecl const * decl ) {
         ast::Type const * base = decl->base;
-        if ( nullptr == base ) return decl;
+        if ( nullptr == base) return decl;
 
         // Add size/align variables for opaque type declarations.
@@ -1667 +1721 @@
         alignDecl->accept( *visitor );
 
-        // A little trick to replace this with two declarations.
-        // Adding after makes sure that there is no conflict with adding stmts.
+        // Can't use [makeVar], because it inserts into stmtsToAdd and TypeDecls
+        // can occur at global scope.
         declsToAddAfter.push_back( alignDecl );
+        // replace with sizeDecl.
         return sizeDecl;
 }
@@ -1687 +1742 @@
 }
 
+void PolyGenericCalculator::previsit( ast::PointerType const * type ) {
+        beginTypeScope( type );
+}
+
+void PolyGenericCalculator::previsit( ast::FunctionType const * type ) {
+        beginTypeScope( type );
+
+        GuardValue( expect_func_type );
+        GuardScope( *this );
+
+        // The other functions type we will see in this scope are probably
+        // function parameters they don't help us with the layout and offsets so
+        // don't mark them as known in this scope.
+        expect_func_type = false;
+}
+
+//void PolyGenericCalculator::previsit( ast::DeclStmt const * stmt ) {
 ast::DeclStmt const * PolyGenericCalculator::previsit( ast::DeclStmt const * stmt ) {
         ast::ObjectDecl const * decl = stmt->decl.as<ast::ObjectDecl>();
@@ -1694 +1766 @@
 
         // Change initialization of a polymorphic value object to allocate via a
-        // variable-length-array (alloca cannot be safely used in loops).
+        // variable-length-array (alloca was previouly used, but it cannot be
+        // safely used in loops).
         ast::ObjectDecl * newBuf = new ast::ObjectDecl( decl->location,
                 bufNamer.newName(),
@@ -2175 +2248 @@
 }
 
+void PolyGenericCalculator::beginGenericScope() {
+        GuardScope( *this );
+        // We expect the first function type see to be the type relating to this
+        // scope but any further type is probably some unrelated function pointer
+        // keep track of whrich is the first.
+        GuardValue( expect_func_type ) = true;
+}
+
 // --------------------------------------------------------------------------
-/// Removes unneeded or incorrect type information.
+/// No common theme found.
 /// * Replaces initialization of polymorphic values with alloca.
 /// * Replaces declaration of dtype/ftype with appropriate void expression.
@@ -2182 +2263 @@
 /// * Strips fields from generic structure declarations.
 struct Eraser final :
+                public BoxPass,
                 public ast::WithGuards {
         void guardTypeVarMap( ast::Type const * type ) {
@@ -2196 +2278 @@
         void previsit( ast::PointerType const * type );
         void previsit( ast::FunctionType const * type );
-public:
-        TypeVarMap scopeTypeVars;
 };