Changes in src/ResolvExpr/AlternativeFinder.cc [a181494:93401f8]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -204 +204 @@
         } // namespace
 
-        void referenceToRvalueConversion( Expression *& expr, Cost & cost ) {
+        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() );
-                        cost.incReference();
                 }
         }
@@ -436 +435 @@
                                         PRINT( std::cerr << "end of formals with varargs function: inc unsafe: " << convCost << std::endl; ; )
                                         // convert reference-typed expressions to value-typed expressions
-                                        referenceToRvalueConversion( *actualExpr, convCost );
+                                        referenceToRvalueConversion( *actualExpr );
                                         continue;
                                 } else {
@@ -566 +565 @@
                                 // DOESN'T WORK: grandchild nodes conflict with their cousins
                                 //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
-
-                                Expression *varExpr = data.combine( newerAlt.cost );
+                                Expression *varExpr = data.combine();
                                 delete varExpr->get_result();
                                 varExpr->set_result( adjType->clone() );
@@ -1123 +1121 @@
                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
                                                 Alternative newFunc( *func );
-                                                referenceToRvalueConversion( newFunc.expr, newFunc.cost );
+                                                referenceToRvalueConversion( newFunc.expr );
                                                 makeFunctionAlternatives( newFunc, function, argExpansions,
                                                         std::back_inserter( candidates ) );
@@ -1132 +1130 @@
                                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
                                                         Alternative newFunc( *func );
-                                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
+                                                        referenceToRvalueConversion( newFunc.expr );
                                                         makeFunctionAlternatives( newFunc, function, argExpansions,
                                                                 std::back_inserter( candidates ) );
@@ -1162 +1160 @@
                                                                 dynamic_cast<FunctionType*>( pointer->get_base() ) ) {
                                                         Alternative newFunc( *funcOp );
-                                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
+                                                        referenceToRvalueConversion( newFunc.expr );
                                                         makeFunctionAlternatives( newFunc, function, argExpansions,
                                                                 std::back_inserter( candidates ) );
@@ -1346 +1344 @@
                 for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
                         // 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
-                        Cost cost = agg->cost;
-                        Expression * aggrExpr = agg->expr->clone();
-                        referenceToRvalueConversion( aggrExpr, cost );
-                        std::unique_ptr<Expression> guard( aggrExpr );
-
+                        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, cost, agg->env, memberExpr->get_member() );
+                                addAggMembers( structInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
-                                addAggMembers( unionInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
+                                addAggMembers( unionInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
                         } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
-                                addTupleMembers( tupleType, aggrExpr, cost, agg->env, memberExpr->get_member() );
+                                addTupleMembers( tupleType, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
                         } // if
                 } // for
@@ -1371 +1370 @@
                 PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; )
                 for ( auto & data : declList ) {
-                        Cost cost = Cost::zero;
-                        Expression * newExpr = data.combine( cost );
-                        alternatives.push_back( Alternative( newExpr, env, Cost::zero ) ); // xxx
+                        Expression * newExpr = data.combine();
+                        // xxx - add in extra cost for with-statement exprs?
+                        alternatives.push_back( Alternative( newExpr, env, Cost::zero ) );
                         PRINT(
                                 std::cerr << "decl is ";
@@ -1413 +1412 @@
                         // return the lowest cost alternative for the argument
                         Alternative &choice = winners.front();
-                        referenceToRvalueConversion( choice.expr, choice.cost );
+                        referenceToRvalueConversion( choice.expr );
                         alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
                 } // if
@@ -1434 +1433 @@
                         // return the lowest cost alternative for the argument
                         Alternative &choice = winners.front();
-                        referenceToRvalueConversion( choice.expr, choice.cost );
+                        referenceToRvalueConversion( choice.expr );
                         alternatives.push_back( Alternative( new AlignofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
                 } // if
@@ -1486 +1485 @@
                         AltList & alternatives = finder.get_alternatives();
                         if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
-                                Cost cost = Cost::zero;
-                                Expression * newExpr = data.combine( cost );
-                                alternatives.push_back( Alternative( new AttrExpr( newExpr, argType->clone() ), env, cost ) );
+                                alternatives.push_back( Alternative( new AttrExpr( data.combine(), argType->clone() ), env, Cost::zero ) );
                                 for ( DeclarationWithType * retVal : function->returnVals ) {
                                         alternatives.back().expr->result = retVal->get_type()->clone();
@@ -1525 +1522 @@
                 } else {
                         for ( auto & data : attrList ) {
-                                Cost cost = Cost::zero;
-                                Expression * newExpr = data.combine( cost );
-                                alternatives.push_back( Alternative( newExpr, env, cost ) );
+                                alternatives.push_back( Alternative( data.combine(), env, Cost::zero ) );
                                 renameTypes( alternatives.back().expr );
                         } // for