Fix #2412: Local error causes spurious errors to be reported

`FunProto#typedArgs` was using the implicit Context from the `FunProto`
constructor, and thus errors weren't stored in the proper context.
This is fixed by passing an implicit Context argument to
`typedArgs` (this was already done for `typedArg`), this means that we
no longer need to store a Context in the class, on the other hand there
are some new difficulties:
- `FunProto#typedArgs` can only be safely called from a point where the
  implicit Context contains the Context where the `FunProto` instance was
  created in its owner chain. This is usually the case but required some
  changes to Implicits (done in the previous commit)
- The Context used must be created with Context#thisCallArgContext when
  typing the arguments of a this(...) constructor call. This requires
  passing storing this information in FunProto. This wouldn't be necessary
  if we could simply type the whole this(...) Apply node with
  Context#thisCallArgContext, unfortunately this does not work since this
  Context does not have the constructors of the class in scope, and I did
  not figure out a way to construct a Context that would have them in
  scope without having the other methods of the class in scope.

Author: smarter

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

@@ -438,7 +438,7 @@ object Contexts {
     override def toString = {
       def iinfo(implicit ctx: Context) = if (ctx.importInfo == null) "" else i"${ctx.importInfo.selectors}%, %"
       "Context(\n" +
-      (outersIterator map ( ctx => s"  owner = ${ctx.owner}, scope = ${ctx.scope}, import = ${iinfo(ctx)}") mkString "\n")
+      (outersIterator map ( ctx => s"  owner = ${ctx.owner}, scope = ${if (ctx.scope != null) ctx.scope.toList(ctx) else null}, import = ${iinfo(ctx)}") mkString "\n")
     }
   }
 

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -178,7 +178,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
            ": " ~ toText(tp.memberProto) ~ " }"
       case tp: ViewProto =>
         return toText(tp.argType) ~ " ?=>? " ~ toText(tp.resultType)
