Further fixes

 - avoid forcing denotation's info in `matches`
 - deal with overloaded alternatives in assignType for TypeApply

Author: odersky

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -1073,9 +1073,9 @@ object Denotations {
       val d = signature.matchDegree(other.signature)
       (// fast path: signatures are the same and neither denotation is a PolyType
        // For polytypes, signatures alone do not tell us enough to be sure about matching.
-       d == Signature.FullMatch && !info.isInstanceOf[PolyType] && !other.info.isInstanceOf[PolyType]
+       d == Signature.FullMatch &&
+       !infoOrCompleter.isInstanceOf[PolyType] && !other.infoOrCompleter.isInstanceOf[PolyType]
        ||
-       // slow path
        d >= Signature.ParamMatch && info.matches(other.info))
     }
 

compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -381,65 +381,70 @@ trait TypeAssigner {
   }
 
   def assignType(tree: untpd.TypeApply, fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
-    val ownType = fn.tpe.widen match {
+    def fail = tree.withType(errorType(err.takesNoParamsStr(fn, "type "), tree.pos))
+    fn.tpe.widen match {
       case pt: TypeLambda =>
-        val paramNames = pt.paramNames
-        if (hasNamedArg(args)) {
-          val paramBoundsByName = paramNames.zip(pt.paramInfos).toMap
-
-          // Type arguments which are specified by name (immutable after this first loop)
-          val namedArgMap = new mutable.HashMap[Name, Type]
-          for (NamedArg(name, arg) <- args)
-            if (namedArgMap.contains(name))
-              ctx.error(DuplicateNamedTypeParameter(name), arg.pos)
-            else if (!paramNames.contains(name))
-              ctx.error(UndefinedNamedTypeParameter(name, paramNames), arg.pos)
-            else
-              namedArgMap(name) = arg.tpe
-
-          // Holds indexes of non-named typed arguments in paramNames
-          val gapBuf = new mutable.ListBuffer[Int]
-          def nextPoly(idx: Int) = {
-            val newIndex = gapBuf.length
-            gapBuf += idx
-            // Re-index unassigned type arguments that remain after transformation
-            pt.paramRefs(newIndex)
-          }
+        tree.withType {
+          val paramNames = pt.paramNames
+          if (hasNamedArg(args)) {
+            val paramBoundsByName = paramNames.zip(pt.paramInfos).toMap
+
+            // Type arguments which are specified by name (immutable after this first loop)
+            val namedArgMap = new mutable.HashMap[Name, Type]
+            for (NamedArg(name, arg) <- args)
+              if (namedArgMap.contains(name))
+                ctx.error(DuplicateNamedTypeParameter(name), arg.pos)
+              else if (!paramNames.contains(name))
+                ctx.error(UndefinedNamedTypeParameter(name, paramNames), arg.pos)
+              else
+                namedArgMap(name) = arg.tpe
+
+            // Holds indexes of non-named typed arguments in paramNames
+            val gapBuf = new mutable.ListBuffer[Int]
+            def nextPoly(idx: Int) = {
+              val newIndex = gapBuf.length
+              gapBuf += idx
+              // Re-index unassigned type arguments that remain after transformation
+              pt.paramRefs(newIndex)
+            }
 
-          // Type parameters after naming assignment, conserving paramNames order
-          val normArgs: List[Type] = paramNames.zipWithIndex.map { case (pname, idx) =>
-            namedArgMap.getOrElse(pname, nextPoly(idx))
-          }
+            // Type parameters after naming assignment, conserving paramNames order
+            val normArgs: List[Type] = paramNames.zipWithIndex.map { case (pname, idx) =>
+              namedArgMap.getOrElse(pname, nextPoly(idx))
+            }
 
-          val transform = new TypeMap {
-            def apply(t: Type) = t match {
-              case TypeParamRef(`pt`, idx) => normArgs(idx)
-              case _ => mapOver(t)
+            val transform = new TypeMap {
+              def apply(t: Type) = t match {
+                case TypeParamRef(`pt`, idx) => normArgs(idx)
+                case _ => mapOver(t)
+              }
+            }
+            val resultType1 = transform(pt.resultType)
+            if (gapBuf.isEmpty) resultType1
+            else {
+              val gaps = gapBuf.toList
+              pt.derivedLambdaType(
+                gaps.map(paramNames),
+                gaps.map(idx => transform(pt.paramInfos(idx)).bounds),
+                resultType1)
             }
           }
-          val resultType1 = transform(pt.resultType)
-          if (gapBuf.isEmpty) resultType1
           else {
-            val gaps = gapBuf.toList
-            pt.derivedLambdaType(
-              gaps.map(paramNames),
-              gaps.map(idx => transform(pt.paramInfos(idx)).bounds),
-              resultType1)
+            val argTypes = args.tpes
+            if (sameLength(argTypes, paramNames)) pt.instantiate(argTypes)
+            else wrongNumberOfTypeArgs(fn.tpe, pt.typeParams, args, tree.pos)
           }
         }
-        else {
-          val argTypes = args.tpes
-          if (sameLength(argTypes, paramNames)) pt.instantiate(argTypes)
-          else wrongNumberOfTypeArgs(fn.tpe, pt.typeParams, args, tree.pos)
-        }
       case err: ErrorType =>
-        err
+        tree.withType(err)
+      case ref: TermRef if ref.isOverloaded =>
+        val disambiguated = ref.denot.suchThat(_.info.isInstanceOf[PolyType])
+        if (disambiguated.exists) assignType(tree, fn.withType(ref.withDenot(disambiguated)), args)
+        else fail
       case _ =>
         //println(i"bad type: $fn: ${fn.symbol} / ${fn.symbol.isType} / ${fn.symbol.info}") // DEBUG
-        errorType(err.takesNoParamsStr(fn, "type "), tree.pos)
+        fail
     }
-
-    tree.withType(ownType)
   }
 
   def assignType(tree: untpd.Typed, tpt: Tree)(implicit ctx: Context): Typed =

tests/neg/i4819.scala

@@ -7,10 +7,6 @@ trait Two[Y <: Foo] {
 }
 
 class Foo extends One[Foo] with Two[Foo] {
-  concat(0) // OK
-
-  // TODO: This does not typecheck because the polymorphic overload is masked
-  // (we merge the denotations for both overloads into one and always prefer
-  // MethodType to PolyType, instead we should return a MultiDenotation). See #4819.
-  concat[Int](0) // error (that should actually not be an error)
+  concat(0) // error: ambiguous overload
+  concat[Int](0) // OK
 }

tests/pos/i4819.scala

@@ -7,6 +7,12 @@ trait Two[Y <: Foo] {
 }
 
 class Foo extends One[Foo] with Two[Foo] {
-  concat(0) // OK
+  concat[Int](0) // OK
   // See also tests/neg/i4819.scala
 }
+
+class Bar extends One[String] with Two[Foo] {
+  val x: String = concat(0)
+  val y = concat[Int](0)
+  val z: Foo = concat(0)
+}