Changes in src/ResolvExpr/AlternativeFinder.cc [62423350:d7dc824]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -604 +604 @@
 //          )
                 SymTab::Indexer decls( indexer );
-                // PRINT(
-                //      std::cerr << "============= original indexer" << std::endl;
-                //      indexer.print( std::cerr );
-                //      std::cerr << "============= new indexer" << std::endl;
-                //      decls.print( std::cerr );
-                // )
+                PRINT(
+                        std::cerr << "============= original indexer" << std::endl;
+                        indexer.print( std::cerr );
+                        std::cerr << "============= new indexer" << std::endl;
+                        decls.print( std::cerr );
+                )
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
@@ -809 +809 @@
         }
 
-        Expression * restructureCast( Expression * argExpr, Type * toType ) {
-                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) {
-                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
-                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
-                        // more components of the tuple than components in the target type, then excess components do not
-                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
-                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
-                                // expressions which may contain side effects require a single unique instance of the expression.
-                                argExpr = new UniqueExpr( argExpr );
-                        }
-                        std::list< Expression * > componentExprs;
-                        for ( unsigned int i = 0; i < toType->size(); i++ ) {
-                                // cast each component
-                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
-                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
-                        }
-                        delete argExpr;
-                        assert( componentExprs.size() > 0 );
-                        // produce the tuple of casts
-                        return new TupleExpr( componentExprs );
-                } else {
-                        // handle normally
-                        return new CastExpr( argExpr, toType->clone() );
-                }
-        }
-
         void AlternativeFinder::visit( CastExpr *castExpr ) {
                 Type *& toType = castExpr->get_result();
@@ -866 +840 @@
                                 thisCost += Cost( 0, 0, discardedValues );
 
-                                candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
+                                Expression * argExpr = i->expr->clone();
+                                if ( argExpr->get_result()->size() > 1 && ! castExpr->get_result()->isVoid() ) {
+                                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
+                                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
+                                        // more components of the tuple than components in the target type, then excess components do not
+                                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
+                                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
+                                                // expressions which may contain side effects require a single unique instance of the expression.
+                                                argExpr = new UniqueExpr( argExpr );
+                                        }
+                                        std::list< Expression * > componentExprs;
+                                        for ( unsigned int i = 0; i < castExpr->get_result()->size(); i++ ) {
+                                                // cast each component
+                                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
+                                                componentExprs.push_back( new CastExpr( idx, castExpr->get_result()->getComponent( i )->clone() ) );
+                                        }
+                                        delete argExpr;
+                                        assert( componentExprs.size() > 0 );
+                                        // produce the tuple of casts
+                                        candidates.push_back( Alternative( new TupleExpr( componentExprs ), i->env, i->cost, thisCost ) );
+                                } else {
+                                        // handle normally
+                                        candidates.push_back( Alternative( new CastExpr( argExpr->clone(), toType->clone() ), i->env, i->cost, thisCost ) );
+                                }
                         } // if
                 } // for
@@ -1185 +1182 @@
         }
 
-        void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
-                // handle each option like a cast
-                AltList candidates;
-                PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; )
-                // O(N^2) checks of d-types with e-types
-                for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
-                        Type * toType = resolveTypeof( initAlt.type, indexer );
-                        SymTab::validateType( toType, &indexer );
-                        adjustExprType( toType, env, indexer );
-                        // Ideally the call to findWithAdjustment could be moved out of the loop, but unfortunately it currently has to occur inside or else
-                        // polymorphic return types are not properly bound to the initialization type, since return type variables are only open for the duration of resolving
-                        // the UntypedExpr. This is only actually an issue in initialization contexts that allow more than one possible initialization type, but it is still suboptimal.
-                        AlternativeFinder finder( indexer, env );
-                        finder.targetType = toType;
-                        finder.findWithAdjustment( initExpr->get_expr() );
-                        for ( Alternative & alt : finder.get_alternatives() ) {
-                                TypeEnvironment newEnv( alt.env );
-                                AssertionSet needAssertions, haveAssertions;
-                                OpenVarSet openVars;  // find things in env that don't have a "representative type" and claim those are open vars?
-                                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();
-                                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 );
-                                if ( thisCost != Cost::infinity ) {
-                                        // count one safe conversion for each value that is thrown away
-                                        thisCost += Cost( 0, 0, discardedValues );
-                                        candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
-                                }
-                        }
-                }
-
-                // findMinCost selects the alternatives with the lowest "cost" members, but has the side effect of copying the
-                // cvtCost member to the cost member (since the old cost is now irrelevant).  Thus, calling findMinCost twice
-                // selects first based on argument cost, then on conversion cost.
-                AltList minArgCost;
-                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( minArgCost ) );
-                findMinCost( minArgCost.begin(), minArgCost.end(), std::back_inserter( alternatives ) );
-        }
 } // namespace ResolvExpr