Fix #1503 - be careful where to insert an apply.

`apply` nodes should not be inserted in the result parts
of a block, if-then-else, match, or try. Instead they should
be added to the surrounding statement.

Author: odersky

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

@@ -927,15 +927,25 @@ object Types {
     def narrow(implicit ctx: Context): TermRef =
       TermRef(NoPrefix, ctx.newSkolem(this))
 
-    /** Useful for diagnsotics: The underlying type if this type is a type proxy,
+   /** Useful for diagnsotics: The underlying type if this type is a type proxy,
      *  otherwise NoType
      */
     def underlyingIfProxy(implicit ctx: Context) = this match {
       case this1: TypeProxy => this1.underlying
       case _ => NoType
     }
 
-    // ----- Normalizing typerefs over refined types ----------------------------
+    /** A "weak" prototype is a FunProto or a PolyProto that applies to a tree
+     *  properly containing the current expression. In that case, we should not
+     *  try to insert an apply to make a tree conform. The apply should be inserted
+     *  on the enclosing tree that is the function part of the actual application.
+     */
+    def isWeakProto: Boolean = false
+
+	/** Overridden in FunProto and PolyProto */
+    def weakenProto: Type = this
+
+     // ----- Normalizing typerefs over refined types ----------------------------
 
     /** If this normalizes* to a refinement type that has a refinement for `name` (which might be followed
      *  by other refinements), and the refined info is a type alias, return the alias,

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

@@ -140,7 +140,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, ", ")

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

@@ -652,7 +652,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 
   /** Overridden in ReTyper to handle primitive operations that can be generated after erasure */
   protected def handleUnexpectedFunType(tree: untpd.Apply, fun: Tree)(implicit ctx: Context): Tree =
-    throw new Error(s"unexpected type.\n fun = $fun,\n methPart(fun) = ${methPart(fun)},\n methPart(fun).tpe = ${methPart(fun).tpe},\n tpe = ${fun.tpe}")
+    throw new Error(i"unexpected type.\n fun = $fun,\n methPart(fun) = ${methPart(fun)},\n methPart(fun).tpe = ${methPart(fun).tpe},\n tpe = ${fun.tpe}")
 
   def typedNamedArgs(args: List[untpd.Tree])(implicit ctx: Context) =
     for (arg @ NamedArg(id, argtpt) <- args) yield {
@@ -1168,7 +1168,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
@@ -1225,7 +1225,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           }
         }
 
-      case pt @ PolyProto(targs1, pt1) =>
+      case pt @ PolyProto(targs1, pt1, _) =>
         assert(targs.isEmpty)
         val alts1 = alts filter pt.isMatchedBy
         resolveOverloaded(alts1, pt1, targs1)

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

