Avoid redundant errors on inferred trees

Issue well-formed errors on well-formed trees only if there
are no other errors.

Author: odersky

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -142,6 +142,24 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
       tree
     }
 
+    private def processValOrDefDef(tree: Tree)(using Context): tree.type =
+      tree match
+        case tree: ValOrDefDef if !tree.symbol.is(Synthetic) =>
+          checkInferredWellFormed(tree.tpt)
+        case _ =>
+      processMemberDef(tree)
+
+    private def checkInferredWellFormed(tree: Tree)(using ctx: Context): Unit = tree match
+      case tree: TypeTree
+      if tree.span.isZeroExtent
+          // don't check TypeTrees with non-zero extent;
+          // these are derived from explicit types
+         && !ctx.reporter.errorsReported
+          // don't check if errors were already reported; this avoids follow-on errors
+          // for inferred types if explicit types are already ill-formed
+        => Checking.checkAppliedTypesIn(tree)
+      case _ =>
+
     private def transformSelect(tree: Select, targs: List[Tree])(implicit ctx: Context): Tree = {
       val qual = tree.qualifier
       qual.symbol.moduleClass.denot match {
@@ -226,17 +244,26 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
                   else dropInlines.transform(arg)))
             else
               tree
-          methPart(app) match {
+          def app1 = 
+   			// reverse order of transforming args and fun. This way, we get a chance to see other
+   			// well-formedness errors before reporting errors in possible inferred type args of fun.
+            val args1 = transform(app.args) 
+            cpy.Apply(app)(transform(app.fun), args1)
+          methPart(app) match
             case Select(nu: New, nme.CONSTRUCTOR) if isCheckable(nu) =>
               // need to check instantiability here, because the type of the New itself
               // might be a type constructor.
               Checking.checkInstantiable(tree.tpe, nu.posd)
-              withNoCheckNews(nu :: Nil)(super.transform(app))
+              withNoCheckNews(nu :: Nil)(app1)
             case _ =>
-              super.transform(app)
-          }
+              app1
+        case UnApply(fun, implicits, patterns) =>
+          // Reverse transform order for the same reason as in `app1` above. 
+          val patterns1 = transform(patterns)
+          cpy.UnApply(tree)(transform(fun), transform(implicits), patterns1)
         case tree: TypeApply =>
           val tree1 @ TypeApply(fn, args) = normalizeTypeArgs(tree)
+          args.foreach(checkInferredWellFormed)
           if (fn.symbol != defn.ChildAnnot.primaryConstructor)
             // Make an exception for ChildAnnot, which should really have AnyKind bounds
             Checking.checkBounds(args, fn.tpe.widen.asInstanceOf[PolyType])
@@ -262,11 +289,11 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           }
         case tree: ValDef =>
           val tree1 = cpy.ValDef(tree)(rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
-          processMemberDef(super.transform(tree1))
+          processValOrDefDef(super.transform(tree1))
         case tree: DefDef =>
           annotateContextResults(tree)
           val tree1 = cpy.DefDef(tree)(rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
-          processMemberDef(superAcc.wrapDefDef(tree1)(super.transform(tree1).asInstanceOf[DefDef]))
+          processValOrDefDef(superAcc.wrapDefDef(tree1)(super.transform(tree1).asInstanceOf[DefDef]))
         case tree: TypeDef =>
           val sym = tree.symbol
           if (sym.isClass)
@@ -304,9 +331,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           Checking.checkRealizable(ref.tpe, ref.posd)
           super.transform(tree)
         case tree: TypeTree =>
-          if tree.span.isZeroExtent then
-            // Don't check TypeTrees with non-zero extent; these are derived from explicit types
-            Checking.checkAppliedTypesIn(tree)
           tree.withType(
             tree.tpe match {
               case AnnotatedType(tpe, annot) => AnnotatedType(tpe, transformAnnot(annot))

tests/neg/i4382.check

@@ -1,16 +1,24 @@
--- Error: tests/neg/i4382.scala:3:10 -----------------------------------------------------------------------------------
+-- [E043] Type Error: tests/neg/i4382.scala:3:10 -----------------------------------------------------------------------
 3 |  def v1: Id[_] = ??? // error
   |          ^^^^^
   |          unreducible application of higher-kinded type App.Id to wildcard arguments
--- Error: tests/neg/i4382.scala:6:10 -----------------------------------------------------------------------------------
+
+longer explanation available when compiling with `-explain`
+-- [E043] Type Error: tests/neg/i4382.scala:6:10 -----------------------------------------------------------------------
 6 |  def v2: HkL[_] = ??? // error
   |          ^^^^^^
   |          unreducible application of higher-kinded type App.HkL to wildcard arguments
--- Error: tests/neg/i4382.scala:9:10 -----------------------------------------------------------------------------------
+
+longer explanation available when compiling with `-explain`
+-- [E043] Type Error: tests/neg/i4382.scala:9:10 -----------------------------------------------------------------------
 9 |  def v3: HkU[_] = ???  // error
   |          ^^^^^^
   |          unreducible application of higher-kinded type App.HkU to wildcard arguments
--- Error: tests/neg/i4382.scala:12:10 ----------------------------------------------------------------------------------
+
+longer explanation available when compiling with `-explain`
+-- [E043] Type Error: tests/neg/i4382.scala:12:10 ----------------------------------------------------------------------
 12 |  def v4: HkAbs[_] = ??? // error
    |          ^^^^^^^^
    |          unreducible application of higher-kinded type App.HkAbs to wildcard arguments
+
+longer explanation available when compiling with `-explain`

tests/neg/i5302.scala

@@ -1,2 +1,3 @@
 type L[X]
-def foo = { class A; null.asInstanceOf[L[A]] }  // error // error
+def foo = { class A; null.asInstanceOf[L[A]] }  // error
+def bar(x: L[_]) = x // error