Make by-name types first-class value types

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -70,10 +70,10 @@ class Compiler {
          new ExpandSAMs) ::          // Expand single abstract method closures to anonymous classes
     List(new init.Checker) ::        // Check initialization of objects
     List(new ElimRepeated,           // Rewrite vararg parameters and arguments
+         new ByNameLambda,           // Replace by-name applications with closures
          new ProtectedAccessors,     // Add accessors for protected members
          new ExtensionMethods,       // Expand methods of value classes with extension methods
          new UncacheGivenAliases,    // Avoid caching RHS of simple parameterless given aliases
-         new ByNameClosures,         // Expand arguments to by-name parameters to closures
          new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope
          new SpecializeApplyMethods, // Adds specialized methods to FunctionN
          new RefChecks,              // Various checks mostly related to abstract members and overriding
@@ -83,7 +83,6 @@ class Compiler {
          new sjs.ExplicitJSClasses,  // Make all JS classes explicit (Scala.js only)
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
-         new ElimByName,             // Expand by-name parameter references
          new StringInterpolatorOpt) :: // Optimizes raw and s string interpolators by rewriting them to string concatenations
     List(new PruneErasedDefs,        // Drop erased definitions from scopes and simplify erased expressions
          new UninitializedDefs,      // Replaces `compiletime.uninitialized` by `_`

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -726,6 +726,14 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case _ => tree
   }
 
+  /** An anonyous function and a closure node referring to it in a block, without any wrappigs */
+  object simpleClosure:
+    def unapply(tree: Tree)(using Context): Option[(DefDef, Closure)] = tree match
+      case Block((meth : DefDef) :: Nil, closure: Closure) if meth.symbol == closure.meth.symbol =>
+        Some((meth, closure))
+      case _ =>
+        None
+
   /** The variables defined by a pattern, in reverse order of their appearance. */
   def patVars(tree: Tree)(using Context): List[Symbol] = {
     val acc = new TreeAccumulator[List[Symbol]] {

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -128,6 +128,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Closure(meth, tss => rhsFn(tss.head).changeOwner(ctx.owner, meth))
   }
 
+  /** A <byname>(...) application */
+  object ByName:
+    def apply(tree: Tree)(using Context): Apply =
+      Apply(ref(defn.byNameMethod), tree :: Nil)
+    def unapply(tree: Apply)(using Context): Option[Tree] =
+      if tree.fun.symbol == defn.byNameMethod then Some(tree.args.head)
+      else None
+
   def CaseDef(pat: Tree, guard: Tree, body: Tree)(using Context): CaseDef =
     ta.assignType(untpd.CaseDef(pat, guard, body), pat, body)
 
@@ -955,6 +963,26 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     def ensureApplied(using Context): Tree =
       if (tree.tpe.widen.isParameterless) tree else tree.appliedToNone
 
+    /** Is tree a by-name application `<byname>(arg)`? */
+    def isByName(using Context): Boolean = tree match
+      case Apply(fun, _) => fun.symbol == defn.byNameMethod
+      case _ => false
+
+    /** If tree is a by-name application `<byname>(arg)` return `arg`, otherwise the original tree */
+    def dropByName(using Context): Tree = tree match
+      case ByName(body) => body
+      case _ => tree
+
+    /** Wrap tree in a by-name application unless it is already one */
+    def wrapByName(using Context): Tree = tree match
+      case ByName(_) => tree
+      case _ => ByName(tree)
+
+    /** Make sure tree is by-name application if `formal` is a by-name parameter type */
+    def alignByName(formal: Type)(using Context) = formal match
+      case ByNameType(underlying) => wrapByName
+      case _ => tree
+
     /** `tree == that` */
     def equal(that: Tree)(using Context): Tree =
       if (that.tpe.widen.isRef(defn.NothingClass))
@@ -1108,7 +1136,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     def etaExpandCFT(using Context): Tree =
       def expand(target: Tree, tp: Type)(using Context): Tree = tp match
-        case defn.ContextFunctionType(argTypes, resType, isErased) =>
+        case defn.ContextFunctionType(argTypes, resType, isErased) if argTypes.nonEmpty =>
           val anonFun = newAnonFun(
             ctx.owner,
             MethodType.companion(isContextual = true, isErased = isErased)(argTypes, resType),

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

@@ -447,16 +447,14 @@ class Definitions {
   @tu lazy val andType: TypeSymbol = enterBinaryAlias(tpnme.AND, AndType(_, _))
   @tu lazy val orType: TypeSymbol = enterBinaryAlias(tpnme.OR, OrType(_, _, soft = false))
 
-  /** Marker method to indicate an argument to a call-by-name parameter.
-   *  Created by byNameClosures and elimByName, eliminated by Erasure,
-   */
-  @tu lazy val cbnArg: TermSymbol = enterPolyMethod(OpsPackageClass, nme.cbnArg, 1,
-      pt => MethodType(List(FunctionOf(Nil, pt.paramRefs(0))), pt.paramRefs(0)))
-
   /** Method representing a throw */
   @tu lazy val throwMethod: TermSymbol = enterMethod(OpsPackageClass, nme.THROWkw,
       MethodType(List(ThrowableType), NothingType))
 
+  /** Method wrapping by-name arguments; created by Typer, eliminated in ByNameLambda */
+  @tu lazy val byNameMethod: TermSymbol = enterMethod(OpsPackageClass, nme.BYNAME,
+      MethodType(List(AnyType))(mt => FunctionOf(Nil, mt.paramRefs(0), isContextual = true)))
+
   @tu lazy val NothingClass: ClassSymbol = enterCompleteClassSymbol(
     ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyType))
   def NothingType: TypeRef = NothingClass.typeRef
@@ -1081,6 +1079,9 @@ class Definitions {
     }
   }
 
+  final def isByNameClass(sym: Symbol): Boolean =
+    sym eq ContextFunction0
+
   final def isCompiletime_S(sym: Symbol)(using Context): Boolean =
     sym.name == tpnme.S && sym.owner == CompiletimeOpsIntModuleClass
 
@@ -1298,6 +1299,7 @@ class Definitions {
   @tu lazy val Function0: Symbol = FunctionClass(0)
   @tu lazy val Function1: Symbol = FunctionClass(1)
   @tu lazy val Function2: Symbol = FunctionClass(2)
+  @tu lazy val ContextFunction0: Symbol = FunctionClass(0, isContextual = true)
 
   def FunctionType(n: Int, isContextual: Boolean = false, isErased: Boolean = false)(using Context): TypeRef =
     FunctionClass(n, isContextual && !ctx.erasedTypes, isErased).typeRef
@@ -1544,7 +1546,8 @@ class Definitions {
     new PerRun(Function2SpecializedReturnTypes.map(_.symbol))
 
   def isSpecializableFunction(cls: ClassSymbol, paramTypes: List[Type], retType: Type)(using Context): Boolean =
-    paramTypes.length <= 2 && cls.derivesFrom(FunctionClass(paramTypes.length))
+    paramTypes.length <= 2
+    && (cls.derivesFrom(FunctionClass(paramTypes.length)) || isByNameClass(cls))
     && isSpecializableFunctionSAM(paramTypes, retType)
 
   /** If the Single Abstract Method of a Function class has this type, is it specializable? */
@@ -1809,7 +1812,7 @@ class Definitions {
 
   /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
   @tu lazy val syntheticCoreMethods: List[TermSymbol] =
-    AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
+    AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod, byNameMethod)
 
   @tu lazy val reservedScalaClassNames: Set[Name] = syntheticScalaClasses.map(_.name).toSet
 

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

@@ -111,7 +111,7 @@ object JavaNullInterop {
           // then its Scala signature will be `def setNames(names: (String|Null)*): Unit`.
           // This is because `setNames(null)` passes as argument a single-element array containing the value `null`,
           // and not a `null` array.
-          !tp.isRef(defn.RepeatedParamClass)
+          !tp.isRepeatedParam
         case _ => true
       })
 

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

@@ -119,6 +119,7 @@ object StdNames {
     val BITMAP_TRANSIENT: N           = s"${BITMAP_PREFIX}trans$$"    // initialization bitmap for transient lazy vals
     val BITMAP_CHECKINIT: N           = s"${BITMAP_PREFIX}init$$"      // initialization bitmap for checkinit values
     val BITMAP_CHECKINIT_TRANSIENT: N = s"${BITMAP_PREFIX}inittrans$$" // initialization bitmap for transient checkinit values
+    val BYNAME: N                     = "<byname>"
     val DEFAULT_GETTER: N             = str.DEFAULT_GETTER
     val DEFAULT_GETTER_INIT: N        = "$lessinit$greater"
     val DO_WHILE_PREFIX: N            = "doWhile$"
@@ -445,7 +446,6 @@ object StdNames {
     val bytes: N                = "bytes"
     val canEqual_ : N           = "canEqual"
     val canEqualAny : N         = "canEqualAny"
-    val cbnArg: N               = "<cbn-arg>"
     val checkInitialized: N     = "checkInitialized"
     val ClassManifestFactory: N = "ClassManifestFactory"
     val classOf: N              = "classOf"

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

@@ -412,11 +412,13 @@ class TypeApplications(val self: Type) extends AnyVal {
 
   /** Translate a type of the form From[T] to either To[T] or To[? <: T] (if `wildcardArg` is set). Keep other types as they are.
    *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
-   *  Do the same for by name types => From[T] and => To[T]
+   *  Do the same for ExprTypes and by-name types => From[T] and => To[T].
    */
   def translateParameterized(from: ClassSymbol, to: ClassSymbol, wildcardArg: Boolean = false)(using Context): Type = self match {
     case self @ ExprType(tp) =>
       self.derivedExprType(tp.translateParameterized(from, to))
+    case self @ ByNameType(tp) =>
+      self.derivedByNameType(tp.translateParameterized(from, to))
     case _ =>
       if (self.derivesFrom(from)) {
         def elemType(tp: Type): Type = tp.widenDealias match

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

@@ -2335,13 +2335,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       }
     case tp1: RecType =>
       tp1.rebind(distributeAnd(tp1.parent, tp2))
-    case ExprType(rt1) =>
-      tp2 match {
-        case ExprType(rt2) =>
-          ExprType(rt1 & rt2)
-        case _ =>
-          NoType
-      }
     case tp1: TypeVar if tp1.isInstantiated =>
       tp1.underlying & tp2
     case tp1: AnnotatedType if !tp1.isRefining =>
@@ -2359,13 +2352,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
    *  The rhs is a proper supertype of the lhs.
    */
   private def distributeOr(tp1: Type, tp2: Type, isSoft: Boolean = true): Type = tp1 match {
-    case ExprType(rt1) =>
-      tp2 match {
-        case ExprType(rt2) =>
-          ExprType(lub(rt1, rt2, isSoft = isSoft))
-        case _ =>
-          NoType
-      }
     case tp1: TypeVar if tp1.isInstantiated =>
       lub(tp1.underlying, tp2, isSoft = isSoft)
     case tp1: AnnotatedType if !tp1.isRefining =>

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

@@ -603,8 +603,6 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       this(tp.widen)
     case SuperType(thistpe, supertpe) =>
       SuperType(this(thistpe), this(supertpe))
-    case ExprType(rt) =>
-      defn.FunctionType(0)
     case RefinedType(parent, nme.apply, refinedInfo) if parent.typeSymbol eq defn.PolyFunctionClass =>
       erasePolyFunctionApply(refinedInfo)
     case tp: TypeProxy =>
@@ -692,7 +690,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
     else defn.TupleXXLClass.typeRef
   }
 
-  /** The erasure of a symbol's info. This is different from `apply` in the way `ExprType`s and
+  /** The erasure of a symbol's info. This is different from `apply` in the way
    *  `PolyType`s are treated. `eraseInfo` maps them them to method types, whereas `apply` maps them
    *  to the underlying type.
    */
@@ -702,14 +700,9 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       case _ => tp
     tp1 match
       case ExprType(rt) =>
-        if sym.is(Param) then apply(tp1)
-            // Note that params with ExprTypes are eliminated by ElimByName,
-            // but potentially re-introduced by ResolveSuper, when we add
-            // forwarders to mixin methods.
-            // See doc comment for ElimByName for speculation how we could improve this.
-        else
-          MethodType(Nil, Nil,
-            eraseResult(rt.translateFromRepeated(toArray = sourceLanguage.isJava)))
+        assert(!sym.is(Param))
+        MethodType(Nil, Nil,
+          eraseResult(rt.translateFromRepeated(toArray = sourceLanguage.isJava)))
       case tp1: PolyType =>
         eraseResult(tp1.resultType) match
           case rt: MethodType => rt
@@ -820,8 +813,6 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         sigName(elem) ++ "[]"
       case tp: TermRef =>
         sigName(tp.widen)
-      case ExprType(rt) =>
-        sigName(defn.FunctionOf(Nil, rt))
       case tp: TypeVar =>
         val inst = tp.instanceOpt
         if (inst.exists) sigName(inst) else tpnme.Uninstantiated

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

@@ -41,6 +41,10 @@ class MissingType(pre: Type, name: Name) extends TypeError {
   }
 }
 
+class InvalidPrefix(pre: Type, desig: Designator) extends TypeError:
+  override def produceMessage(using Context): Message =
+    i"malformed type: $pre is not a legal prefix for $desig"
+
 class RecursionOverflow(val op: String, details: => String, val previous: Throwable, val weight: Int) extends TypeError {
 
   def explanation: String = s"$op $details"