Changes in src/ResolvExpr/AlternativeFinder.cc [a5f0529:b1bead1]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:52:08 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Jul 26 11:33:00 2017
-// Update Count     : 31
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 17 09:14:17 2017
+// Update Count     : 30
 //
 
@@ -67 +67 @@
 
         Cost sumCost( const AltList &in ) {
-                Cost total;
+                Cost total = Cost::zero;
                 for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
                         total += i->cost;
@@ -144 +144 @@
                         expr->get_result()->accept( global_renamer );
                 }
-        }
+
+                void referenceToRvalueConversion( Expression *& expr ) {
+                        if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                                // cast away reference from expr
+                                expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                        }
+                }
+        } // namespace
 
         template< typename InputIterator, typename OutputIterator >
@@ -213 +220 @@
         void AlternativeFinder::addAnonConversions( const Alternative & alt ) {
                 // adds anonymous member interpretations whenever an aggregate value type is seen.
-                Expression * expr = alt.expr->clone();
-                std::unique_ptr< Expression > manager( expr ); // RAII for expr
-                alt.env.apply( expr->get_result() );
-                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( expr->get_result() ) ) {
+                // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
+                std::unique_ptr<Expression> aggrExpr( alt.expr->clone() );
+                alt.env.apply( aggrExpr->get_result() );
+                Type * aggrType = aggrExpr->get_result();
+                if ( dynamic_cast< ReferenceType * >( aggrType ) ) {
+                        aggrType = aggrType->stripReferences();
+                        aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
+                }
+
+                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
                         NameExpr nameExpr( "" );
-                        addAggMembers( structInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr );
-                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( expr->get_result() ) ) {
+                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
+                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
                         NameExpr nameExpr( "" );
-                        addAggMembers( unionInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr );
+                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
                 } // if
         }
@@ -277 +290 @@
                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
 
-                Cost convCost( 0, 0, 0 );
+                Cost convCost = Cost::zero;
                 std::list< DeclarationWithType* >& formals = function->get_parameters();
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
@@ -290 +303 @@
                                 actualType->print( std::cerr, 8 );
                         )
-                        Cost actualCost;
+                        Cost actualCost = Cost::zero;
                         if ( formal == formals.end() ) {
                                 if ( function->get_isVarArgs() ) {
-                                        convCost += Cost( 1, 0, 0 );
+                                        convCost.incUnsafe();
+                                        // convert reference-typed expressions to value-typed expressions
+                                        referenceToRvalueConversion( *actualExpr );
                                         continue;
                                 } else {
@@ -305 +320 @@
                                 std::cerr << std::endl << " to ";
                                 formalType->print( std::cerr, 8 );
+                                std::cerr << std::endl << "environment is: ";
+                                alt.env.print( std::cerr, 8 );
+                                std::cerr << std::endl;
                         )
                         Cost newCost = conversionCost( actualType, formalType, indexer, alt.env );
@@ -316 +334 @@
                         convCost += newCost;
                         actualCost += newCost;
-                        if ( actualCost != Cost( 0, 0, 0 ) ) {
+                        if ( actualCost != Cost::zero ) {
                                 Type *newType = formalType->clone();
                                 alt.env.apply( newType );
                                 *actualExpr = new CastExpr( *actualExpr, newType );
                         }
-                        convCost += Cost( 0, polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ), 0 );
+                        convCost.incPoly( polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ) );
                         ++formal; // can't be in for-loop update because of the continue
                 }
@@ -343 +361 @@
                         }
                         convCost += newCost;
-                        convCost += Cost( 0, polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ), 0 );
+                        convCost.incPoly( polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ) );
                 }
 
@@ -400 +418 @@
                         Expression * actual = actualIt->expr;
                         Type * actualType = actual->get_result();
+
                         PRINT(
                                 std::cerr << "formal type is ";
@@ -408 +427 @@
                         )
                         if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                // std::cerr << "unify failed" << std::endl;
                                 return false;
                         }
@@ -452 +472 @@
                         // match flattened actuals with formal parameters - actuals will be grouped to match
                         // with formals as appropriate
-                        Cost cost;
+                        Cost cost = Cost::zero;
                         std::list< Expression * > newExprs;
                         ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
@@ -643 +663 @@
                         makeExprList( instantiatedActuals, appExpr->get_args() );
                         PRINT(
+                                std::cerr << "instantiate function success: " << appExpr << std::endl;
                                 std::cerr << "need assertions:" << std::endl;
                                 printAssertionSet( resultNeed, std::cerr, 8 );
@@ -663 +684 @@
                                 UntypedExpr *vexpr = untypedExpr->clone();
                                 vexpr->set_result( pt.clone() );
-                                alternatives.push_back( Alternative( vexpr, env, Cost()) );
+                                alternatives.push_back( Alternative( vexpr, env, Cost::zero) );
                                 return;
                         }
@@ -681 +702 @@
                 AltList candidates;
                 SemanticError errors;
