Adding () insertion to normalization.

We need to take account of the possibility of inserting a () argument list in normalization. Otherwise, a type with a

    def toString(): String

member would not count as a valid solution for ?{toString: String}. This would then lead to an implicit insertion, with a nice explosion of inference search because of course every implicit result has some sort
of toString method.

The problem is solved by dereferencing nullary method types if the corresponding function type is not
compatible with the prototype.

2 files changed, 18 insertions, 6 deletions

diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala
index 08987a095..860a7be80 100644
--- a/src/dotty/tools/dotc/typer/Applications.scala
+++ b/src/dotty/tools/dotc/typer/Applications.scala
@@ -315,11 +315,11 @@ trait Applications extends Compatibility { self: Typer =>
     type Result = Unit
 
     /** The type of the given argument */
-    protected def argType(arg: Arg): Type
+    protected def argType(arg: Arg, formal: Type): Type
 
     def typedArg(arg: Arg, formal: Type): Arg = arg
     def addArg(arg: TypedArg, formal: Type) =
-      ok = ok & isCompatible(argType(arg), formal)
+      ok = ok & isCompatible(argType(arg, formal), formal)
     def makeVarArg(n: Int, elemFormal: Type) = {}
     def fail(msg: => String, arg: Arg) =
       ok = false
@@ -333,7 +333,7 @@ trait Applications extends Compatibility { self: Typer =>
   /** Subclass of Application for applicability tests with trees as arguments. */
   class ApplicableToTrees(methRef: TermRef, args: List[Tree], resultType: Type)(implicit ctx: Context)
   extends TestApplication(methRef, methRef, args, resultType) {
-    def argType(arg: Tree): Type = normalize(arg.tpe, NoType)
+    def argType(arg: Tree, formal: Type): Type = normalize(arg.tpe, formal)
     def treeToArg(arg: Tree): Tree = arg
     def isVarArg(arg: Tree): Boolean = tpd.isWildcardStarArg(arg)
   }
@@ -341,7 +341,7 @@ trait Applications extends Compatibility { self: Typer =>
   /** Subclass of Application for applicability tests with types as arguments. */
   class ApplicableToTypes(methRef: TermRef, args: List[Type], resultType: Type)(implicit ctx: Context)
   extends TestApplication(methRef, methRef, args, resultType) {
-    def argType(arg: Type): Type = arg
+    def argType(arg: Type, formal: Type): Type = arg
     def treeToArg(arg: Tree): Type = arg.tpe
     def isVarArg(arg: Type): Boolean = arg.isRepeatedParam
   }
diff --git a/src/dotty/tools/dotc/typer/Inferencing.scala b/src/dotty/tools/dotc/typer/Inferencing.scala
index 92467c0e2..124f43391 100644
--- a/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -32,7 +32,7 @@ object Inferencing {
     def isCompatible(tp: Type, pt: Type)(implicit ctx: Context): Boolean =
       tp.widenByName <:< pt.widenByName || viewExists(tp, pt)
 
-    /** Test compatibility after normalization in a fresh typerstate */
+    /** Test compatibility after normalization in a fresh typerstate. */
     def normalizedCompatible(tp: Type, pt: Type)(implicit ctx: Context) = {
       val nestedCtx = ctx.fresh.withExploreTyperState
       isCompatible(normalize(tp, pt)(nestedCtx), pt)(nestedCtx)
@@ -164,13 +164,25 @@ object Inferencing {
    *   - skips implicit parameters
    *   - converts non-dependent method types to the corresponding function types
    *   - dereferences parameterless method types
+   *   - dereferences nullary method types provided the corresponding function type
+   *     is not a subtype of the expected type.
+   * Note: We need to take account of the possibility of inserting a () argument list in normalization. Otherwise, a type with a
+   *     def toString(): String
+   * member would not count as a valid solution for ?{toString: String}. This would then lead to an implicit
+   * insertion, with a nice explosion of inference search because of course every implicit result has some sort
+   * of toString method. The problem is solved by dereferencing nullary method types if the corresponding
+   * function type is not compatible with the prototype.
    */
   def normalize(tp: Type, pt: Type)(implicit ctx: Context): Type = Stats.track("normalize") {
     tp.widenSingleton match {
       case pt: PolyType => normalize(constrained(pt).resultType, pt)
       case mt: MethodType if !mt.isDependent /*&& !pt.isInstanceOf[ApplyingProto]*/ =>
         if (mt.isImplicit) mt.resultType
-        else defn.FunctionType(mt.paramTypes, normalize(mt.resultType, pt))
+        else {
+          val rt = normalize(mt.resultType, pt)
+          val ft = defn.FunctionType(mt.paramTypes, rt)
+          if (mt.paramTypes.nonEmpty || ft <:< pt) ft else rt
+        }
       case et: ExprType => et.resultType
       case _ => tp
     }