Changeset eba74ba for src/ResolvExpr/AlternativeFinder.cc

Timestamp:

May 25, 2018, 2:51:06 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

cdc4d43

Parents:

3ef35bd (diff), 58e822a (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 remote-tracking branch 'origin/master' into with_gc

File:

• src/ResolvExpr/AlternativeFinder.cc (modified) (11 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -689 +689 @@
                         const ExplodedArgs& args, std::vector<ArgPack>& results, std::size_t& genStart,
                         const SymTab::Indexer& indexer, unsigned nTuples = 0 ) {
-                if ( TupleType* tupleType = dynamic_cast<TupleType*>( formalType ) ) {
+                if ( TupleType * tupleType = dynamic_cast<TupleType*>( formalType ) ) {
                         // formalType is a TupleType - group actuals into a TupleExpr
                         ++nTuples;
                         for ( Type* type : *tupleType ) {
                                 // xxx - dropping initializer changes behaviour from previous, but seems correct
+                                // ^^^ need to handle the case where a tuple has a default argument
                                 if ( ! instantiateArgument(
                                                 type, nullptr, args, results, genStart, indexer, nTuples ) )
@@ -704 +705 @@
                         }
                         return true;
-                } else if ( TypeInstType* ttype = Tuples::isTtype( formalType ) ) {
+                } else if ( TypeInstType * ttype = Tuples::isTtype( formalType ) ) {
                         // formalType is a ttype, consumes all remaining arguments
                         // xxx - mixing default arguments with variadic??
@@ -907 +908 @@
                                 // consider only first exploded actual
                                 Expression* expr = expl.exprs.front();
-                                Type* actualType = expr->get_result()->clone();
+                                Type* actualType = expr->result->clone();
 
                                 PRINT(
@@ -938 +939 @@
                 ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
                 // sum cost and accumulate actuals
-                std::list<Expression*>& args = appExpr->get_args();
+                std::list<Expression*>& args = appExpr->args;
                 Cost cost = func.cost;
                 const ArgPack* pack = &result;
@@ -965 +966 @@
                 // add all type variables as open variables now so that those not used in the parameter
                 // list are still considered open.
-                funcEnv.add( funcType->get_forall() );
-
-                if ( targetType && ! targetType->isVoid() && ! funcType->get_returnVals().empty() ) {
+                funcEnv.add( funcType->forall );
+
+                if ( targetType && ! targetType->isVoid() && ! funcType->returnVals.empty() ) {
                         // attempt to narrow based on expected target type
-                        Type * returnType = funcType->get_returnVals().front()->get_type();
+                        Type * returnType = funcType->returnVals.front()->get_type();
                         if ( ! unify( returnType, targetType, funcEnv, funcNeed, funcHave, funcOpenVars,
                                         indexer ) ) {
@@ -982 +983 @@
                 std::size_t genStart = 0;
 
-                for ( DeclarationWithType* formal : funcType->get_parameters() ) {
+                for ( DeclarationWithType* formal : funcType->parameters ) {
                         ObjectDecl* obj = strict_dynamic_cast< ObjectDecl* >( formal );
                         if ( ! instantiateArgument(
-                                        obj->get_type(), obj->get_init(), args, results, genStart, indexer ) )
+                                        obj->type, obj->init, args, results, genStart, indexer ) )
                                 return;
                 }
@@ -1066 +1067 @@
         void AlternativeFinder::Finder::postvisit( UntypedExpr *untypedExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
-                funcFinder.findWithAdjustment( untypedExpr->get_function() );
+                funcFinder.findWithAdjustment( untypedExpr->function );
                 // if there are no function alternatives, then proceeding is a waste of time.
                 if ( funcFinder.alternatives.empty() ) return;
@@ -1275 +1276 @@
                 AlternativeFinder finder( indexer, env );
                 finder.targetType = toType;
-                finder.findWithAdjustment( castExpr->get_arg() );
+                finder.findWithAdjustment( castExpr->arg );
 
                 AltList candidates;
@@ -1282 +1283 @@
                         OpenVarSet openVars;
 
+                        alt.env.extractOpenVars( openVars );
+
                         // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
                         // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
-                        int discardedValues = alt.expr->get_result()->size() - castExpr->get_result()->size();
+                        int discardedValues = alt.expr->result->size() - castExpr->result->size();
                         if ( discardedValues < 0 ) continue;
                         // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
                         // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
                         // unification run for side-effects
-                        unify( castExpr->get_result(), alt.expr->get_result(), alt.env, needAssertions,
+                        unify( castExpr->result, alt.expr->result, alt.env, needAssertions,
                                 haveAssertions, openVars, indexer );
-                        Cost thisCost = castCost( alt.expr->get_result(), castExpr->get_result(), indexer,
+                        Cost thisCost = castCost( alt.expr->result, castExpr->result, indexer,
                                 alt.env );
                         PRINT(
@@ -1706 +1709 @@
                         AlternativeFinder finder( indexer, env );
                         finder.targetType = toType;
-                        finder.findWithAdjustment( initExpr->get_expr() );
+                        finder.findWithAdjustment( initExpr->expr );
                         for ( Alternative & alt : finder.get_alternatives() ) {
                                 TypeEnvironment newEnv( alt.env );
@@ -1713 +1716 @@
                                 PRINT(
                                         std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl;
-                                 )
+                                )
                                 // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
                                 // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
                                 // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                                 // to.
-                                int discardedValues = alt.expr->get_result()->size() - toType->size();
+                                int discardedValues = alt.expr->result->size() - toType->size();
                                 if ( discardedValues < 0 ) continue;
                                 // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
                                 // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
                                 // unification run for side-effects
-                                unify( toType, alt.expr->get_result(), newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
-
-                                Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv );
+                                unify( toType, alt.expr->result, newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
+
+                                Cost thisCost = castCost( alt.expr->result, toType, indexer, newEnv );
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away