-      case tp @ FunProto(args, resultType, _) =>
+      case tp @ FunProto(args, resultType, _, _) =>
         val argsText = args match {
           case dummyTreeOfType(tp) :: Nil if !(tp isRef defn.NullClass) => "null: " ~ toText(tp)
           case _ => toTextGlobal(args, ", ")

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

@@ -478,7 +478,7 @@ object Erasure {
       val Apply(fun, args) = tree
       if (fun.symbol == defn.cbnArg)
         typedUnadapted(args.head, pt)
-      else typedExpr(fun, FunProto(args, pt, this)) match {
+      else typedExpr(fun, FunProto(args, pt, this, untpd.isSelfConstrCall(tree))) match {
         case fun1: Apply => // arguments passed in prototype were already passed
           fun1
         case fun1 =>

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

@@ -672,7 +672,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
   def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = {
 
     def realApply(implicit ctx: Context): Tree = track("realApply") {
-      val originalProto = new FunProto(tree.args, IgnoredProto(pt), this)(argCtx(tree))
+      val originalProto = new FunProto(tree.args, IgnoredProto(pt), this, untpd.isSelfConstrCall(tree))
       val fun1 = typedExpr(tree.fun, originalProto)
 
       // Warning: The following lines are dirty and fragile. We record that auto-tupling was demanded as
@@ -690,7 +690,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       // help sharpen the inferred parameter types for the argument function literal(s).
       // This tweak is needed to make i1378 compile.
       if (tree.args.exists(untpd.isFunctionWithUnknownParamType(_)))
-        if (!constrainResult(fun1.tpe.widen, proto.derivedFunProto(resultType = pt)))
+        if (!constrainResult(fun1.tpe.widen, proto.derivedFunProto(resType = pt)))
           typr.println(i"result failure for $tree with type ${fun1.tpe.widen}, expected = $pt")
 
       /** Type application where arguments come from prototype, and no implicits are inserted */
@@ -701,7 +701,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
               if (proto.allArgTypesAreCurrent())
                 new ApplyToTyped(tree, fun1, funRef, proto.typedArgs, pt)
               else
-                new ApplyToUntyped(tree, fun1, funRef, proto, pt)(argCtx(tree))
+                new ApplyToUntyped(tree, fun1, funRef, proto, pt)
             convertNewGenericArray(ConstFold(app.result))
           case _ =>
             handleUnexpectedFunType(tree, fun1)
@@ -1317,7 +1317,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       alts filter (isApplicable(_, argTypes, resultType))
 
     val candidates = pt match {
-      case pt @ FunProto(args, resultType, _) =>
+      case pt @ FunProto(args, resultType, _, _) =>
         val numArgs = args.length
         val normArgs = args.mapConserve {
           case Block(Nil, expr) => expr
@@ -1370,7 +1370,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           if (isDetermined(alts2)) alts2
           else {
             pretypeArgs(alts2, pt)
-            narrowByTrees(alts2, pt.typedArgs, resultType)
+            narrowByTrees(alts2, pt.typedArgs(ctx.addMode(Mode.ImplicitsEnabled)), resultType)
           }
         }
 

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

@@ -757,7 +757,7 @@ trait Implicits { self: Typer =>
 
     lazy val funProto = fullProto match {
       case proto: ViewProto =>
-        FunProto(untpd.TypedSplice(dummyTreeOfType(proto.argType)) :: Nil, proto.resultType, self)
+        FunProto(untpd.TypedSplice(dummyTreeOfType(proto.argType)) :: Nil, proto.resultType, self, isSelfConstrCall = false)
       case proto => proto
     }
 

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

@@ -171,8 +171,10 @@ object ProtoTypes {
   /** A prototype for expressions that appear in function position
    *
    *  [](args): resultType
+   *
+   *  @param isSelfConstrCall  True for prototypes of `this(...)` constructor calls
    */
-  case class FunProto(args: List[untpd.Tree], resType: Type, typer: Typer)(implicit ctx: Context)
+  case class FunProto(args: List[untpd.Tree], resType: Type, typer: Typer, isSelfConstrCall: Boolean)
   extends UncachedGroundType with ApplyingProto {
     private var myTypedArgs: List[Tree] = Nil
 
@@ -184,15 +186,28 @@ object ProtoTypes {
     /** A map recording the typer states in which arguments stored in myTypedArg were typed */
     private var evalState: SimpleMap[untpd.Tree, TyperState] = SimpleMap.Empty
 
-    def isMatchedBy(tp: Type)(implicit ctx: Context) =
+    private[this] var thisCallArgCtxUsed: Boolean = false
+
+    /** Evalute `op` with the proper context to type the arguments. */
+    protected def withArgCtx[T](op: Context => T)(implicit ctx: Context) = {
+      if (isSelfConstrCall && !thisCallArgCtxUsed) {
+        // Context#thisCallArgContext is not idempotent so we must only use it
+        // once even with nested calls to withArgCtx
+        thisCallArgCtxUsed = true
+        try op(ctx.thisCallArgContext)
+        finally thisCallArgCtxUsed = false
+      } else op(ctx)
+    }
+
+    def isMatchedBy(tp: Type)(implicit ctx: Context) = withArgCtx { implicit ctx =>
       typer.isApplicable(tp, Nil, typedArgs, resultType)
+    }
 
-    def derivedFunProto(args: List[untpd.Tree] = this.args, resultType: Type, typer: Typer = this.typer) =
-      if ((args eq this.args) && (resultType eq this.resultType) && (typer eq this.typer)) this
-      else new FunProto(args, resultType, typer)
+    def derivedFunProto(args: List[untpd.Tree] = this.args, resType: Type, typer: Typer = this.typer) =
+      if ((args eq this.args) && (resType eq this.resType) && (typer eq this.typer)) this
+      else new FunProto(args, resType, typer, isSelfConstrCall)
 
     override def notApplied = WildcardType
-
     /** Forget the types of any arguments that have been typed producing a constraint in a
      *  typer state that is not yet committed into the one of the current context `ctx`.
      *  This is necessary to avoid "orphan" TypeParamRefs that are referred to from
@@ -226,7 +241,7 @@ object ProtoTypes {
     /** The typed arguments. This takes any arguments already typed using
      *  `typedArg` into account.
      */
-    def typedArgs: List[Tree] = {
+    def typedArgs(implicit ctx: Context): List[Tree] = withArgCtx { implicit ctx =>
       if (myTypedArgs.size != args.length)
         myTypedArgs = args.mapconserve(cacheTypedArg(_, typer.typed(_)))
       myTypedArgs
@@ -235,7 +250,7 @@ object ProtoTypes {
     /** Type single argument and remember the unadapted result in `myTypedArg`.
      *  used to avoid repeated typings of trees when backtracking.
      */
-    def typedArg(arg: untpd.Tree, formal: Type)(implicit ctx: Context): Tree = {
+    def typedArg(arg: untpd.Tree, formal: Type)(implicit ctx: Context): Tree = withArgCtx { implicit ctx =>
       val targ = cacheTypedArg(arg, typer.typedUnadapted(_, formal))
       typer.adapt(targ, formal)
     }
@@ -253,7 +268,7 @@ object ProtoTypes {
       case pt: FunProto =>
         pt
       case _ =>
-        myTupled = new FunProto(untpd.Tuple(args) :: Nil, resultType, typer)
+        myTupled = new FunProto(untpd.Tuple(args) :: Nil, resType, typer, isSelfConstrCall)
         tupled
     }
 
@@ -276,7 +291,7 @@ object ProtoTypes {
 
     def isDropped: Boolean = toDrop
 
-    override def toString = s"FunProto(${args mkString ","} => $resultType)"
+    override def toString = s"FunProto(${args mkString ","} => $resType)"
 
     def map(tm: TypeMap)(implicit ctx: Context): FunProto =
       derivedFunProto(args, tm(resultType), typer)
@@ -292,8 +307,10 @@ object ProtoTypes {
    *
    *  [](args): resultType, where args are known to be typed
    */
-  class FunProtoTyped(args: List[tpd.Tree], resultType: Type, typer: Typer)(implicit ctx: Context) extends FunProto(args, resultType, typer)(ctx) {
-    override def typedArgs = args
+  class FunProtoTyped(args: List[tpd.Tree], resultType: Type, typer: Typer)
+  // args are already typed so no need to set isSelfConstrCall
+  extends FunProto(args, resultType, typer, isSelfConstrCall = false) {
+    override def typedArgs(implicit ctx: Context) = args
   }
 
   /** A prototype for implicitly inferred views:
@@ -330,7 +347,7 @@ object ProtoTypes {
   }
 
   class UnapplyFunProto(argType: Type, typer: Typer)(implicit ctx: Context) extends FunProto(
-    untpd.TypedSplice(dummyTreeOfType(argType))(ctx) :: Nil, WildcardType, typer)
+    untpd.TypedSplice(dummyTreeOfType(argType))(ctx) :: Nil, WildcardType, typer, isSelfConstrCall = false)
 
   /** A prototype for expressions [] that are type-parameterized:
    *

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

@@ -772,7 +772,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
                 expr1.tpe
               case _ =>
                 val protoArgs = args map (_ withType WildcardType)
-                val callProto = FunProto(protoArgs, WildcardType, this)
+                val callProto = FunProto(protoArgs, WildcardType, this, isSelfConstrCall = false)
                 val expr1 = typedExpr(expr, callProto)
                 fnBody = cpy.Apply(fnBody)(untpd.TypedSplice(expr1), args)
                 expr1.tpe
@@ -1822,7 +1822,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       tryInsertImplicitOnQualifier(tree, pt).getOrElse(fallBack)
 
     pt match {
-      case pt @ FunProto(Nil, _, _)
+      case pt @ FunProto(Nil, _, _, _)
       if tree.symbol.allOverriddenSymbols.exists(_.info.isNullaryMethod) =>
         pt.markAsDropped()
         tree

tests/neg/i2412.scala

@@ -0,0 +1,8 @@
+object Test {
+  def test(foo: List[String]): Unit = {
+    foo.filter(f => {
+      iDontExist // error: not found
+      true
+    })
+  }
+}