Merge pull request #6715 from dotty-staging/fix-protos

Ignore all kinds of ProtoTypes instead of just AppliedProtos

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, WildcardType, 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/reporting/diagnostic/messages.scala

@@ -1363,7 +1363,9 @@ object messages {
 
     val msg: String = {
       val more = if (tree.isInstanceOf[tpd.Apply]) " more" else ""
-      em"${methodSymbol.showLocated} does not take$more parameters"
+      val meth = methodSymbol
+      val methStr = if (meth.exists) methodSymbol.showLocated else "expression"
+      em"$methStr does not take$more parameters"
     }
 
     val explanation: String = {

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

@@ -493,16 +493,16 @@ trait ImplicitRunInfo { self: Run =>
       override implicit protected val ctx: Context = liftingCtx
       override def stopAtStatic = true
 
+      private def isLiftTarget(sym: Symbol) = sym.isClass || sym.isOpaqueAlias
+
       def apply(tp: Type) = tp match {
         case tp: TypeRef =>
-          val sym = tp.symbol
-          if (sym.isClass || sym.isOpaqueAlias) tp
+          if (isLiftTarget(tp.symbol)) tp
           else {
             val pre = tp.prefix
             def joinClass(tp: Type, cls: Symbol) =
               AndType.make(tp, cls.typeRef.asSeenFrom(pre, cls.owner))
             val lead = if (pre eq NoPrefix) defn.AnyType else apply(pre)
-            def isLiftTarget(sym: Symbol) = sym.isClass || sym.isOpaqueAlias
             (lead /: tp.parentSymbols(isLiftTarget))(joinClass)
           }
         case tp: TypeVar =>
@@ -583,7 +583,7 @@ trait ImplicitRunInfo { self: Run =>
         val liftedTp = if (isLifted) tp else liftToClasses(tp)
         val refs =
           if (liftedTp ne tp) {
-	          implicitsDetailed.println(i"lifted of $tp = $liftedTp")
+            implicitsDetailed.println(i"lifted of $tp = $liftedTp")
             iscope(liftedTp, isLifted = true).companionRefs
           }
           else

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
   }
 }