-                for ( AltList::const_iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
+                for ( AltList::iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
                         try {
                                 PRINT(
@@ -688 +709 @@
                                 )
                                 // check if the type is pointer to function
-                                PointerType *pointer;
-                                if ( ( pointer = dynamic_cast< PointerType* >( func->expr->get_result() ) ) ) {
+                                if ( PointerType *pointer = dynamic_cast< PointerType* >( func->expr->get_result()->stripReferences() ) ) {
                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                                                referenceToRvalueConversion( func->expr );
                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
                                                         // XXX
@@ -696 +717 @@
                                                         makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
                                                 }
-                                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
-                                                EqvClass eqvClass;
-                                                if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
-                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
-                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
-                                                                        makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
-                                                                } // for
-                                                        } // if
+                                        }
+                                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->get_result()->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer)
+                                        referenceToRvalueConversion( func->expr );
+                                        EqvClass eqvClass;
+                                        if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
+                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
+                                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                        } // for
                                                 } // if
                                         } // if
@@ -722 +744 @@
                                         }
 
-                                        for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
+                                        for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
                                                 // check if the type is pointer to function
-                                                PointerType *pointer;
-                                                if ( ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result() ) ) ) {
+                                                if ( PointerType *pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result()->stripReferences() ) ) {
                                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                                                                referenceToRvalueConversion( funcOp->expr );
                                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
                                                                         AltList currentAlt;
@@ -753 +775 @@
                                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
                                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
-                                std::cerr << "Case +++++++++++++" << std::endl;
+                                std::cerr << "Case +++++++++++++ " << appExpr->get_function() << std::endl;
                                 std::cerr << "formals are:" << std::endl;
                                 printAll( function->get_parameters(), std::cerr, 8 );
@@ -796 +818 @@
         bool isLvalue( Expression *expr ) {
                 // xxx - recurse into tuples?
-                return expr->has_result() && expr->get_result()->get_lvalue();
+                return expr->has_result() && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
         }
 
@@ -810 +832 @@
 
         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 ( argExpr->get_result()->size() > 1 && ! toType->isVoid() && ! dynamic_cast<ReferenceType *>( toType ) ) {
+                        // Argument expression is a tuple and the target type is not void and not a reference type.
+                        // 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.
@@ -855 +878 @@
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
-                        int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
+                        int discardedValues = i->expr->get_result()->size() - castExpr->get_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(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
-                        Cost thisCost = castCost( (*i).expr->get_result(), castExpr->get_result(), indexer, i->env );
+                        unify( castExpr->get_result(), i->expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
+                        Cost thisCost = castCost( i->expr->get_result(), castExpr->get_result(), indexer, i->env );
                         if ( thisCost != Cost::infinity ) {
                                 // count one safe conversion for each value that is thrown away
-                                thisCost += Cost( 0, 0, discardedValues );
+                                thisCost.incSafe( discardedValues );
 
                                 candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
@@ -878 +901 @@
         }
 
-        void AlternativeFinder::visit( VirtualCastExpr * castExpr ) {
-                assertf( castExpr->get_result(), "Implicate virtual cast targets not yet supported." );
-                AlternativeFinder finder( indexer, env );
-                // don't prune here, since it's guaranteed all alternatives will have the same type
-                // (giving the alternatives different types is half of the point of ConstructorExpr nodes)
-                finder.findWithAdjustment( castExpr->get_arg(), false );
-                for ( Alternative & alt : finder.alternatives ) {
-                        alternatives.push_back( Alternative(
-                                new VirtualCastExpr( alt.expr->clone(), castExpr->get_result()->clone() ),
-                                alt.env, alt.cost ) );
-                }
-        }
-
         void AlternativeFinder::visit( UntypedMemberExpr *memberExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
                 funcFinder.findWithAdjustment( memberExpr->get_aggregate() );
                 for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
-                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
-                                addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
-                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) {
-                                addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
-                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( agg->expr->get_result() ) ) {
-                                addTupleMembers( tupleType, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
+                        std::unique_ptr<Expression> aggrExpr( agg->expr->clone() );
+                        Type * aggrType = aggrExpr->get_result();
+                        if ( dynamic_cast< ReferenceType * >( aggrType ) ) {
+                                aggrType = aggrType->stripReferences();
+                                aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
+                        }
+                        // find member of the given type
+                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
+                                addAggMembers( structInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
+                                addAggMembers( unionInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
+                                addTupleMembers( tupleType, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
                         } // if
                 } // for
@@ -915 +933 @@
                 for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
                         VariableExpr newExpr( *i, nameExpr->get_argName() );
-                        alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                        alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                         PRINT(
                                 std::cerr << "decl is ";
@@ -1059 +1077 @@
                         for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
                                 VariableExpr newExpr( *i );
-                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                                 renameTypes( alternatives.back().expr );
                         } // for
@@ -1232 +1250 @@
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away
-                                        thisCost += Cost( 0, 0, discardedValues );
+                                        thisCost.incSafe( discardedValues );
                                         candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
                                 }