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

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -14 +14 @@
 //
 
-#include <algorithm>               // for copy
-#include <cassert>                 // for safe_dynamic_cast, assert, assertf
-#include <iostream>                // for operator<<, cerr, ostream, endl
-#include <iterator>                // for back_insert_iterator, back_inserter
-#include <list>                    // for _List_iterator, list, _List_const_...
-#include <map>                     // for _Rb_tree_iterator, map, _Rb_tree_c...
-#include <memory>                  // for allocator_traits<>::value_type
-#include <utility>                 // for pair
-
-#include "Alternative.h"           // for AltList, Alternative
+#include <list>
+#include <iterator>
+#include <algorithm>
+#include <functional>
+#include <cassert>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
 #include "AlternativeFinder.h"
-#include "Common/SemanticError.h"  // for SemanticError
-#include "Common/utility.h"        // for deleteAll, printAll, CodeLocation
-#include "Cost.h"                  // for Cost, Cost::zero, operator<<, Cost...
-#include "InitTweak/InitTweak.h"   // for getFunctionName
-#include "RenameVars.h"            // for RenameVars, global_renamer
-#include "ResolveTypeof.h"         // for resolveTypeof
-#include "Resolver.h"              // for resolveStmtExpr
-#include "SymTab/Indexer.h"        // for Indexer
-#include "SymTab/Mangler.h"        // for Mangler
-#include "SymTab/Validate.h"       // for validateType
-#include "SynTree/Constant.h"      // for Constant
-#include "SynTree/Declaration.h"   // for DeclarationWithType, TypeDecl, Dec...
-#include "SynTree/Expression.h"    // for Expression, CastExpr, NameExpr
-#include "SynTree/Initializer.h"   // for SingleInit, operator<<, Designation
-#include "SynTree/SynTree.h"       // for UniqueId
-#include "SynTree/Type.h"          // for Type, FunctionType, PointerType
-#include "Tuples/Explode.h"        // for explode
-#include "Tuples/Tuples.h"         // for isTtype, handleTupleAssignment
-#include "Unify.h"                 // for unify
-#include "typeops.h"               // for adjustExprType, polyCost, castCost
+#include "Alternative.h"
+#include "Cost.h"
+#include "typeops.h"
+#include "Unify.h"
+#include "RenameVars.h"
+#include "SynTree/Type.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Initializer.h"
+#include "SynTree/Visitor.h"
+#include "SymTab/Indexer.h"
+#include "SymTab/Mangler.h"
+#include "SynTree/TypeSubstitution.h"
+#include "SymTab/Validate.h"
+#include "Tuples/Tuples.h"
+#include "Tuples/Explode.h"
+#include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
+#include "InitTweak/GenInit.h"
+#include "ResolveTypeof.h"
+#include "Resolver.h"
 
 extern bool resolvep;
@@ -286 +286 @@
         }
 
-        Cost computeConversionCost( Type * actualType, Type * formalType, const SymTab::Indexer &indexer, const TypeEnvironment & env ) {
-                PRINT(
-                        std::cerr << std::endl << "converting ";
-                        actualType->print( std::cerr, 8 );
-                        std::cerr << std::endl << " to ";
-                        formalType->print( std::cerr, 8 );
-                        std::cerr << std::endl << "environment is: ";
-                        env.print( std::cerr, 8 );
-                        std::cerr << std::endl;
-                )
-                Cost convCost = conversionCost( actualType, formalType, indexer, env );
-                PRINT(
-                        std::cerr << std::endl << "cost is" << convCost << std::endl;
-                )
-                if ( convCost == Cost::infinity ) {
-                        return convCost;
-                }
-                convCost.incPoly( polyCost( formalType, env, indexer ) + polyCost( actualType, env, indexer ) );
-                return convCost;
-        }
-
-        Cost computeExpressionConversionCost( Expression *& actualExpr, Type * formalType, const SymTab::Indexer &indexer, const TypeEnvironment & env ) {
-                Cost convCost = computeConversionCost( actualExpr->result, formalType, indexer, env );
-                // if ( convCost != Cost::zero ) {
-
-                // xxx - temporary -- ignore poly cost, since this causes some polymorphic functions to be cast, which causes the specialize
-                // pass to try to specialize them, which currently does not work. Once that is fixed, remove the next 3 lines and uncomment the
-                // previous line.
-                Cost tmpCost = convCost;
-                tmpCost.incPoly( -tmpCost.get_polyCost() );
-                if ( tmpCost != Cost::zero ) {
-                        Type *newType = formalType->clone();
-                        env.apply( newType );
-                        actualExpr = new CastExpr( actualExpr, newType );
-                        // xxx - SHOULD be able to resolve this cast, but at the moment pointers are not castable to zero_t, but are implicitly convertible. This is clearly
-                        // inconsistent, once this is fixed it should be possible to resolve the cast.
-                        // xxx - this isn't working, it appears because type1 (the formal type) is seen as widenable, but it shouldn't be, because this makes the conversion from DT* to DT* since commontype(zero_t, DT*) is DT*, rather than just nothing.
-
-                        // AlternativeFinder finder( indexer, env );
-                        // finder.findWithAdjustment( actualExpr );
-                        // assertf( finder.get_alternatives().size() > 0, "Somehow castable expression failed to find alternatives." );
-                        // assertf( finder.get_alternatives().size() == 1, "Somehow got multiple alternatives for known cast expression." );
-                        // Alternative & alt = finder.get_alternatives().front();
-                        // delete actualExpr;
-                        // actualExpr = alt.expr->clone();
-                }
-                return convCost;
-        }
-
-        Cost computeApplicationConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
+        Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
                 ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
