Drop code for previous creator expression scheme

Author: odersky

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -8,11 +8,6 @@ object Config {
   inline val cacheImplicitScopes = true
   inline val cacheMatchReduced = true
 
-  /** If true, we implement creator expressions by adding constructor proxies.
-   *  If false, we rely on fallbacks in Typer to try a constructor if everything else failed.
-   */
-  inline val addConstructorProxies = true
-
   /** If true, the `runWithOwner` operation uses a re-usable context,
    *  similar to explore. This requires that the context does not escape
    *  the call. If false, `runWithOwner` runs its operation argument

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

@@ -300,19 +300,10 @@ class Definitions {
     cls.info = ClassInfo(cls.owner.thisType, cls, List(AnyType, MatchableType), newScope)
     cls.setFlag(NoInits | JavaDefined)
 
-    if config.Config.addConstructorProxies then
-      ensureConstructor(cls, cls.denot.asClass, EmptyScope)
-      val companion = JavaLangPackageVal.info.decl(nme.Object).symbol.asTerm
-      NamerOps.makeConstructorCompanion(companion, cls)
-      cls
-    else
-      // The companion object doesn't really exist, so it needs to be marked as
-      // absent. Here we need to set it before completing attempt to load Object's
-      // classfile, which causes issue #1648.
-      val companion = JavaLangPackageVal.info.decl(nme.Object).symbol
-      companion.moduleClass.markAbsent()
-      companion.markAbsent()
-      completeClass(cls)
+    ensureConstructor(cls, cls.denot.asClass, EmptyScope)
+    val companion = JavaLangPackageVal.info.decl(nme.Object).symbol.asTerm
+    NamerOps.makeConstructorCompanion(companion, cls)
+    cls
   }
   def ObjectType: TypeRef = ObjectClass.typeRef
 

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

@@ -71,8 +71,7 @@ object NamerOps:
 
   /** Does symbol `cls` need constructor proxies to be generated? */
   def needsConstructorProxies(cls: Symbol)(using Context): Boolean =
-    Config.addConstructorProxies
-    && cls.isClass
+    cls.isClass
     && !cls.flagsUNSAFE.isOneOf(NoConstructorProxyNeededFlags)
     && !cls.isAnonymousClass
 
@@ -89,9 +88,8 @@ object NamerOps:
       newSymbol(
         modcls, nme.apply, ApplyProxyFlags | (constr.flagsUNSAFE & AccessFlags),
         ApplyProxyCompleter(constr), coord = constr.coord)
-    if Config.addConstructorProxies then
-      for dcl <- cls.info.decls do
-        if dcl.isConstructor then scope.enter(proxy(dcl))
+    for dcl <- cls.info.decls do
+      if dcl.isConstructor then scope.enter(proxy(dcl))
     scope
   end addConstructorApplies
 

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

@@ -844,24 +844,6 @@ trait Applications extends Compatibility {
     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)(using Context): Tree =
-    if Config.addConstructorProxies then typedExpr(fn, pt)
-    else
-      tryEither {
-        typedExpr(fn, pt)
-      } { (result, tstate) =>
-        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) then tryNew(untpd)(fn, pt, fallBack)
-        else fallBack(ctx.typerState)
-      }
-
   /** Typecheck application. Result could be an `Apply` node,
    *  or, if application is an operator assignment, also an `Assign` or
    *  Block node.
@@ -872,7 +854,7 @@ trait Applications extends Compatibility {
       val originalProto =
         new FunProto(tree.args, IgnoredProto(pt))(this, tree.applyKind)(using argCtx(tree))
       record("typedApply")
-      val fun1 = typedFunPart(tree.fun, originalProto)
+      val fun1 = typedExpr(tree.fun, originalProto)
 
       // Warning: The following lines are dirty and fragile.
       // We record that auto-tupling or untupling was demanded as a side effect in adapt.
@@ -1077,7 +1059,7 @@ trait Applications extends Compatibility {
     val isNamed = hasNamedArg(tree.args)
     val typedArgs = if (isNamed) typedNamedArgs(tree.args) else tree.args.mapconserve(typedType(_))
     record("typedTypeApply")
-    typedFunPart(tree.fun, PolyProto(typedArgs, pt)) match {
+    typedExpr(tree.fun, PolyProto(typedArgs, pt)) match {
       case IntegratedTypeArgs(app) =>
         app
       case _: TypeApply if !ctx.isAfterTyper =>

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

@@ -71,9 +71,6 @@ class ReTyper extends Typer with ReChecking {
   override def typedRefinedTypeTree(tree: untpd.RefinedTypeTree)(using Context): TypTree =
     promote(TypeTree(tree.tpe).withSpan(tree.span))
 
-  override def typedFunPart(fn: untpd.Tree, pt: Type)(using Context): Tree =
-    typedExpr(fn, pt)
-
   override def typedBind(tree: untpd.Bind, pt: Type)(using Context): Bind = {
     assertTyped(tree)
     val body1 = typed(tree.body, pt)
@@ -104,10 +101,6 @@ class ReTyper extends Typer with ReChecking {
   override def tryInsertApplyOrImplicit(tree: Tree, pt: ProtoType, locked: TypeVars)(fallBack: => Tree)(using Context): Tree =
     fallBack
 
-  override def tryNew[T >: Untyped <: Type]
-    (treesInst: Instance[T])(tree: Trees.Tree[T], pt: Type, fallBack: TyperState => Tree)(using Context): Tree =
-      fallBack(ctx.typerState)
-
   override def completeAnnotations(mdef: untpd.MemberDef, sym: Symbol)(using Context): Unit = ()
 
   override def ensureConstrCall(cls: ClassSymbol, parents: List[Tree])(using Context): List[Tree] =

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

@@ -2791,55 +2791,6 @@ class Typer extends Namer
     case _                  => false
   }
 
-  /** Try to rename `tpt` to a type `T` and typecheck `new T` with given expected type `pt`.
-   *  The operation is called from either `adapt` or `typedApply`. `adapt` gets to call `tryNew`
-   *  for calls `p.C(..)` if there is a value `p.C`. `typedApply` calls `tryNew` as a fallback
-   *  in case typing `p.C` fails since there is no value with path `p.C`. The call from `adapt`
-   *  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: TyperState => Tree)(using Context): Tree = {
-
-    def tryWithType(tpt: untpd.Tree): Tree =
-      tryEither {
-        val tycon = typed(tpt)
-        if (summon[Context].reporter.hasErrors)
-          EmptyTree // signal that we should return the error in fallBack
-        else {
-          def recur(tpt: Tree, pt: Type): Tree = pt.revealIgnored match {
-            case PolyProto(targs, pt1) if !targs.exists(_.isInstanceOf[NamedArg]) =>
-              // Applications with named arguments cannot be converted, since new expressions
-              // don't accept named arguments
-              IntegratedTypeArgs(recur(AppliedTypeTree(tpt, targs), pt1))
-            case _ =>
-              typed(untpd.Select(untpd.New(untpd.TypedSplice(tpt)), nme.CONSTRUCTOR), pt)
-          }
-          recur(tycon, pt)
-            .showing(i"try new $tree -> $result", typr)
-        }
-      } { (nu, nuState) =>
-        if (nu.isEmpty) fallBack(nuState)
-        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) =>
-        tryWithType(cpy.Ident(tree)(name.toTypeName))
-      case Select(qual, name) =>
-        val qual1 = treesInst match {
-          case `tpd` => untpd.TypedSplice(qual)
-          case `untpd` => qual
-        }
-        tryWithType(cpy.Select(tree)(qual1, name.toTypeName))
-      case _ =>
-        fallBack(ctx.typerState)
-    }
-  }
-
   /** Potentially add apply node or implicit conversions. Before trying either,
    *  if the function is applied to an empty parameter list (), we try
    *
@@ -2876,10 +2827,7 @@ class Typer extends Namer
     }
 
     def tryImplicit(fallBack: => Tree) =
-      tryInsertImplicitOnQualifier(tree, pt.withContext(ctx), locked)
-        .getOrElse(
-          if Config.addConstructorProxies then fallBack
-          else tryNew(tpd)(tree, pt, _ => fallBack))
+      tryInsertImplicitOnQualifier(tree, pt.withContext(ctx), locked).getOrElse(fallBack)
 
     if (ctx.mode.is(Mode.SynthesizeExtMethodReceiver))
       // Suppress insertion of apply or implicit conversion on extension method receiver
@@ -3651,10 +3599,8 @@ class Typer extends Namer
               adaptOverloaded(ref)
           }
         case poly: PolyType if !(ctx.mode is Mode.Type) =>
-          if tree.symbol.isAllOf(ApplyProxyFlags) && Config.addConstructorProxies then
-            newExpr
-          else if pt.isInstanceOf[PolyProto] then
-            tree
+          if tree.symbol.isAllOf(ApplyProxyFlags) then newExpr
+          else if pt.isInstanceOf[PolyProto] then tree
           else
             var typeArgs = tree match
               case Select(qual, nme.CONSTRUCTOR) => qual.tpe.widenDealias.argTypesLo.map(TypeTree)
@@ -3667,7 +3613,7 @@ class Typer extends Namer
             readaptSimplified(handleStructural(tree))
           else pt match {
             case pt: FunProto =>
-              if tree.symbol.isAllOf(ApplyProxyFlags) && Config.addConstructorProxies then newExpr
+              if tree.symbol.isAllOf(ApplyProxyFlags) then newExpr
               else adaptToArgs(wtp, pt)
             case pt: PolyProto =>
               tree match {