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

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -14 +14 @@
 //
 
-#include <list>
-#include <iterator>
-#include <algorithm>
-#include <functional>
-#include <cassert>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
+#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 "AlternativeFinder.h"
-#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"
+#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
 
 extern bool resolvep;
@@ -286 +286 @@
         }
 
-        Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
+        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 ) {
                 ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
@@ -304 +353 @@
                                 actualType->print( std::cerr, 8 );
                         )
-                        Cost actualCost = Cost::zero;
                         if ( formal == formals.end() ) {
                                 if ( function->get_isVarArgs() ) {
@@ -325 +373 @@
                                 std::cerr << std::endl;
                         )
-                        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 ) );
+                        convCost += computeExpressionConversionCost( *actualExpr, formalType, indexer, alt.env );
                         ++formal; // can't be in for-loop update because of the continue
                 }
@@ -348 +381 @@
 
                 for ( InferredParams::const_iterator assert = appExpr->get_inferParams().begin(); assert != appExpr->get_inferParams().end(); ++assert ) {
-                        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 ) );
+                        convCost += computeConversionCost( assert->second.actualType, assert->second.formalType, indexer, alt.env );
                 }
 
@@ -776 +795 @@
                 // compute conversionsion costs
                 for ( AltList::iterator withFunc = candidates.begin(); withFunc != candidates.end(); ++withFunc ) {
-                        Cost cvtCost = computeConversionCost( *withFunc, indexer );
+                        Cost cvtCost = computeApplicationConversionCost( *withFunc, indexer );
 
                         PRINT(
@@ -895 +914 @@
                                 // count one safe conversion for each value that is thrown away
                                 thisCost.incSafe( discardedValues );
-
-                                candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
+                                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 ) );
                         } // if
                 } // for
@@ -979 +1002 @@
         void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) {
                 if ( sizeofExpr->get_isType() ) {
-                        // xxx - resolveTypeof?
-                        alternatives.push_back( Alternative( sizeofExpr->clone(), env, Cost::zero ) );
+                        Type * newType = sizeofExpr->get_type()->clone();
+                        alternatives.push_back( Alternative( new SizeofExpr( resolveTypeof( newType, indexer ) ), env, Cost::zero ) );
                 } else {
                         // find all alternatives for the argument to sizeof
@@ -1000 +1023 @@
         void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
                 if ( alignofExpr->get_isType() ) {
-                        // xxx - resolveTypeof?
-                        alternatives.push_back( Alternative( alignofExpr->clone(), env, Cost::zero ) );
+                        Type * newType = alignofExpr->get_type()->clone();
+                        alternatives.push_back( Alternative( new AlignofExpr( resolveTypeof( newType, indexer ) ), env, Cost::zero ) );
                 } else {
                         // find all alternatives for the argument to sizeof
@@ -1139 +1162 @@
                                                 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 ) );