Changes in / [5a806be4:4ada74e]

Location:

src

Files:

• ResolvExpr/AlternativeFinder.cc (modified) (12 diffs)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (1 diff)
• SymTab/Indexer.cc (modified) (2 diffs)
• SymTab/Indexer.h (modified) (2 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

src/ResolvExpr/Resolver.cc

@@ -526 +526 @@
                                         Alternative newFunc( func );
                                         // Strip reference from function
-                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
+                                        referenceToRvalueConversion( newFunc.expr );
 
                                         // For all the set of arguments we have try to match it with the parameter of the current function alternative

src/ResolvExpr/typeops.h

@@ -106 +106 @@
 
         // in AlternativeFinder.cc
-        void referenceToRvalueConversion( Expression *& expr, Cost & cost );
+        void referenceToRvalueConversion( Expression *& expr );
 
         // flatten tuple type into list of types

src/SymTab/Indexer.cc

@@ -603 +603 @@
                                         if ( dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t ) ) {
                                                 Expression * base = expr->clone();
-                                                ResolvExpr::Cost cost = ResolvExpr::Cost::zero; // xxx - carry this cost into the indexer as a base cost?
-                                                ResolvExpr::referenceToRvalueConversion( base, cost );
+                                                ResolvExpr::referenceToRvalueConversion( base );
                                                 addMembers( t->getAggr(), new MemberExpr( dwt, base ), handleConflicts );
                                         }
@@ -706 +705 @@
         }
 
-        Expression * Indexer::IdData::combine( ResolvExpr::Cost & cost ) const {
+        Expression * Indexer::IdData::combine() const {
                 Expression * ret = nullptr;
                 if ( baseExpr ) {
                         Expression * base = baseExpr->clone();
-                        ResolvExpr::referenceToRvalueConversion( base, cost );
+                        ResolvExpr::referenceToRvalueConversion( base );
                         ret = new MemberExpr( id, base );
                         // xxx - this introduces hidden environments, for now remove them.

src/SymTab/Indexer.h

@@ -23 +23 @@
 #include "SynTree/Visitor.h"  // for Visitor
 #include "SynTree/SynTree.h"  // for AST nodes
-
-namespace ResolvExpr {
-class Cost;
-}
 
 namespace SymTab {
@@ -55 +51 @@
                         IdData( DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt ) : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ) {}
 
-                        Expression * combine( ResolvExpr::Cost & cost ) const;
+                        Expression * combine() const;
                 };