Changeset caa649b for src/ResolvExpr

Timestamp:

Mar 6, 2018, 12:11:11 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

520145b, e5d4e5c, e6c5e79

Parents:

094476d (diff), 1feb535f (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:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/ResolvExpr

Files:

• Resolver.cc (modified) (2 diffs)
• TypeEnvironment.cc (modified) (1 diff)
• TypeEnvironment.h (modified) (1 diff)

src/ResolvExpr/Resolver.cc

@@ -788 +788 @@
                 stmtExpr->accept( resolver );
                 stmtExpr->computeResult();
+                // xxx - aggregate the environments from all statements? Possibly in AlternativeFinder instead?
         }
 
@@ -793 +794 @@
                 visit_children = false;
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
-                maybeAccept( ctorInit->get_ctor(), *visitor );
-                maybeAccept( ctorInit->get_dtor(), *visitor );
+                maybeAccept( ctorInit->ctor, *visitor );
+                maybeAccept( ctorInit->dtor, *visitor );
 
                 // found a constructor - can get rid of C-style initializer
-                delete ctorInit->get_init();
-                ctorInit->set_init( NULL );
+                delete ctorInit->init;
+                ctorInit->init = nullptr;
 
                 // intrinsic single parameter constructors and destructors do nothing. Since this was
                 // implicitly generated, there's no way for it to have side effects, so get rid of it
                 // to clean up generated code.
-                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
-                        delete ctorInit->get_ctor();
-                        ctorInit->set_ctor( NULL );
-                }
-
-                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
-                        delete ctorInit->get_dtor();
-                        ctorInit->set_dtor( NULL );
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
+                        delete ctorInit->ctor;
+                        ctorInit->ctor = nullptr;
+                }
+
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
+                        delete ctorInit->dtor;
+                        ctorInit->dtor = nullptr;
                 }
 

src/ResolvExpr/TypeEnvironment.cc

@@ -118 +118 @@
                         env.push_back( newClass );
                 } // for
+        }
+
+        void TypeEnvironment::add( const TypeSubstitution & sub ) {
+                EqvClass newClass;
+                for ( auto p : sub ) {
+                        newClass.vars.insert( p.first );
+                        newClass.type = p.second->clone();
+                        newClass.allowWidening = false;
+                        // Minimal assumptions. Not technically correct, but might be good enough, and
+                        // is the best we can do at the moment since information is lost in the
+                        // transition to TypeSubstitution
+                        newClass.data = TypeDecl::Data{ TypeDecl::Dtype, false };
+                        add( newClass );
+                }
         }
 

src/ResolvExpr/TypeEnvironment.h

@@ -76 +76 @@
                 void add( const EqvClass &eqvClass );
                 void add( const Type::ForallList &tyDecls );
+                void add( const TypeSubstitution & sub );
                 template< typename SynTreeClass > int apply( SynTreeClass *&type ) const;
                 template< typename SynTreeClass > int applyFree( SynTreeClass *&type ) const;