Represent by-name types => T as () ?=> T

Author: odersky

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

@@ -70,6 +70,7 @@ 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

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

@@ -457,6 +457,10 @@ class Definitions {
   @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 +1085,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 +1305,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
@@ -1809,7 +1817,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$"

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"

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

@@ -90,7 +90,7 @@ object Types {
    *
    *  Note: please keep in sync with copy in `docs/docs/internals/type-system.md`.
    */
-  abstract class Type extends Hashable with printing.Showable {
+  abstract class Type extends Hashable with printing.Showable:
 
 // ----- Tests -----------------------------------------------------
 
@@ -398,8 +398,10 @@ object Types {
       (new isGroundAccumulator).apply(true, this)
 
     /** Is this a type of a repeated parameter? */
-    def isRepeatedParam(using Context): Boolean =
-      typeSymbol eq defn.RepeatedParamClass
+    def isRepeatedParam(using Context): Boolean = this match
+      case ExprType(underlying) => underlying.isRepeatedParam
+      case ByNameType(underlying) => underlying.isRepeatedParam
+      case _ => typeSymbol eq defn.RepeatedParamClass
 
     /** Is this the type of a method that has a repeated parameter type as
      *  last parameter type?
@@ -1517,10 +1519,13 @@ object Types {
     }
 
     /** If this is a repeated type, its element type, otherwise the type itself */
-    def repeatedToSingle(using Context): Type = this match {
-      case tp @ ExprType(tp1) => tp.derivedExprType(tp1.repeatedToSingle)
-      case _                  => if (isRepeatedParam) this.argTypesHi.head else this
-    }
+    def repeatedToSingle(using Context): Type = this match
+      case tp @ ExprType(tp1) =>
+        tp.derivedExprType(tp1.repeatedToSingle)
+      case tp @ ByNameType(tp1) =>
+        tp.derivedByNameType(tp1.repeatedToSingle)
+      case _ =>
+        if (isRepeatedParam) this.argTypesHi.head else this
 
     // ----- Normalizing typerefs over refined types ----------------------------
 
@@ -1841,7 +1846,10 @@ object Types {
     def dropRepeatedAnnot(using Context): Type = dropAnnot(defn.RepeatedAnnot)
 
     def annotatedToRepeated(using Context): Type = this match {
-      case tp @ ExprType(tp1) => tp.derivedExprType(tp1.annotatedToRepeated)
+      case tp @ ExprType(tp1) =>
+        tp.derivedExprType(tp1.annotatedToRepeated)
+      case tp @ ByNameType(tp1) =>
+        tp.derivedByNameType(tp1.annotatedToRepeated)
       case AnnotatedType(tp, annot) if annot matches defn.RepeatedAnnot =>
         val typeSym = tp.typeSymbol.asClass
         assert(typeSym == defn.SeqClass || typeSym == defn.ArrayClass)
@@ -1916,9 +1924,8 @@ object Types {
 
     /** Is the `hash` of this type the same for all possible sequences of enclosing binders? */
     def hashIsStable: Boolean = true
-  }
 
-  // end Type
+  end Type
 
 // ----- Type categories ----------------------------------------------
 
@@ -2085,7 +2092,7 @@ object Types {
     def designator: Designator
     protected def designator_=(d: Designator): Unit
 
-    assert(prefix.isValueType || (prefix eq NoPrefix), s"invalid prefix $prefix")
+    if !prefix.isValueType && (prefix ne NoPrefix) then throw InvalidPrefix(prefix, designator)
 
     private var myName: Name = null
     private var lastDenotation: Denotation = null
@@ -5448,6 +5455,41 @@ object Types {
       else None
   }
 
+  // ----- ByName Param Type Encoding ------------------------------------------------
+
+  object ByNameType:
+    def apply(tp: Type)(using Context): Type =
+      defn.FunctionOf(Nil, tp, isContextual = true)
+    def unapply(tp: Type)(using Context): Option[Type] = tp match
+      case tp @ AppliedType(tycon, arg :: Nil) if defn.isByNameClass(tycon.typeSymbol) =>
+        Some(arg)
+      case tp @ AnnotatedType(parent, _) =>
+        unapply(parent)
+      case _ =>
+        None
+  end ByNameType
+
+  extension (tp: Type)
+    def isByName(using Context): Boolean = tp match
+      case tp @ AppliedType(tycon, arg :: Nil) =>
+        defn.isByNameClass(tycon.typeSymbol)
+      case tp @ AnnotatedType(parent, _) =>
+        parent.isByName
+      case _ =>
+        false
+
+    def derivedByNameType(arg: Type)(using Context): Type = tp match
+      case tp @ AppliedType(tycon, arg0 :: Nil) =>
+        assert(defn.isByNameClass(tycon.typeSymbol))
+        if arg0 eq arg then tp
+        else tp.derivedAppliedType(tycon, arg :: Nil)
+      case tp @ AnnotatedType(parent, annot) =>
+        tp.derivedAnnotatedType(parent.derivedByNameType(arg), annot)
+
+    def widenByName(using Context): Type = tp match
+      case ByNameType(underlying) => underlying
+      case _ => tp
+
   // ----- TypeMaps --------------------------------------------------------------------
 
   /** Where a traversal should stop */
@@ -6140,6 +6182,7 @@ object Types {
     }
   }
 
+  /** Type size as defined in implicit divergence checking */
   class TypeSizeAccumulator(using Context) extends TypeAccumulator[Int] {
     var seen = util.HashSet[Type](initialCapacity = 8)
     def apply(n: Int, tp: Type): Int =
@@ -6148,7 +6191,8 @@ object Types {
         seen += tp
         tp match {
           case tp: AppliedType =>
-            foldOver(n + 1, tp)
+            if defn.isByNameClass(tp.tycon.typeSymbol) then foldOver(n, tp.args)
+            else foldOver(n + 1, tp)
           case tp: RefinedType =>
             foldOver(n + 1, tp)
           case tp: TypeRef if tp.info.isTypeAlias =>
@@ -6161,6 +6205,7 @@ object Types {
       }
   }
 
+  /** Covering set as defined in implicit divergence checking */
   class CoveringSetAccumulator(using Context) extends TypeAccumulator[Set[Symbol]] {
     var seen = util.HashSet[Type](initialCapacity = 8)
     def apply(cs: Set[Symbol], tp: Type): Set[Symbol] =
@@ -6171,7 +6216,9 @@ object Types {
           case tp if tp.isExactlyAny || tp.isExactlyNothing =>
             cs
           case tp: AppliedType =>
-            foldOver(cs + tp.typeSymbol, tp)
+            val tsym = tp.tycon.typeSymbol
+            if defn.isByNameClass(tsym) then foldOver(cs, tp.args)
+            else foldOver(cs + tsym, tp)
           case tp: RefinedType =>
             foldOver(cs + tp.typeSymbol, tp)
           case tp: TypeRef if tp.info.isTypeAlias =>