Fix #8569: Better error message for erroneous creator applications

Don't just fall-back to say "not a member".

Author: odersky

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

@@ -29,7 +29,7 @@ import config.Printers.{overload, typr, unapp}
 import TypeApplications._
 
 import reporting.diagnostic.Message
-import reporting.diagnostic.messages.{UnexpectedPatternForSummonFrom, NotAMember}
+import reporting.diagnostic.messages.{UnexpectedPatternForSummonFrom, NotAMember, MissingIdent}
 import reporting.trace
 import Constants.{Constant, IntTag, LongTag}
 import dotty.tools.dotc.reporting.diagnostic.messages.{UnapplyInvalidReturnType, NotAnExtractor, UnapplyInvalidNumberOfArguments}
@@ -819,12 +819,13 @@ trait Applications extends Compatibility {
     tryEither {
       typedExpr(fn, pt)
     } { (result, tstate) =>
-      def fallBack = {
-        tstate.commit()
+      def fallBack(nuState: TyperState) =
+        if (nuState ne ctx.typerState) && !saysNotFound(nuState, EmptyTypeName)
+        then nuState.commit() // nuState messages are more interesting that tstate's "not found"
+        else tstate.commit()  // it's "not found" both ways; keep original message
         result
-      }
-      if (untpd.isPath(fn)) tryNew(untpd)(fn, pt, fallBack)
-      else fallBack
+      if untpd.isPath(fn) then tryNew(untpd)(fn, pt, fallBack)
+      else fallBack(ctx.typerState)
     }
 
   /** Typecheck application. Result could be an `Apply` node,
@@ -1056,6 +1057,21 @@ trait Applications extends Compatibility {
       tree
   }
 
+  /** Does `state` contain a single "NotAMember" or "MissingIdent" message as
+   *  pending error message that says `$memberName is not a member of ...` or
+   *  `Not found: $memberName`? If memberName is empty, any name will do.
+   */
+  def saysNotFound(state: TyperState, memberName: Name)(using Context): Boolean =
+    state.reporter.pendingMessages match
+      case msg :: Nil =>
+        msg.contained match
+          case NotAMember(_, name, _, _) =>
+            memberName.isEmpty || name == memberName
+          case MissingIdent(_, _, name) =>
+            memberName.isEmpty || name == memberName.toString
+          case _ => false
+      case _ => false
+
   def typedUnApply(tree: untpd.Apply, selType: Type)(implicit ctx: Context): Tree = {
     record("typedUnApply")
     val Apply(qual, args) = tree
@@ -1066,25 +1082,14 @@ trait Applications extends Compatibility {
       if (!tree.tpe.isError && tree.tpe.isErroneous) tree
       else errorTree(tree, NotAnExtractor(qual))
 
-    /** Does `state` contain a single "NotAMember" message as pending error message
-     *  that says `$membername is not a member of ...` ?
-     */
-    def saysNotAMember(state: TyperState, memberName: TermName): Boolean =
-      state.reporter.pendingMessages match
-        case msg :: Nil =>
-          msg.contained match
-            case NotAMember(_, name, _, _) => name == memberName
-            case _ => false
-        case _ => false
-
     /** Report errors buffered in state.
      *  @pre state has errors to report
      *  If there is a single error stating that "unapply" is not a member, print
      *  the more informative "notAnExtractor" message instead.
      */
     def reportErrors(tree: Tree, state: TyperState): Tree =
       assert(state.reporter.hasErrors)
-      if saysNotAMember(state, nme.unapply) then notAnExtractor(tree)
+      if saysNotFound(state, nme.unapply) then notAnExtractor(tree)
       else
         state.reporter.flush()
         tree
@@ -1154,7 +1159,7 @@ trait Applications extends Compatibility {
             (sel2, state2) =>
               // if both fail, return unapply error, unless that is simply a
               // "not a member", and the unapplySeq error is more refined.
-              if saysNotAMember(state, nme.unapply) && !saysNotAMember(state2, nme.unapplySeq)
+              if saysNotFound(state, nme.unapply) && !saysNotFound(state2, nme.unapplySeq)
               then fallBack(sel2, state2)
               else fallBack(sel, state)
           }

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

@@ -104,7 +104,8 @@ class ReTyper extends Typer with ReChecking {
     fallBack
 
   override def tryNew[T >: Untyped <: Type]
-    (treesInst: Instance[T])(tree: Trees.Tree[T], pt: Type, fallBack: => Tree)(implicit ctx: Context): Tree = fallBack
+    (treesInst: Instance[T])(tree: Trees.Tree[T], pt: Type, fallBack: TyperState => Tree)(implicit ctx: Context): Tree =
+      fallBack(ctx.typerState)
 
   override def completeAnnotations(mdef: untpd.MemberDef, sym: Symbol)(implicit ctx: Context): Unit = ()
 

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

@@ -2466,7 +2466,7 @@ class Typer extends Namer
    *  is more efficient since it re-uses the prefix `p` in typed form.
    */
   def tryNew[T >: Untyped <: Type]
-    (treesInst: Instance[T])(tree: Trees.Tree[T], pt: Type, fallBack: => Tree)(implicit ctx: Context): Tree = {
+    (treesInst: Instance[T])(tree: Trees.Tree[T], pt: Type, fallBack: TyperState => Tree)(implicit ctx: Context): Tree = {
 
     def tryWithType(tpt: untpd.Tree): Tree =
       tryEither {
@@ -2486,7 +2486,7 @@ class Typer extends Namer
             .reporting(i"try new $tree -> $result", typr)
         }
       } { (nu, nuState) =>
-        if (nu.isEmpty) fallBack
+        if (nu.isEmpty) fallBack(nuState)
         else {
           // we found a type constructor, signal the error in its application instead of the original one
           nuState.commit()
@@ -2504,7 +2504,7 @@ class Typer extends Namer
         }
         tryWithType(cpy.Select(tree)(qual1, name.toTypeName))
       case _ =>
-        fallBack
+        fallBack(ctx.typerState)
     }
   }
 
@@ -2550,7 +2550,7 @@ class Typer extends Namer
 
     def tryImplicit(fallBack: => Tree) =
       tryInsertImplicitOnQualifier(tree, pt.withContext(ctx), locked)
-        .getOrElse(tryNew(tpd)(tree, pt, fallBack))
+        .getOrElse(tryNew(tpd)(tree, pt, _ => fallBack))
 
     if (ctx.mode.is(Mode.SynthesizeExtMethodReceiver))
       // Suppress insertion of apply or implicit conversion on extension method receiver

tests/neg/i8569.check

@@ -0,0 +1,8 @@
+-- Error: tests/neg/i8569.scala:8:2 ------------------------------------------------------------------------------------
+8 |  outer.Inner(2) // error
+  |  ^^^^^
+  |  (Test.outer : => Outer) is not a valid path
+-- Error: tests/neg/i8569.scala:9:6 ------------------------------------------------------------------------------------
+9 |  new outer.Inner(2) // error
+  |      ^^^^^
+  |      (Test.outer : => Outer) is not a valid path

tests/neg/i8569.scala

@@ -0,0 +1,10 @@
+class Outer(x: Int) {
+  class Inner(y: Int) {
+  }
+}
+object Test {
+  def outer = Outer(1)
+
+  outer.Inner(2) // error
+  new outer.Inner(2) // error
+}