Changes in src/ResolvExpr/AlternativeFinder.cc [322b97e:5ccb10d]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -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 >
@@ -186 +193 @@
                         if ( alternatives.begin() == oldBegin ) {
                                 std::ostringstream stream;
-                                stream << "Can't choose between " << alternatives.size() << " alternatives for expression ";
+                                AltList winners;
+                                findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
+                                stream << "Can't choose between " << winners.size() << " alternatives for expression ";
                                 expr->print( stream );
                                 stream << "Alternatives are:";
-                                AltList winners;
-                                findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
                                 printAlts( winners, stream, 8 );
                                 throw SemanticError( stream.str() );
@@ -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
         }
@@ -228 +241 @@
         void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
                 // by this point, member must be a name expr
-                NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member );
+                NameExpr * nameExpr = dynamic_cast< NameExpr * >( member );
+                if ( ! nameExpr ) return;
                 const std::string & name = nameExpr->get_name();
                 std::list< Declaration* > members;
@@ -250 +264 @@
                         // during parsing and reusing that information here.
                         std::stringstream ss( constantExpr->get_constant()->get_value() );
-                        int val;
+                        int val = 0;
                         std::string tmp;
                         if ( ss >> val && ! (ss >> tmp) ) {
@@ -277 +291 @@
                 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 +304 @@
                                 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 +321 @@
                                 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 +335 @@
                         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 +362 @@
                         }
                         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 +419 @@
                         Expression * actual = actualIt->expr;
                         Type * actualType = actual->get_result();
+
                         PRINT(
                                 std::cerr << "formal type is ";
@@ -408 +428 @@
                         )
                         if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                // std::cerr << "unify failed" << std::endl;
                                 return false;
                         }
@@ -452 +473 @@
                         // 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 );
@@ -613 +634 @@
                 AssertionSet newNeed;
                 //AssertionParentSet needParents;
+                PRINT(
+                        std::cerr << "env is: " << std::endl;
+                        newAlt.env.print( std::cerr, 0 );
+                        std::cerr << std::endl;
+                )
+
                 inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, /*needParents,*/ 0, indexer, out );
 //      PRINT(
@@ -643 +670 @@
                         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 +691 @@
                                 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 +709 @@
                 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 +716 @@
                                 )
                                 // 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 +724 @@
                                                         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 +751 @@
                                         }
 
-                                        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 +782 @@
                                 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 +825 @@
         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 +839 @@
 
         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 ) ) {
+                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::maybeImpureIgnoreUnique( argExpr ) ) {
                                 // expressions which may contain side effects require a single unique instance of the expression.
                                 argExpr = new UniqueExpr( argExpr );
@@ -855 +885 @@
                         // 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 ) );
@@ -895 +925 @@
                 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 +953 @@
                 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 ";
@@ -941 +979 @@
         void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) {
                 if ( sizeofExpr->get_isType() ) {
-                        Type * newType = sizeofExpr->get_type()->clone();
-                        alternatives.push_back( Alternative( new SizeofExpr( resolveTypeof( newType, indexer ) ), env, Cost::zero ) );
+                        // xxx - resolveTypeof?
+                        alternatives.push_back( Alternative( sizeofExpr->clone(), env, Cost::zero ) );
                 } else {
                         // find all alternatives for the argument to sizeof
@@ -955 +993 @@
                         // return the lowest cost alternative for the argument
                         Alternative &choice = winners.front();
+                        referenceToRvalueConversion( choice.expr );
                         alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
                 } // if
@@ -961 +1000 @@
         void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
                 if ( alignofExpr->get_isType() ) {
-                        Type * newType = alignofExpr->get_type()->clone();
-                        alternatives.push_back( Alternative( new AlignofExpr( resolveTypeof( newType, indexer ) ), env, Cost::zero ) );
+                        // xxx - resolveTypeof?
+                        alternatives.push_back( Alternative( alignofExpr->clone(), env, Cost::zero ) );
                 } else {
                         // find all alternatives for the argument to sizeof
@@ -975 +1014 @@
                         // return the lowest cost alternative for the argument
                         Alternative &choice = winners.front();
+                        referenceToRvalueConversion( choice.expr );
                         alternatives.push_back( Alternative( new AlignofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
                 } // if
@@ -1059 +1099 @@
                         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 +1272 @@
                                 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 ) );
                                 }