@@ -163,7 +163,8 @@ object ProtoTypes {
    *
    *  [](args): resultType
    */
-  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,
+                      override val isWeakProto: Boolean = false)(implicit ctx: Context)
   extends UncachedGroundType with ApplyingProto {
     private var myTypedArgs: List[Tree] = Nil
 
@@ -182,6 +183,9 @@ object ProtoTypes {
       if ((args eq this.args) && (resultType eq this.resultType) && (typer eq this.typer)) this
       else new FunProto(args, resultType, typer)
 
+    override def weakenProto =
+      if (isWeakProto) this else new FunProto(args, resultType, typer, isWeakProto = true)
+
     /** 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" PolyParams that are referred to from
@@ -243,7 +247,10 @@ object ProtoTypes {
     /** Somebody called the `tupled` method of this prototype */
     def isTupled: Boolean = myTupled.isInstanceOf[FunProto]
 
-    override def toString = s"FunProto(${args mkString ","} => $resultType)"
+    override def toString = {
+      val weak  = if (isWeakProto) "/weak" else ""
+      s"FunProto(${args mkString ","} => $resultType$weak)"
+    }
 
     def map(tm: TypeMap)(implicit ctx: Context): FunProto =
       derivedFunProto(args, tm(resultType), typer)
@@ -303,7 +310,8 @@ object ProtoTypes {
    *
    *    [] [targs] resultType
    */
-  case class PolyProto(targs: List[Type], resType: Type) extends UncachedGroundType with ProtoType {
+  case class PolyProto(targs: List[Type], resType: Type, override val isWeakProto: Boolean = false)
+  extends UncachedGroundType with ProtoType {
 
     override def resultType(implicit ctx: Context) = resType
 
@@ -319,6 +327,9 @@ object ProtoTypes {
       if ((targs eq this.targs) && (resType eq this.resType)) this
       else PolyProto(targs, resType)
 
+    override def weakenProto =
+      if (isWeakProto) this else new PolyProto(targs, resType, isWeakProto = true)
+
     def map(tm: TypeMap)(implicit ctx: Context): PolyProto =
       derivedPolyProto(targs mapConserve tm, tm(resultType))
 

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

@@ -572,7 +572,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context) = track("typedBlock") {
     val exprCtx = index(tree.stats)
     val stats1 = typedStats(tree.stats, ctx.owner)
-    val expr1 = typedExpr(tree.expr, pt)(exprCtx)
+    val expr1 = typedExpr(tree.expr, pt.weakenProto)(exprCtx)
     ensureNoLocalRefs(
         assignType(cpy.Block(tree)(stats1, expr1), stats1, expr1), pt, localSyms(stats1))
   }
@@ -619,8 +619,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context) = track("typedIf") {
     val cond1 = typed(tree.cond, defn.BooleanType)
-    val thenp1 = typed(tree.thenp, pt)
-    val elsep1 = typed(tree.elsep orElse (untpd.unitLiteral withPos tree.pos), pt)
+    val thenp1 = typed(tree.thenp, pt.weakenProto)
+    val elsep1 = typed(tree.elsep orElse (untpd.unitLiteral withPos tree.pos), pt.weakenProto)
     val thenp2 :: elsep2 :: Nil = harmonize(thenp1 :: elsep1 :: Nil)
     assignType(cpy.If(tree)(cond1, thenp2, elsep2), thenp2, elsep2)
   }
@@ -793,7 +793,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         val selType = widenForMatchSelector(
             fullyDefinedType(sel1.tpe, "pattern selector", tree.pos))
 
-        val cases1 = typedCases(tree.cases, selType, pt)
+        val cases1 = typedCases(tree.cases, selType, pt.weakenProto)
         val cases2 = harmonize(cases1).asInstanceOf[List[CaseDef]]
         assignType(cpy.Match(tree)(sel1, cases2), cases2)
     }
@@ -920,8 +920,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context): Try = track("typedTry") {
-    val expr1 = typed(tree.expr, pt)
-    val cases1 = typedCases(tree.cases, defn.ThrowableType, pt)
+    val expr1 = typed(tree.expr, pt.weakenProto)
+    val cases1 = typedCases(tree.cases, defn.ThrowableType, pt.weakenProto)
     val finalizer1 = typed(tree.finalizer, defn.UnitType)
     val expr2 :: cases2x = harmonize(expr1 :: cases1)
     val cases2 = cases2x.asInstanceOf[List[CaseDef]]
@@ -1525,18 +1525,24 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
    *  2nd strategy: If tree is a select `qual.name`, try to insert an implicit conversion
    *    around the qualifier part `qual` so that the result conforms to the expected type
    *    with wildcard result type.
+   *
+   *  If `pt` is a weak prototype, only try to insert the implicit on qualifier. If that
+   *  fails, succeed anyway with the idea that the `apply` can still be inserted further out.
+   *  where the actual application is. 
    */
   def tryInsertApplyOrImplicit(tree: Tree, pt: ProtoType)(fallBack: (Tree, TyperState) => Tree)(implicit ctx: Context): Tree =
-    tryEither { implicit ctx =>
-      val sel = typedSelect(untpd.Select(untpd.TypedSplice(tree), nme.apply), pt)
-      if (sel.tpe.isError) sel else adapt(sel, pt)
-    } { (failedTree, failedState) =>
-      tryInsertImplicitOnQualifier(tree, pt).getOrElse(fallBack(failedTree, failedState))
-    }
+    if (pt.isWeakProto)
+      tryInsertImplicitOnQualifier(tree, pt).getOrElse(tree)
+    else
+      tryEither { implicit ctx =>
+        val sel = typedSelect(untpd.Select(untpd.TypedSplice(tree), nme.apply), pt)
+        if (sel.tpe.isError) sel else adapt(sel, pt)
+      } { (failedTree, failedState) =>
+        tryInsertImplicitOnQualifier(tree, pt).getOrElse(fallBack(failedTree, failedState))
+      }
 
   /** If this tree is a select node `qual.name`, try to insert an implicit conversion
-   *  `c` around `qual` so that `c(qual).name` conforms to `pt`. If that fails
-   *  return `tree` itself.
+   *  `c` around `qual` so that `c(qual).name` conforms to `pt`.
    */
   def tryInsertImplicitOnQualifier(tree: Tree, pt: Type)(implicit ctx: Context): Option[Tree] = ctx.traceIndented(i"try insert impl on qualifier $tree $pt") {
     tree match {