Changeset ea83e00a for src

Timestamp:

Dec 13, 2016, 5:01:51 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

722617d

Parents:

7933351

Message:

attempt to narrow resolution of function calls based on return type if a cast is applied

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -608 +608 @@
                 makeUnifiableVars( funcType, openVars, resultNeed );
                 AltList instantiatedActuals; // filled by instantiate function
+                if ( targetType && ! targetType->isVoid() ) {
+                        // attempt to narrow based on expected target type
+                        Type * returnType = funcType->get_returnVals().front()->get_type();
+                        if ( ! unify( returnType, targetType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                // unification failed, don't pursue this alternative
+                                return;
+                        }
+                }
+
                 if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave, instantiatedActuals ) ) {
                         ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
@@ -740 +749 @@
 
                 findMinCost( candidates.begin(), candidates.end(), std::back_inserter( alternatives ) );
+
+                if ( alternatives.empty() && targetType && ! targetType->isVoid() ) {
+                        // xxx - this is a temporary hack. If resolution is unsuccessful with a target type, try again without a
+                        // target type, since it will sometimes succeed when it wouldn't easily with target type binding. For example,
+                        //   forall( otype T ) lvalue T ?[?]( T *, ptrdiff_t );
+                        //   const char * x = "hello world";
+                        //   unsigned char ch = x[0];
+                        // Fails with simple return type binding. First, T is bound to unsigned char, then (x: const char *) is unified
+                        // with unsigned char *, which fails because pointer base types must be unified exactly. The new resolver should
+                        // fix this issue in a more robust way.
+                        targetType = nullptr;
+                        visit( untypedExpr );
+                }
         }