Tweaks and more comments

Author: odersky

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

@@ -45,7 +45,14 @@ object ProtoTypes {
       }
       if (keepConstraint)
         tp.widenSingleton match {
-          case poly: PolyType => normalizedCompatible(tp, pt, keepConstraint = false)
+          case poly: PolyType =>
+            // We can't keep the constraint in this case, since we have to add type parameters
+            // to it, but there's no place to associate them with type variables.
+            // So we'd get a "inconsistent: no typevars were added to committable constraint"
+            // assertion failure in `constrained`. To do better, we'd have to change the
+            // constraint handling architecture so that some type parameters are committable
+            // and others are not. But that's a whole different ballgame.
+            normalizedCompatible(tp, pt, keepConstraint = false)
           case _ => testCompat
         }
       else ctx.test(implicit ctx => testCompat)
@@ -196,8 +203,18 @@ object ProtoTypes {
   def selectionProto(name: Name, tp: Type, typer: Typer)(implicit ctx: Context): TermType =
     if (name.isConstructorName) WildcardType
     else tp match {
-      case tp: UnapplyFunProto => new UnapplySelectionProto(name)
-      case tp => SelectionProto(name, IgnoredProto(tp), typer, privateOK = true)
+      case tp: UnapplyFunProto =>
+        new UnapplySelectionProto(name)
+      case tp =>
+        val memberProto =
+          if (ctx.mode.is(Mode.SynthesizeExtMethodReceiver)) tp
+          else IgnoredProto(tp)
+          // Disregard what's known about the member in the selection prototype.
+          // This allows implicit conversions to be applied on the member
+          // and avoids duplicated computations. Exception: when synthesizing
+          // the receiver of an extension method, we do take the type of the first
+          // argument into sccount.
+        SelectionProto(name, memberProto, typer, privateOK = true)
     }
 
   /** A prototype for expressions [] that are in some unspecified selection operation
@@ -246,6 +263,8 @@ object ProtoTypes {
     def isMatchedBy(tp: Type, keepConstraint: Boolean)(implicit ctx: Context): Boolean = {
       val args = unforcedTypedArgs
       def isPoly(tree: Tree) = tree.tpe.widenSingleton.isInstanceOf[PolyType]
+      // See remark in normalizedCompatible for why we can't keep the constraint
+      // if one of the arguments has a PolyType.
       typer.isApplicable(tp, Nil, args, resultType, keepConstraint && !args.exists(isPoly))
     }
 
@@ -308,7 +327,7 @@ object ProtoTypes {
       if (state.typedArgs.size == args.length) state.typedArgs
       else {
         val args1 = args.mapconserve(cacheTypedArg(_, typer.typed(_), force))
-        if (!args1.contains(WildcardType)) state.typedArgs = args1
+        if (force || !args1.contains(WildcardType)) state.typedArgs = args1
         args1
       }
 

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

@@ -2397,13 +2397,6 @@ class Typer extends Namer
       }
     }
 
-    /** Reveal ignored parts of prototype when synthesizing the receiver
-     *  of an extension method. This is necessary for pos/i5773.scala
-     */
-    def revealProtoOfExtMethod(tp: Type)(implicit ctx: Context): Type =
-      if (ctx.mode.is(Mode.SynthesizeExtMethodReceiver)) tp.deepenProto
-      else tp
-
     def adaptNoArgsImplicitMethod(wtp: MethodType): Tree = {
       assert(wtp.isImplicitMethod)
       val tvarsToInstantiate = tvarsInParams(tree, locked).distinct
@@ -2616,7 +2609,7 @@ class Typer extends Namer
     }
 
     def resultMatches(wtp: Type, pt: Type) =
-      constrainResult(tree.symbol, wtp, revealProtoOfExtMethod(followAlias(pt)))
+      constrainResult(tree.symbol, wtp, followAlias(pt))
 
     def adaptNoArgs(wtp: Type): Tree = {
       val ptNorm = underlyingApplied(pt)