Changeset 30b65d8 for src/ResolvExpr/Resolver.cc

Timestamp:

Nov 10, 2016, 4:16:32 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

8f9cc50

Parents:

b726084

Message:

always construct polymorphic types, substitute generic type parameters when resolving initializers

File:

• src/ResolvExpr/Resolver.cc (modified) (5 diffs)

src/ResolvExpr/Resolver.cc

@@ -66 +66 @@
                 void handlePtrType( PtrType * type );
 
-          void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & );
-          void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
+          void resolveAggrInit( ReferenceToType *, InitIterator &, InitIterator & );
+          void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator &, TypeSubstitution sub );
           void fallbackInit( ConstructorInit * ctorInit );
 
@@ -397 +397 @@
         }
 
-        void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd ) {
+        template< typename AggrInst >
+        TypeSubstitution makeGenericSubstitutuion( AggrInst * inst ) {
+                std::list< TypeDecl * > baseParams = *inst->get_baseParameters();
+                std::list< Expression * > typeSubs = inst->get_parameters();
+                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
+                return subs;
+        }
+
+        ReferenceToType * isStructOrUnion( Type * type ) {
+                if ( StructInstType * sit = dynamic_cast< StructInstType * >( type ) ) {
+                        return sit;
+                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( type ) ) {
+                        return uit;
+                }
+                return nullptr;
+        }
+
+        void Resolver::resolveSingleAggrInit( Declaration * dcl, InitIterator & init, InitIterator & initEnd, TypeSubstitution sub ) {
                 DeclarationWithType * dt = dynamic_cast< DeclarationWithType * >( dcl );
                 assert( dt );
-                initContext = dt->get_type();
+                // need to substitute for generic types, so that casts are to concrete types
+                initContext = dt->get_type()->clone();
+                sub.apply( initContext );
+
                 try {
                         if ( init == initEnd ) return; // stop when there are no more initializers
@@ -407 +427 @@
                 } catch( SemanticError & ) {
                         // need to delve deeper, if you can
-                        if ( StructInstType * sit = dynamic_cast< StructInstType * >( dt->get_type() ) ) {
-                                resolveAggrInit( sit->get_baseStruct(), init, initEnd );
-                        } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( dt->get_type() ) ) {
-                                resolveAggrInit( uit->get_baseUnion(), init, initEnd );
+                        if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
+                                resolveAggrInit( type, init, initEnd );
                         } else {
                                 // member is not an aggregate type, so can't go any deeper
@@ -420 +438 @@
         }
 
-        void Resolver::resolveAggrInit( AggregateDecl * aggr, InitIterator & init, InitIterator & initEnd ) {
-                if ( StructDecl * st = dynamic_cast< StructDecl * >( aggr ) ) {
+        void Resolver::resolveAggrInit( ReferenceToType * inst, InitIterator & init, InitIterator & initEnd ) {
+
+                if ( StructInstType * sit = dynamic_cast< StructInstType * >( inst ) ) {
+                        TypeSubstitution sub = makeGenericSubstitutuion( sit );
+                        StructDecl * st = sit->get_baseStruct();
                         // want to resolve each initializer to the members of the struct,
                         // but if there are more initializers than members we should stop
                         list< Declaration * >::iterator it = st->get_members().begin();
                         for ( ; it != st->get_members().end(); ++it) {
-                                resolveSingleAggrInit( *it, init, initEnd );
+                                resolveSingleAggrInit( *it, init, initEnd, sub );
                         }
-                } else if ( UnionDecl * un = dynamic_cast< UnionDecl * >( aggr ) ) {
+                } else if ( UnionInstType * uit = dynamic_cast< UnionInstType * >( inst ) ) {
+                        TypeSubstitution sub = makeGenericSubstitutuion( sit );
+                        UnionDecl * un = uit->get_baseUnion();
                         // only resolve to the first member of a union
-                        resolveSingleAggrInit( *un->get_members().begin(), init, initEnd );
+                        resolveSingleAggrInit( *un->get_members().begin(), init, initEnd, sub );
                 } // if
         }
@@ -450 +473 @@
                                 (*iter++)->accept( *this );
                         }
-                } else if ( StructInstType * st = dynamic_cast< StructInstType * >( initContext ) ) {
-                        resolveAggrInit( st->get_baseStruct(), iter, end );
-                } else if ( UnionInstType * st = dynamic_cast< UnionInstType * >( initContext ) ) {
-                        resolveAggrInit( st->get_baseUnion(), iter, end );
+                } else if ( ReferenceToType * type = isStructOrUnion( initContext ) ) {
+                        resolveAggrInit( type, iter, end );
                 } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
                         Type * base = tt->get_baseType()->get_base();