Add fallback E -> new E if typing an applied function fails

Author: odersky

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

@@ -7,9 +7,11 @@ import Contexts._
 import util.{SimpleIdentityMap, SimpleIdentitySet}
 import reporting._
 import config.Config
+import config.Printers.constr
 import collection.mutable
 import java.lang.ref.WeakReference
 import util.Stats
+import Decorators._
 
 import scala.annotation.internal.sharable
 
@@ -143,6 +145,8 @@ class TyperState(private val previous: TyperState /* | Null */) {
   def commit()(implicit ctx: Context): Unit = {
     Stats.record("typerState.commit")
     val targetState = ctx.typerState
+   	if (constraint ne targetState.constraint)
+      constr.println(i"committing $this to $targetState, fromConstr = $constraint, toConstr = ${targetState.constraint}")
     assert(isCommittable)
     if (targetState.constraint eq previousConstraint) targetState.constraint = constraint
     else targetState.mergeConstraintWith(this)

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

@@ -214,7 +214,7 @@ object Applications {
    */
   class ExtMethodApply(app: Tree)(implicit @constructorOnly src: SourceFile)
   extends IntegratedTypeArgs(app)
-  
+
   /** 1. If we are in an inline method but not in a nested quote, mark the inline method
    *  as a macro.
    *
@@ -803,6 +803,29 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     if (ctx.owner.isClassConstructor && untpd.isSelfConstrCall(app)) ctx.thisCallArgContext
     else ctx
 
+  /** Typecheck the function part of an application.
+   *  Fallback if this fails: try to convert `E` to `new E`.
+   */
+  def typedFunPart(fn: untpd.Tree, pt: Type)(implicit ctx: Context): Tree =
+    tryEither { implicit ctx =>
+      typedExpr(fn, pt)
+    } { (result, tstate) =>
+      def fallBack = {
+        tstate.commit()
+        result
+      }
+      fn match {
+        case Ident(name) =>
+          tryNewWithType(cpy.Ident(fn)(name.toTypeName), pt, fallBack)
+        case Select(qual, name) =>
+          tryNewWithType(cpy.Select(fn)(qual, name.toTypeName), pt, fallBack)
+            // TODO: try to keep as much as possible from typed `qual` in order to avoid
+            // combinatorial explosion
+        case _ =>
+          fallBack
+      }
+    }
+
   /** Typecheck application. Result could be an `Apply` node,
    *  or, if application is an operator assignment, also an `Assign` or
    *  Block node.
@@ -812,7 +835,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     def realApply(implicit ctx: Context): Tree = track("realApply") {
       val originalProto = new FunProto(tree.args, IgnoredProto(pt))(this, tree.isContextual)(argCtx(tree))
       record("typedApply")
-      val fun1 = typedExpr(tree.fun, originalProto)
+      val fun1 = typedFunPart(tree.fun, originalProto)
 
       // Warning: The following lines are dirty and fragile. We record that auto-tupling was demanded as
       // a side effect in adapt. If it was, we assume the tupled proto-type in the rest of the application,
@@ -947,7 +970,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     val isNamed = hasNamedArg(tree.args)
     val typedArgs = if (isNamed) typedNamedArgs(tree.args) else tree.args.mapconserve(typedType(_))
     record("typedTypeApply")
-    handleMeta(typedExpr(tree.fun, PolyProto(typedArgs, pt)) match {
+    handleMeta(typedFunPart(tree.fun, PolyProto(typedArgs, pt)) match {
       case IntegratedTypeArgs(app) =>
         app
       case _: TypeApply if !ctx.isAfterTyper =>

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

@@ -64,6 +64,9 @@ class ReTyper extends Typer with ReChecking {
   override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(implicit ctx: Context): TypeTree =
     promote(tree)
 
+  override def typedFunPart(fn: untpd.Tree, pt: Type)(implicit ctx: Context): Tree =
+    typedExpr(fn, pt)
+
   override def typedBind(tree: untpd.Bind, pt: Type)(implicit ctx: Context): Bind = {
     assertTyped(tree)
     val body1 = typed(tree.body, pt)
@@ -93,6 +96,8 @@ class ReTyper extends Typer with ReChecking {
   override def tryInsertApplyOrImplicit(tree: Tree, pt: ProtoType, locked: TypeVars)(fallBack: => Tree)(implicit ctx: Context): Tree =
     fallBack
 
+  override def tryNewWithType(tpt: untpd.Tree, pt: Type, fallBack: => Tree)(implicit ctx: Context): Tree = fallBack
+
   override def completeAnnotations(mdef: untpd.MemberDef, sym: Symbol)(implicit ctx: Context): Unit = ()
 
   override def ensureConstrCall(cls: ClassSymbol, parents: List[Tree])(implicit ctx: Context): List[Tree] =

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

@@ -2232,6 +2232,24 @@ class Typer extends Namer
     case _                  => false
   }
 
+  /** Try to rename `tpt` to a type `T` and typecheck `new T` with given expected type `pt`.
+   */
+  def tryNewWithType(tpt: untpd.Tree, pt: Type, fallBack: => Tree)(implicit ctx: Context): Tree =
+    tryEither { implicit ctx =>
+      val tycon = typed(tpt)
+      if (ctx.reporter.hasErrors)
+        EmptyTree // signal that we should return the error in fallBack
+      else
+        typed(untpd.Select(untpd.New(untpd.TypedSplice(tycon)), nme.CONSTRUCTOR), pt)
+    } { (nu, nuState) =>
+      if (nu.isEmpty) fallBack
+      else {
+        // we found a type constructor, signal the error in its application instead of the original one
+        nuState.commit()
+        nu
+      }
+    }
+
   /** Potentially add apply node or implicit conversions. Before trying either,
    *  if the function is applied to an empty parameter list (), we try
    *
@@ -2273,28 +2291,11 @@ class Typer extends Namer
     }
 
     def tryNew(fallBack: => Tree): Tree = {
-
-      def tryNewWithType(tpt: untpd.Tree): Tree =
-        tryEither { implicit ctx =>
-          val tycon = typed(tpt.withSpan(tree.span))
-          if (ctx.reporter.hasErrors)
-            EmptyTree // signal that we should return the error in fallBack
-          else
-            typed(untpd.Select(untpd.New(untpd.TypedSplice(tycon)), nme.CONSTRUCTOR), pt)
-        } { (nu, nuState) =>
-          if (nu.isEmpty) fallBack
-          else {
-            // we found a type constructor, signal the error in its application instead of the original one
-            nuState.commit()
-            nu
-          }
-        }
-
       tree match {
         case Ident(name) =>
-          tryNewWithType(untpd.Ident(name.toTypeName))
+          tryNewWithType(cpy.Ident(tree)(name.toTypeName), pt, fallBack)
         case Select(qual, name) =>
-          tryNewWithType(untpd.Select(untpd.TypedSplice(qual), name.toTypeName))
+          tryNewWithType(cpy.Select(tree)(untpd.TypedSplice(qual), name.toTypeName), pt, fallBack)
         case _ =>
           fallBack
       }

tests/neg/i1648.scala

@@ -1 +1 @@
-class Foo { Object[A] } // error // error
+class Foo { Object[A] } // error

tests/neg/i1907.scala

@@ -3,5 +3,5 @@ import java.io.File
 object Test {
   Some(new File("."))
     .map(_.listFiles).getOrElse(Array.empty) // error: undetermined ClassTag
-    .map(_.listFiles)
+    .map(_.listFiles) // error: missing parameter type
 }

tests/run/creator-applys.scala

@@ -37,7 +37,7 @@ object Test extends App {
   assert((x8: C[String, Int]).run == "C a 1")
 */
 }
-/*
+
 object Test2 {
   class A {
     def run = "A"
@@ -66,4 +66,4 @@ object Test2 {
 
   val x6 = C("a", 1)
   assert((x6: C[String, Int]).run == "C a 1")
-}*/
+}