Changeset 3e91c6f9 for src/GenPoly/InstantiateGeneric.cpp

Timestamp:

Mar 13, 2025, 9:26:17 AM (4 weeks ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

8b639f9

Parents:

3bd9508 (diff), 594671a (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:

fix pull conflicit

File:

• src/GenPoly/InstantiateGeneric.cpp (modified) (7 diffs)

src/GenPoly/InstantiateGeneric.cpp ¶

@@ -10 +10 @@
 // Created On       : Tue Aug 16 10:51:00 2022
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Oct 31 16:48:00 2022
-// Update Count     : 1
+// Last Modified On : Wed Mar 12 15:18:00 2025
+// Update Count     : 2
 //
 
@@ -159 +159 @@
 }
 
+/// Get the scrubbed type of a declaration (see scrubTypeVars functions).
+ast::TypeExpr const * scrubTypeDecl(
+                CodeLocation const & location, ast::TypeDecl const * typeDecl ) {
+        switch ( typeDecl->kind ) {
+        // Erase any incomplete dtype to `void` (`T *` -> `void *`).
+        case ast::TypeDecl::Dtype:
+                return new ast::TypeExpr( location, new ast::VoidType() );
+        // Erase any ftype to `void (*)(void)`.
+        case ast::TypeDecl::Ftype:
+                return new ast::TypeExpr( location, new ast::FunctionType() );
+        // Remaining cases are not supported.
+        case ast::TypeDecl::Ttype:
+                assertf( false, "Ttype parameters are not currently allowed as parameters to generic types." );
+                break;
+        default:
+                assertf( false, "Unhandled type parameter kind" );
+                break;
+        }
+}
+
 /// Makes substitutions of params into baseParams; returns dtypeStatic if
 /// there is a concrete instantiation based only on {d,f}type-to-void
@@ -190 +210 @@
                                 gt |= GenericType::concrete;
                         }
-                } else switch ( (*baseParam)->kind ) {
-                case ast::TypeDecl::Dtype:
-                        // Here, pretend that any incomplete dtype is `void`.
-                        out.emplace_back( new ast::TypeExpr( paramExpr->location,
-                                new ast::VoidType() ) );
-                        break;
-                case ast::TypeDecl::Ftype:
-                        // Here, pretend that any ftype is `void (*)(void)`.
-                        out.emplace_back( new ast::TypeExpr( paramExpr->location,
-                                new ast::FunctionType() ) );
-                        break;
-                case ast::TypeDecl::Ttype:
-                        assertf( false, "Ttype parameters are not currently allowed as parameters to generic types." );
-                        break;
-                default:
-                        assertf( false, "Unhandled type parameter kind" );
-                        break;
+                } else {
+                        out.emplace_back( scrubTypeDecl( paramExpr->location, *baseParam ) );
                 }
         }
@@ -443 +448 @@
                 instantiations(), dtypeStatics(), typeNamer("_conc_") {}
 
+        ast::StructDecl const * previsit( ast::StructDecl const * );
+        ast::UnionDecl const * previsit( ast::UnionDecl const * );
+
         ast::Type const * postvisit( ast::StructInstType const * inst );
         ast::Type const * postvisit( ast::UnionInstType const * inst );
@@ -481 +489 @@
 
         template<typename AggrDecl>
+        AggrDecl const * fixAggrDecl( AggrDecl const * decl );
+
+        template<typename AggrDecl>
         ast::Type const * fixInstType( ast::SueInstType<AggrDecl> const * inst );
 
@@ -489 +500 @@
                 ast::vector<ast::TypeExpr> const & typeSubs );
 };
+
+ast::StructDecl const * GenericInstantiator::previsit( ast::StructDecl const * decl ) {
+        return fixAggrDecl( decl );
+}
+
+ast::UnionDecl const * GenericInstantiator::previsit( ast::UnionDecl const * decl ) {
+        return fixAggrDecl( decl );
+}
+
+template<typename AggrDecl>
+AggrDecl const * GenericInstantiator::fixAggrDecl( AggrDecl const * decl ) {
+        // This function and stripDtypeParams handle declarations before their
+        // first use (required to be in the previsit for types with a self use).
+        if ( decl->params.empty() || !isDtypeStatic( decl->params ) ) {
+                return decl;
+        }
+
+        ast::vector<ast::TypeExpr> typeSubs;
+        for ( auto const & param : decl->params ) {
+                assert( !param->isComplete() );
+                typeSubs.emplace_back( scrubTypeDecl( param->location, param ) );
+        }
+
+        assert( decl->unique() );
+        auto mutDecl = ast::mutate( decl );
+        stripDtypeParams( mutDecl, mutDecl->params, typeSubs );
+
+        return mutDecl;
+}
 
 ast::Type const * GenericInstantiator::postvisit(
@@ -531 +571 @@
         case GenericType::dtypeStatic:
         {
+                // This call to stripDtypeParams is used when a forward declaration
+                // has allowed an instance to appear before the full declaration.
                 auto mutInst = ast::mutate( inst );
                 assert( mutInst->base->unique() );