Merge pull request scala#6871 from adriaanm/overload_proto

More precise prototype for args of overloaded method

Author: SethTisue

spec/06-expressions.md

@@ -1432,11 +1432,27 @@ to expressions $(e_1 , \ldots , e_n)$ of types $(\mathit{shape}(e_1) , \ldots ,
 If there is precisely one alternative in $\mathscr{B}$, that alternative is chosen.
 
 Otherwise, let $S_1 , \ldots , S_m$ be the list of types obtained by typing each argument as follows.
-An argument `$e_i$` of the shape `($p_1$: $T_1 , \ldots , p_n$: $T_n$) => $b$` where one of the `$T_i$` is missing,
-i.e., a function literal with a missing parameter type, is typed with an expected function type that
-propagates the least upper bound of the fully defined types of the corresponding parameters of
-the ([SAM-converted](#sam-conversion)) function types specified by the `$i$`th argument type found in each alternative.
-All other arguments are typed with an undefined expected type.
+
+Normally, an argument is typed without an expected type, except when trying to propagate more type
+information to aid inference of higher-order function parameter types, as explained next. The intuition is
+that all arguments must be of a function-like type (`PartialFunction`, `FunctionN` or some equivalent [SAM type](#sam-conversion)),
+which in turn must define the same set of higher-order argument types, so that they can safely be used as
+the expected type of a given argument of the overloaded method, without unduly ruling out any alternatives.
+The intent is not to steer overloading resolution, but to preserve enough type information to steer type
+inference of the arguments (a function literal or eta-expanded method) to this overloaded method.
+
+Note that the expected type drives eta-expansion (not performed unless a function-like type is expected),
+as well as inference of omitted parameter types of function literals.
+
+More precisely, an argument `$e_i$` is typed with an expected type that is derived from the `$i$`th argument
+type found in each alternative (call these `$T_{ij}$` for alternative `$j$` and argument position `$i$`) when
+all `$T_{ij}$` are function types `$(A_{1j},..., A_{nj}) => ?$` (or the equivalent `PartialFunction`, or SAM)
+of some arity `$n$`, and their argument types `$A_{kj}$` are identical across all overloads `$j$` for a
+given `$k$`. Then, the expected type for `$e_i$` is derived as follows:
+   - we use `$PartialFunction[A_{1j},..., A_{nj}, ?]$` if for some overload `$j$`, `$T_{ij}$`'s type symbol is `PartialFunction`;
+   - else, if for some `$j$`, `$T_{ij}$` is `FunctionN`, the expected type is `$FunctionN[A_{1j},..., A_{nj}, ?]$`;
+   - else, if for all `$j$`, `$T_{ij}$` is a SAM type of the same class, defining argument types `$A_{1j},..., A_{nj}$`
+     (and a potentially varying result type), the expected type encodes these argument types and the SAM class.
 
 For every member $m$ in $\mathscr{B}$ one determines whether it is applicable
 to expressions ($e_1 , \ldots , e_m$) of types $S_1, \ldots , S_m$.

src/compiler/scala/tools/nsc/typechecker/Implicits.scala

@@ -329,6 +329,8 @@ trait Implicits {
     result
   }
 
+  // TODO: use ProtoType for HasMember/HasMethodMatching
+
   /** An extractor for types of the form ? { name: ? }
    */
   object HasMember {
@@ -634,7 +636,7 @@ trait Implicits {
     private def matchesPtView(tp: Type, ptarg: Type, ptres: Type, undet: List[Symbol]): Boolean = tp match {
       case MethodType(p :: _, restpe) if p.isImplicit => matchesPtView(restpe, ptarg, ptres, undet)
       case MethodType(p :: Nil, restpe)               => matchesArgRes(p.tpe, restpe, ptarg, ptres, undet)
-      case ExistentialType(_, qtpe)                   => matchesPtView(normalize(qtpe), ptarg, ptres, undet)
+      case ExistentialType(_, qtpe)                   => matchesPtView(methodToExpressionTp(qtpe), ptarg, ptres, undet)
       case Function1(arg1, res1)                      => matchesArgRes(arg1, res1, ptarg, ptres, undet)
       case _                                          => false
     }
@@ -733,7 +735,7 @@ trait Implicits {
           }
         case NullaryMethodType(restpe)  => loop(restpe, pt)
         case PolyType(_, restpe)        => loop(restpe, pt)
-        case ExistentialType(_, qtpe)   => if (fast) loop(qtpe, pt) else normalize(tp) <:< pt // is !fast case needed??
+        case ExistentialType(_, qtpe)   => if (fast) loop(qtpe, pt) else methodToExpressionTp(tp) <:< pt // is !fast case needed??
         case _                          => if (fast) isPlausiblySubType(tp, pt) else tp <:< pt
       }
       loop(tp0, pt0)

src/compiler/scala/tools/nsc/typechecker/Infer.scala

@@ -50,6 +50,42 @@ trait Infer extends Checkable {
       formals1
   }
 
+  // @requires sam == samOf(samTp)
+  def instantiateSamFromFunction(funTp: Type, samTp: Type, sam: Symbol) = {
+    val samClassSym = samTp.typeSymbol
+
+    // the unknowns
+    val tparams = samClassSym.typeParams
+
+    if (tparams.isEmpty) samTp
+    else {
+      // ... as typevars
+      val tvars = tparams map freshVar
+
+      // we're trying to fully define the type arguments for this type constructor
+      val samTyCon = samClassSym.typeConstructor
+
+      val ptVars = appliedType(samTyCon, tvars)
+
+      // carry over info from pt
+      ptVars <:< samTp
+
+      val samInfoWithTVars = ptVars.memberInfo(sam)
+
+      // use function type subtyping, not method type subtyping (the latter is invariant in argument types)
+      funTp <:< functionType(samInfoWithTVars.paramTypes, samInfoWithTVars.finalResultType)
+
+      val variances = tparams map varianceInType(sam.info)
+
+      // solve constraints tracked by tvars
+      val targs = solvedTypes(tvars, tparams, variances, upper = false, lubDepth(sam.info :: Nil))
+
+      debuglog(s"sam infer: $samTp --> ${appliedType(samTyCon, targs)} by ${funTp} <:< $samInfoWithTVars --> $targs for $tparams")
+
+      appliedType(samTyCon, targs)
+    }
+  }
+
   /** Sorts the alternatives according to the given comparison function.
    *  Returns a list containing the best alternative as well as any which
    *  the best fails to improve upon.
@@ -103,9 +139,9 @@ trait Infer extends Checkable {
         finally excludedVars -= tv
     }
     def apply(tp: Type): Type = tp match {
-      case WildcardType | BoundedWildcardType(_) | NoType => throw new NoInstance("undetermined type")
-      case tv: TypeVar if !tv.untouchable                 => applyTypeVar(tv)
-      case _                                              => mapOver(tp)
+      case _: ProtoType | NoType          => throw new NoInstance("undetermined type")
+      case tv: TypeVar if !tv.untouchable => applyTypeVar(tv)
+      case _                              => mapOver(tp)
     }
   }
 
@@ -115,13 +151,13 @@ trait Infer extends Checkable {
   /** Is type fully defined, i.e. no embedded anytypes or wildcards in it?
    */
   private[typechecker] def isFullyDefined(tp: Type): Boolean = tp match {
-    case WildcardType | BoundedWildcardType(_) | NoType => false
-    case NoPrefix | ThisType(_) | ConstantType(_)       => true
-    case TypeRef(pre, _, args)                          => isFullyDefined(pre) && (args forall isFullyDefined)
-    case SingleType(pre, _)                             => isFullyDefined(pre)
-    case RefinedType(ts, _)                             => ts forall isFullyDefined
-    case TypeVar(_, constr) if constr.inst == NoType    => false
-    case _                                              => falseIfNoInstance({ instantiate(tp) ; true })
+    case _: ProtoType | NoType                       => false
+    case NoPrefix | ThisType(_) | ConstantType(_)    => true
+    case TypeRef(pre, _, args)                       => isFullyDefined(pre) && (args forall isFullyDefined)
+    case SingleType(pre, _)                          => isFullyDefined(pre)
+    case RefinedType(ts, _)                          => ts forall isFullyDefined
+    case TypeVar(_, constr) if constr.inst == NoType => false
+    case _                                           => falseIfNoInstance { instantiate(tp); true }
   }
 
   /** Solve constraint collected in types `tvars`.
@@ -151,25 +187,7 @@ trait Infer extends Checkable {
     case _                                => tp
   }
 
-  /** Automatically perform the following conversions on expression types:
-   *  A method type becomes the corresponding function type.
-   *  A nullary method type becomes its result type.
-   *  Implicit parameters are skipped.
-   *  This method seems to be performance critical.
-   */
-  def normalize(tp: Type): Type = tp match {
-    case PolyType(_, restpe) =>
-      logResult(sm"""|Normalizing PolyType in infer:
-                     |  was: $restpe
-                     |  now""")(normalize(restpe))
-    case mt @ MethodType(_, restpe) if mt.isImplicit             => normalize(restpe)
-    case mt @ MethodType(_, restpe) if !mt.isDependentMethodType =>
-      if (phase.erasedTypes) FunctionClass(mt.params.length).tpe
-      else functionType(mt.paramTypes, normalize(restpe))
-    case NullaryMethodType(restpe)                               => normalize(restpe)
-    case ExistentialType(tparams, qtpe)                          => newExistentialType(tparams, normalize(qtpe))
-    case _                                                       => tp // @MAT aliases already handled by subtyping
-  }
+
 
   private lazy val stdErrorClass = rootMirror.RootClass.newErrorClass(tpnme.ERROR)
   private lazy val stdErrorValue = stdErrorClass.newErrorValue(nme.ERROR)
@@ -297,11 +315,11 @@ trait Infer extends Checkable {
         && isCompatible(tp, dropByName(pt))
       )
       def isCompatibleSam(tp: Type, pt: Type): Boolean = (definitions.isFunctionType(tp) || tp.isInstanceOf[MethodType] || tp.isInstanceOf[PolyType]) &&  {
-        val samFun = typer.samToFunctionType(pt)
+        val samFun = samToFunctionType(pt)
         (samFun ne NoType) && isCompatible(tp, samFun)
       }
 
-      val tp1 = normalize(tp)
+      val tp1 = methodToExpressionTp(tp)
 
       (    (tp1 weak_<:< pt)
         || isCoercible(tp1, pt)
@@ -344,9 +362,8 @@ trait Infer extends Checkable {
         tparam.tpe
       }
       val tp1 = tp map {
-        case WildcardType                => addTypeParam(TypeBounds.empty)
-        case BoundedWildcardType(bounds) => addTypeParam(bounds)
-        case t                           => t
+        case pt: ProtoType => addTypeParam(pt.toBounds)
+        case t             => t
       }
       if (tp eq tp1) tp
       else existentialAbstraction(tparams.reverse, tp1)
@@ -359,25 +376,27 @@ trait Infer extends Checkable {
      *  conforms to `pt`, return null.
      */
     private def exprTypeArgs(tvars: List[TypeVar], tparams: List[Symbol], restpe: Type, pt: Type, useWeaklyCompatible: Boolean): List[Type] = {
-      def restpeInst = restpe.instantiateTypeParams(tparams, tvars)
-      def conforms   = if (useWeaklyCompatible) isWeaklyCompatible(restpeInst, pt) else isCompatible(restpeInst, pt)
-      // If the restpe is an implicit method, and the expected type is fully defined
-      // optimize type variables wrt to the implicit formals only; ignore the result type.
-      // See test pos/jesper.scala
-      def variance = restpe match {
-        case mt: MethodType if mt.isImplicit && isFullyDefined(pt) => MethodType(mt.params, AnyTpe)
-        case _                                                     => restpe
-      }
-      def solve() = solvedTypes(tvars, tparams, tparams map varianceInType(variance), upper = false, lubDepth(restpe :: pt :: Nil))
+      val resTpVars = restpe.instantiateTypeParams(tparams, tvars)
 
-      if (conforms) {
+      if (if (useWeaklyCompatible) isWeaklyCompatible(resTpVars, pt) else isCompatible(resTpVars, pt)) {
         // If conforms has just solved a tvar as a singleton type against pt, then we need to
         // prevent it from being widened later by adjustTypeArgs
         tvars.foreach(_.constr.stopWideningIfPrecluded)
-        try solve() catch { case _: NoInstance => null }
+
+        // If the restpe is an implicit method, and the expected type is fully defined
+        // optimize type variables wrt to the implicit formals only; ignore the result type.
+        // See test pos/jesper.scala
+        val variance = restpe match {
+          case mt: MethodType if mt.isImplicit && isFullyDefined(pt) => MethodType(mt.params, AnyTpe)
+          case _                                                     => restpe
+        }
+
+        try solvedTypes(tvars, tparams, tparams map varianceInType(variance), upper = false, lubDepth(restpe :: pt :: Nil))
+        catch { case _: NoInstance => null }
       } else
         null
     }
+
     /** Overload which allocates fresh type vars.
      *  The other one exists because apparently inferExprInstance needs access to the typevars
      *  after the call, and it's wasteful to return a tuple and throw it away almost every time.