@@ -353 +304 @@
                                 actualType->print( std::cerr, 8 );
                         )
+                        Cost actualCost = Cost::zero;
                         if ( formal == formals.end() ) {
                                 if ( function->get_isVarArgs() ) {
@@ -373 +325 @@
                                 std::cerr << std::endl;
                         )
-                        convCost += computeExpressionConversionCost( *actualExpr, formalType, indexer, alt.env );
+                        Cost newCost = conversionCost( actualType, formalType, indexer, alt.env );
+                        PRINT(
+                                std::cerr << std::endl << "cost is" << newCost << std::endl;
+                        )
+
+                        if ( newCost == Cost::infinity ) {
+                                return newCost;
+                        }
+                        convCost += newCost;
+                        actualCost += newCost;
+                        if ( actualCost != Cost::zero ) {
+                                Type *newType = formalType->clone();
+                                alt.env.apply( newType );
+                                *actualExpr = new CastExpr( *actualExpr, newType );
+                        }
+                        convCost.incPoly( polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ) );
                         ++formal; // can't be in for-loop update because of the continue
                 }
@@ -381 +348 @@
 
                 for ( InferredParams::const_iterator assert = appExpr->get_inferParams().begin(); assert != appExpr->get_inferParams().end(); ++assert ) {
-                        convCost += computeConversionCost( assert->second.actualType, assert->second.formalType, indexer, alt.env );
+                        PRINT(
+                                std::cerr << std::endl << "converting ";
+                                assert->second.actualType->print( std::cerr, 8 );
+                                std::cerr << std::endl << " to ";
+                                assert->second.formalType->print( std::cerr, 8 );
+                        )
+                        Cost newCost = conversionCost( assert->second.actualType, assert->second.formalType, indexer, alt.env );
+                        PRINT(
+                                std::cerr << std::endl << "cost of conversion is " << newCost << std::endl;
+                        )
+                        if ( newCost == Cost::infinity ) {
+                                return newCost;
+                        }
+                        convCost += newCost;
+                        convCost.incPoly( polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ) );
                 }
 
@@ -795 +776 @@
                 // compute conversionsion costs
                 for ( AltList::iterator withFunc = candidates.begin(); withFunc != candidates.end(); ++withFunc ) {
-                        Cost cvtCost = computeApplicationConversionCost( *withFunc, indexer );
+                        Cost cvtCost = computeConversionCost( *withFunc, indexer );
 
                         PRINT(
@@ -914 +895 @@
                                 // count one safe conversion for each value that is thrown away
                                 thisCost.incSafe( discardedValues );
-                                Alternative newAlt( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost );
-                                // xxx - this doesn't work at the moment, since inferParameters requires an ApplicationExpr as the alternative.
-                                // Once this works, it should be possible to infer parameters on a cast expression and specialize any function.
-
-                                // inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
-                                candidates.emplace_back( std::move( newAlt ) );
+
+                                candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
                         } // if
                 } // for
@@ -1002 +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
@@ -1023 +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
@@ -1162 +1139 @@
                                                 ConditionalExpr *newExpr = new ConditionalExpr( first->expr->clone(), second->expr->clone(), third->expr->clone() );
                                                 newExpr->set_result( commonType ? commonType : second->expr->get_result()->clone() );
-                                                // convert both options to the conditional result type
-                                                newAlt.cost += computeExpressionConversionCost( newExpr->arg2, newExpr->result, indexer, newAlt.env );
-                                                newAlt.cost += computeExpressionConversionCost( newExpr->arg3, newExpr->result, indexer, newAlt.env );
                                                 newAlt.expr = newExpr;
                                                 inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );