Ignore all kinds of ProtoTypes instead of just AppliedProtos

In blocks, conditionals and matches we mapped applied prototypes to
WildcardTypes in order to force eta expansions. With extension methods
the same problem arises for SelectionProtos as well. Furthermore,
it makes to sense to propagate a ViewProto into a local context. So the
consistent thing to do is to map all kinds of ProtoTypes to WildcardTypes
in these situations.

This fails one line in run/implicitsFuns.scala, which, however is of dubious value.
(The line requires a manually inserted `apply` to propagate a `given` argument
into an if-then-else, circumvening the previous "no applies propagated" strategy.

Author: odersky

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

@@ -1249,9 +1249,6 @@ object Types {
       case _                  => if (isRepeatedParam) this.argTypesHi.head else this
     }
 
-    /** If this is a FunProto or PolyProto, WildcardType, otherwise this. */
-    def notApplied: Type = this
-
     // ----- Normalizing typerefs over refined types ----------------------------
 
     /** If this normalizes* to a refinement type that has a refinement for `name` (which might be followed
@@ -1433,6 +1430,9 @@ object Types {
     /** If this is an ignored proto type, its underlying type, otherwise the type itself */
     def revealIgnored: Type = this
 
+    /** If this is a proto type, the ignored version, otherwise the type itself */
+    def dropIfProto: Type = this
+
 // ----- Substitutions -----------------------------------------------------
 
     /** Substitute all types that refer in their symbol attribute to
@@ -1733,6 +1733,8 @@ object Types {
      *  captures the given context `ctx`.
      */
     def withContext(ctx: Context): ProtoType = this
+
+    override def dropIfProto = WildcardType
   }
 
   /** Implementations of this trait cache the results of `narrow`. */

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

@@ -260,8 +260,6 @@ object ProtoTypes {
       if ((args eq this.args) && (resultType eq this.resultType) && (typer eq this.typer)) this
       else new FunProto(args, resultType)(typer, isGivenApply)
 
-    override def notApplied: Type = WildcardType
-
     /** @return True if all arguments have types.
      */
     def allArgTypesAreCurrent()(implicit ctx: Context): Boolean =
@@ -453,8 +451,6 @@ object ProtoTypes {
       if ((targs eq this.targs) && (resType eq this.resType)) this
       else PolyProto(targs, resType)
 
-    override def notApplied: Type = WildcardType
-
     def map(tm: TypeMap)(implicit ctx: Context): PolyProto =
       derivedPolyProto(targs, tm(resultType))
 

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

@@ -712,7 +712,7 @@ class Typer extends Namer
 
   def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context): Tree = track("typedBlock") {
     val (exprCtx, stats1) = typedBlockStats(tree.stats)
-    val expr1 = typedExpr(tree.expr, pt.notApplied)(exprCtx)
+    val expr1 = typedExpr(tree.expr, pt.dropIfProto)(exprCtx)
     ensureNoLocalRefs(
       cpy.Block(tree)(stats1, expr1).withType(expr1.tpe), pt, localSyms(stats1))
   }
@@ -766,7 +766,7 @@ class Typer extends Namer
     }
     else {
       val thenp1 :: elsep1 :: Nil = harmonic(harmonize, pt)(
-        (tree.thenp :: tree.elsep :: Nil).map(typed(_, pt.notApplied)))
+        (tree.thenp :: tree.elsep :: Nil).map(typed(_, pt.dropIfProto)))
       assignType(cpy.If(tree)(cond1, thenp1, elsep1), thenp1, elsep1)
     }
   }
@@ -1068,7 +1068,7 @@ class Typer extends Namer
 
   // Overridden in InlineTyper for inline matches
   def typedMatchFinish(tree: untpd.Match, sel: Tree, wideSelType: Type, cases: List[untpd.CaseDef], pt: Type)(implicit ctx: Context): Tree = {
-    val cases1 = harmonic(harmonize, pt)(typedCases(cases, wideSelType, pt.notApplied))
+    val cases1 = harmonic(harmonize, pt)(typedCases(cases, wideSelType, pt.dropIfProto))
       .asInstanceOf[List[CaseDef]]
     assignType(cpy.Match(tree)(sel, cases1), sel, cases1)
   }
@@ -1193,8 +1193,8 @@ class Typer extends Namer
 
   def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context): Try = track("typedTry") {
     val expr2 :: cases2x = harmonic(harmonize, pt) {
-      val expr1 = typed(tree.expr, pt.notApplied)
-      val cases1 = typedCases(tree.cases, defn.ThrowableType, pt.notApplied)
+      val expr1 = typed(tree.expr, pt.dropIfProto)
+      val cases1 = typedCases(tree.cases, defn.ThrowableType, pt.dropIfProto)
       expr1 :: cases1
     }
     val finalizer1 = typed(tree.finalizer, defn.UnitType)

tests/pos/implicit-scope.scala

@@ -11,6 +11,7 @@ object A {
 
   delegate FlagOps {
     def (xs: FlagSet) bits: Long = opaques.toBits(xs)
+    def (xs: FlagSet) | (ys: FlagSet): FlagSet = FlagSet(xs.bits | ys.bits)
   }
 }
 
@@ -22,4 +23,8 @@ object B {
 
   val v: Variance = A.someFlag
   v.bits // OK, used to fail with: value bits is not a member of B.Variance
+
+  A.someFlag.bits  // OK
+  var x = 0
+  (if (x > 0) A.someFlag else A.someFlag).bits // OK, used to fail with: value bits is not a member of ?
 }

tests/run/implicitFuns.scala

@@ -56,7 +56,7 @@ object Test {
 
     def foo(s: String): Stringly[Int] = 42
 
-    (if ("".isEmpty) foo("") else foo("")).apply given ""
+    //(if ("".isEmpty) foo("") else foo("")).apply given ""  // does not typecheck
   }
 }