Changeset 907eccb for src/ResolvExpr

Timestamp:

Dec 22, 2016, 3:23:49 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:

4c8621ac

Parents:

0c286cf

Message:

added UntypedTupleExpr? to better differentiate typed and untyped contexts, simplifying some code

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (3 diffs)
• AlternativeFinder.h (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -351 +351 @@
                 if ( TupleType * tupleType = dynamic_cast< TupleType * >( formalType ) ) {
                         // formalType is a TupleType - group actuals into a TupleExpr whose type unifies with the TupleType
-                        TupleExpr * tupleExpr = new TupleExpr();
+                        std::list< Expression * > exprs;
                         for ( Type * type : *tupleType ) {
-                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( tupleExpr->get_exprs() ) ) ) {
-                                        delete tupleExpr;
+                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( exprs ) ) ) {
+                                        deleteAll( exprs );
                                         return false;
                                 }
                         }
-                        tupleExpr->set_result( Tuples::makeTupleType( tupleExpr->get_exprs() ) );
-                        *out++ = tupleExpr;
+                        *out++ = new TupleExpr( exprs );
                 } else if ( actualIt != actualEnd ) {
                         if ( TypeInstType * ttype = Tuples::isTtype( formalType ) ) {
@@ -1058 +1057 @@
         }
 
-        void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
+        void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
                 std::list< AlternativeFinder > subExprAlternatives;
                 findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) );
@@ -1064 +1063 @@
                 combos( subExprAlternatives.begin(), subExprAlternatives.end(), back_inserter( possibilities ) );
                 for ( std::list< AltList >::const_iterator i = possibilities.begin(); i != possibilities.end(); ++i ) {
-                        TupleExpr *newExpr = new TupleExpr;
-                        makeExprList( *i, newExpr->get_exprs() );
-                        newExpr->set_result( Tuples::makeTupleType( newExpr->get_exprs() ) );
+                        std::list< Expression * > exprs;
+                        makeExprList( *i, exprs );
 
                         TypeEnvironment compositeEnv;
                         simpleCombineEnvironments( i->begin(), i->end(), compositeEnv );
-                        alternatives.push_back( Alternative( newExpr, compositeEnv, sumCost( *i ) ) );
+                        alternatives.push_back( Alternative( new TupleExpr( exprs ) , compositeEnv, sumCost( *i ) ) );
                 } // for
+        }
+
+        void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
+                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
         }
 

src/ResolvExpr/AlternativeFinder.h

@@ -64 +64 @@
                 virtual void visit( ConditionalExpr *conditionalExpr );
                 virtual void visit( CommaExpr *commaExpr );
-                virtual void visit( TupleExpr *tupleExpr );
                 virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
                 virtual void visit( ConstructorExpr * ctorExpr );
+                virtual void visit( UntypedTupleExpr *tupleExpr );
+                virtual void visit( TupleExpr *tupleExpr );
                 virtual void visit( TupleIndexExpr *tupleExpr );
                 virtual void visit( TupleAssignExpr *tupleExpr );