Add creator apply methods

Use synthetic apply methods instead of a fallback in Typer to implement
creator applications

Author: odersky

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -14,6 +14,7 @@ import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.util.WeakHashSet
+import dotty.tools.dotc.core.Decorators._
 
 /**
  * This class mainly contains the method classBTypeFromSymbol, which extracts the necessary
@@ -101,7 +102,8 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
       else if (classSym.is(ModuleClass)) {
         // workaround #371
 
-        println(s"Warning: mocking up superclass for $classSym")
+        println(i"Warning: mocking up superclass for $classSym ${classSym.id}")
+        assert(false)
         defn.ObjectClass
       }
       else t

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

@@ -8,6 +8,9 @@ object Config {
   inline val cacheImplicitScopes = true
   inline val cacheMatchReduced = true
 
+  val addCreatorCompanions = true
+  val addCreatorApplies = 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

@@ -290,15 +290,10 @@ class Definitions {
     assert(!cls.isCompleted, "race for completing java.lang.Object")
     cls.info = ClassInfo(cls.owner.thisType, cls, AnyClass.typeRef :: Nil, newScope)
     cls.setFlag(NoInits | JavaDefined)
-
-    // 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.makeCreatorCompanion(companion, cls)
+    cls
   }
   def ObjectType: TypeRef = ObjectClass.typeRef
 

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

@@ -378,7 +378,7 @@ object Flags {
   val (Touched @ _, _, _) = newFlags(50, "<touched>")
 
   /** Class has been lifted out to package level, local value has been lifted out to class level */
-  val (Lifted @ _, _, _) = newFlags(51, "<lifted>")
+  val (Lifted @ _, _, _) = newFlags(51, "<creator/lifted>") // only used from lambda-lift
 
   /** Term member has been mixed in */
   val (MixedIn @ _, _, _) = newFlags(52, "<mixedin>")
@@ -420,6 +420,8 @@ object Flags {
   /** A denotation that is valid in all run-ids */
   val (Permanent @ _, _, _) = newFlags(61, "<permanent>")
 
+  val (CreatorProxy @ _, _, _) = newFlags(62, "<creator proxy>")
+
 // --------- Combined Flag Sets and Conjunctions ----------------------
 
   /** All possible flags */
@@ -455,15 +457,16 @@ object Flags {
     Scala2SpecialFlags, MutableOrOpen, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor,
     Extension, NonMember, Implicit, Given, Permanent, Synthetic,
-    SuperParamAliasOrScala2x, Inline, Macro)
+    SuperParamAliasOrScala2x, Inline, Macro, CreatorProxy)
 
   /** Flags that are not (re)set when completing the denotation, or, if symbol is
    *  a top-level class or object, when completing the denotation once the class
    *  file defining the symbol is loaded (which is generally before the denotation
    *  is completed)
    */
   val AfterLoadFlags: FlagSet = commonFlags(
-    FromStartFlags, AccessFlags, Final, AccessorOrSealed, LazyOrTrait, SelfName, JavaDefined, Transparent)
+    FromStartFlags, AccessFlags, Final, AccessorOrSealed,
+    Abstract, LazyOrTrait, SelfName, JavaDefined, Transparent)
 
   /** A value that's unstable unless complemented with a Stable flag */
   val UnstableValueFlags: FlagSet = Mutable | Method
@@ -508,7 +511,7 @@ object Flags {
   val RetainedModuleValAndClassFlags: FlagSet =
     AccessFlags | Package | Case |
     Synthetic | JavaDefined | JavaStatic | Artifact |
-    Lifted | MixedIn | Specialized
+    Lifted | MixedIn | Specialized | CreatorProxy
 
   /** Flags that can apply to a module val */
   val RetainedModuleValFlags: FlagSet = RetainedModuleValAndClassFlags |
@@ -539,7 +542,10 @@ object Flags {
   val EnumCase: FlagSet                      = Case | Enum
   val CovariantLocal: FlagSet                = Covariant | Local                              // A covariant type parameter
   val ContravariantLocal: FlagSet            = Contravariant | Local                          // A contravariant type parameter
+  val EffectivelyErased                      = CreatorProxy | Erased
+  val CreatorProxyModule: FlagSet            = CreatorProxy | Module
   val DefaultParameter: FlagSet              = HasDefault | Param                             // A Scala 2x default parameter
+  val DeferredInline: FlagSet                = Deferred | Inline
   val DeferredOrLazy: FlagSet                = Deferred | Lazy
   val DeferredOrLazyOrMethod: FlagSet        = Deferred | Lazy | Method
   val DeferredOrTermParamOrAccessor: FlagSet = Deferred | ParamAccessor | TermParam           // term symbols without right-hand sides
@@ -548,7 +554,7 @@ object Flags {
   val FinalOrInline: FlagSet                 = Final | Inline
   val FinalOrModuleClass: FlagSet            = Final | ModuleClass                            // A module class or a final class
   val EffectivelyFinalFlags: FlagSet         = Final | Private
-  val ExcludedForwarder: Flags.FlagSet       = Specialized | Lifted | Protected | JavaStatic | Private | Macro
+  val ExcludedForwarder: Flags.FlagSet       = Specialized | Lifted | Protected | JavaStatic | Private | Macro | CreatorProxy
   val FinalOrSealed: FlagSet                 = Final | Sealed
   val GivenOrImplicit: FlagSet               = Given | Implicit
   val GivenOrImplicitVal: FlagSet            = GivenOrImplicit.toTermFlags

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

@@ -1,9 +1,12 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package core
 
-import Contexts._, Symbols._, Types._, Flags._, Scopes._, Decorators._, NameOps._
+import Contexts._, Symbols._, Types._, Flags._, Scopes._, Decorators._, Names._, NameOps._
 import Denotations._
-import SymDenotations.LazyType, Names.Name, StdNames.nme
+import SymDenotations.{LazyType, SymDenotation}, Names.Name, StdNames.nme
+import config.Config
+import ast.untpd
 
 /** Operations that are shared between Namer and TreeUnpickler */
 object NamerOps:
@@ -57,4 +60,101 @@ object NamerOps:
     else NoSymbol.assertingErrorsReported(s"no companion $name in $scope")
   }
 
+  private val noAppliesNeededFlags = Abstract | Trait | Case | Synthetic | Module
+  val CreatorCompanionFlags = Synthetic | CreatorProxy
+  val applyProxyFlags = Synthetic | CreatorProxy | Inline | Method
+
+  def needsCreatorCompanion(cls: Symbol)(using Context): Boolean =
+    Config.addCreatorCompanions
+    && cls.isClass
+    && !cls.flagsUNSAFE.isOneOf(noAppliesNeededFlags)
+    && !cls.isAnonymousClass
+
+  class ApplyProxyCompleter(constr: Symbol)(using Context) extends LazyType:
+    def complete(denot: SymDenotation)(using Context): Unit =
+      denot.info = constr.info
+
+  def addCreatorMethods(scope: MutableScope, cls: ClassSymbol, modcls: ClassSymbol)(using Context): scope.type =
+    def creatorProxy(constr: Symbol): Symbol =
+      newSymbol(
+        modcls, nme.apply, applyProxyFlags | (constr.flagsUNSAFE & AccessFlags),
+        ApplyProxyCompleter(constr), coord = constr.coord)
+          //.showing(i"created apply ${result.showLocated}")
+    if Config.addCreatorApplies then
+      for dcl <- cls.info.decls do
+        if dcl.isConstructor then scope.enter(creatorProxy(dcl))
+    scope
+  end addCreatorMethods
+
+  def creatorCompanionCompleter(cls: ClassSymbol)(
+      modul: TermSymbol, modcls: ClassSymbol)(using Context): LazyType =
+    new LazyType with SymbolLoaders.SecondCompleter {
+      def complete(denot: SymDenotation)(using Context): Unit =
+        val prefix = modcls.owner.thisType
+        denot.info = ClassInfo(
+          prefix, modcls, defn.AnyType :: Nil,
+          addCreatorMethods(newScope, cls, modcls), TermRef(prefix, modul))
+    }.withSourceModule(modul)
+
+  def creatorCompanion(cls: ClassSymbol)(using Context): TermSymbol =
+    val companion = newModuleSymbol(
+        cls.owner, cls.name.toTermName,
+        CreatorCompanionFlags, CreatorCompanionFlags,
+        creatorCompanionCompleter(cls), coord = cls.coord)
+    companion.moduleClass.registerCompanion(cls)
+    cls.registerCompanion(companion.moduleClass)
+    companion
+      //.showing(i"created creator companion $companion")
+/*
+    if needsCreatorCompanion(cls) && !cls.linkedClass.exists then
+      val companion = newModuleSymbol(
+        cls.owner, cls.name.toTermName,
+        CreatorCompanionFlags, CreatorCompanionFlags,
+        creatorCompanionCompleter(cls), coord = cls.coord).entered
+      companion.moduleClass.registerCompanion(cls)
+      cls.registerCompanion(companion.moduleClass)
+      println(i"created proxy companion $companion")
+
+  def ensureApplyProxyCompanion(cls: ClassSymbol)(using Context): Unit =
+    println(i"ensure proxy companion $cls ${cls.flagsString}")
+    if needsCreatorCompanion(cls) && !cls.linkedClass.exists then
+
+      val companion = newModuleSymbol(
+        cls.owner, cls.name.toTermName,
+        applyProxyCompanionFlags, applyProxyCompanionFlags,
+        applyProxyCompanionCompleter(cls), coord = cls.coord).entered
+      companion.moduleClass.registerCompanion(cls)
+      cls.registerCompanion(companion.moduleClass)
+      println(i"created proxy companion $companion")
+*/
+
+  /** For all nested classes without companion objects
+   *  add a companion object. For all constructors, add an apply method.
+   */
+  def addCreatorDefs(cls: ClassSymbol)(using Context): Unit =
+    //println(i"add creator defs $cls / ${}")
+    def memberExists(cls: ClassSymbol, name: TermName): Boolean =
+      cls.baseClasses.exists(_.info.decls.lookupEntry(name) != null)
+    for mbr <- cls.info.decls do
+      if needsCreatorCompanion(mbr)
+         && !mbr.asClass.unforcedRegisteredCompanion.exists
+         && !memberExists(cls, mbr.name.toTermName)
+      then
+        creatorCompanion(mbr.asClass).entered
+
+    if cls.is(Module)
+       && needsCreatorCompanion(cls.linkedClass)
+       && !memberExists(cls, nme.apply)
+    then
+      addCreatorMethods(cls.info.decls.openForMutations, cls.linkedClass.asClass, cls)
+  end addCreatorDefs
+
+  def makeCreatorCompanion(modul: TermSymbol, cls: ClassSymbol)(using Context): Unit =
+    val modcls = modul.moduleClass.asClass
+    modul.setFlag(CreatorCompanionFlags)
+    modcls.setFlag(CreatorCompanionFlags)
+    modcls.info = creatorCompanionCompleter(cls)(modul, modcls)
+    cls.registeredCompanion = modcls
+    modcls.registeredCompanion = cls
+
 end NamerOps

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

@@ -951,7 +951,8 @@ object SymDenotations {
 
     /** An erased value or an erased inline method or field */
     def isEffectivelyErased(using Context): Boolean =
-      is(Erased) || is(Inline) && !isRetainedInline && !hasAnnotation(defn.ScalaStaticAnnot)
+      isOneOf(EffectivelyErased)
+      || is(Inline) && !isRetainedInline && !hasAnnotation(defn.ScalaStaticAnnot)
 
     /** ()T and => T types should be treated as equivalent for this symbol.
      *  Note: For the moment, we treat Scala-2 compiled symbols as loose matching,
@@ -2165,6 +2166,8 @@ object SymDenotations {
       if (companion.isClass && !isAbsent(canForce = false) && !companion.isAbsent(canForce = false))
         myCompanion = companion
 
+    def unforcedRegisteredCompanion: Symbol = myCompanion
+
     override def registeredCompanion(using Context) =
       if !myCompanion.exists then
         ensureCompleted()
@@ -2267,35 +2270,41 @@ object SymDenotations {
           )
         if compiledNow.exists then compiledNow
         else
-          val assocFiles = multi.aggregate(d => Set(d.symbol.associatedFile), _ union _)
-          if assocFiles.size == 1 then
-            multi // they are all overloaded variants from the same file
+          val noCreators = multi.filterWithPredicate(!_.symbol.is(CreatorProxy))
+          if noCreators ne multi then
+            noCreators match
+              case noCreators: DenotUnion => dropStale(noCreators)
+              case _ => noCreators
           else
-            // pick the variant(s) from the youngest class file
-            val lastModDate = assocFiles.map(_.lastModified).max
-            val youngest = assocFiles.filter(_.lastModified == lastModDate)
-            val chosen = youngest.head
-            def ambiguousFilesMsg(f: AbstractFile) =
-              em"""Toplevel definition $name is defined in
-                  |  $chosen
-                  |and also in
-                  |  $f"""
-            if youngest.size > 1 then
-              throw TypeError(i"""${ambiguousFilesMsg(youngest.tail.head)}
-                                 |One of these files should be removed from the classpath.""")
-
-            // Warn if one of the older files comes from a different container.
-            // In that case picking the youngest file is not necessarily what we want,
-            // since the older file might have been loaded from a jar earlier in the
-            // classpath.
-            def sameContainer(f: AbstractFile): Boolean =
-              try f.container == chosen.container catch case NonFatal(ex) => true
-            if !ambiguityWarningIssued then
-              for conflicting <- assocFiles.find(!sameContainer(_)) do
-                report.warning(i"""${ambiguousFilesMsg(conflicting)}
-                               |Keeping only the definition in $chosen""")
-                ambiguityWarningIssued = true
-            multi.filterWithPredicate(_.symbol.associatedFile == chosen)
+            val assocFiles = multi.aggregate(d => Set(d.symbol.associatedFile), _ union _)
+            if assocFiles.size == 1 then
+              multi // they are all overloaded variants from the same file
+            else
+              // pick the variant(s) from the youngest class file
+              val lastModDate = assocFiles.map(_.lastModified).max
+              val youngest = assocFiles.filter(_.lastModified == lastModDate)
+              val chosen = youngest.head
+              def ambiguousFilesMsg(f: AbstractFile) =
+                em"""Toplevel definition $name is defined in
+                    |  $chosen
+                    |and also in
+                    |  $f"""
+              if youngest.size > 1 then
+                throw TypeError(i"""${ambiguousFilesMsg(youngest.tail.head)}
+                                  |One of these files should be removed from the classpath.""")
+
+              // Warn if one of the older files comes from a different container.
+              // In that case picking the youngest file is not necessarily what we want,
+              // since the older file might have been loaded from a jar earlier in the
+              // classpath.
+              def sameContainer(f: AbstractFile): Boolean =
+                try f.container == chosen.container catch case NonFatal(ex) => true
+              if !ambiguityWarningIssued then
+                for conflicting <- assocFiles.find(!sameContainer(_)) do
+                  report.warning(i"""${ambiguousFilesMsg(conflicting)}
+                                |Keeping only the definition in $chosen""")
+                  ambiguityWarningIssued = true
+              multi.filterWithPredicate(_.symbol.associatedFile == chosen)
       end dropStale
 
       if symbol eq defn.ScalaPackageClass then
@@ -2392,7 +2401,11 @@ object SymDenotations {
   }
 
   def stillValid(denot: SymDenotation)(using Context): Boolean =
-    if (denot.isOneOf(ValidForeverFlags) || denot.isRefinementClass || denot.isImport) true
+    if denot.isOneOf(ValidForeverFlags)
+       || denot.isRefinementClass
+       || denot.isImport
+       || denot.isAllOf(CreatorProxyModule)
+    then true
     else {
       val initial = denot.initial
       val firstPhaseId =

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

@@ -359,21 +359,28 @@ abstract class SymbolLoader extends LazyType { self =>
         throw ex
     }
     finally {
-      def postProcess(denot: SymDenotation) =
-        if (!denot.isCompleted &&
-            !denot.completer.isInstanceOf[SymbolLoaders.SecondCompleter])
-          denot.markAbsent()
-      postProcess(root)
+      def postProcess(denot: SymDenotation, other: Symbol) =
+        if !denot.isCompleted &&
+           !denot.completer.isInstanceOf[SymbolLoaders.SecondCompleter] then
+          if denot.is(ModuleClass) && NamerOps.needsCreatorCompanion(other) then
+            NamerOps.makeCreatorCompanion(
+              denot.sourceModule.asTerm, other.asClass)
+            denot.resetFlag(Touched)
+          else
+            denot.markAbsent()
+
+      val other = if root.isRoot then NoSymbol else root.scalacLinkedClass
+      postProcess(root, other)
       if (!root.isRoot)
-        postProcess(root.scalacLinkedClass.denot)
+        postProcess(other, root.symbol)
     }
   }
 
   protected def rootDenots(rootDenot: ClassDenotation)(using Context): (ClassDenotation, ClassDenotation) = {
     val linkedDenot = rootDenot.scalacLinkedClass.denot match {
       case d: ClassDenotation => d
       case d =>
-        // this can happen if the companion if shadowed by a val or type
+        // this can happen if the com*.scaapanion if shadowed by a val or type
         // in a package object; in this case, we make up some dummy denotation
         // as a stand in for loading.
         // An example for this situation is scala.reflect.Manifest, which exists

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

@@ -54,14 +54,10 @@ object Symbols {
     //assert(id != 723)
 
     def coord: Coord = myCoord
-    /** Set the coordinate of this class, this is only useful when the coordinate is
-     *  not known at symbol creation. This is the case for root symbols
-     *  unpickled from TASTY.
-     *
-     *  @pre coord == NoCoord
-     */
+
     private[core] def coord_=(c: Coord): Unit = {
-      assert(myCoord == NoCoord)
+      // This assertion fails for CommentPickling test
+      // assert(myCoord == NoCoord)
       myCoord = c
     }
 

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -196,6 +196,8 @@ class ClassfileParser(
         addAnnotationConstructor(classInfo.asInstanceOf[TempClassInfoType])
 
       setClassInfo(classRoot, classInfo, fromScala2 = false)
+      if NamerOps.needsCreatorCompanion(classRoot.classSymbol) then
+        NamerOps.addCreatorDefs(moduleRoot.classSymbol)
     }
     else if (result == Some(NoEmbedded))
       for (sym <- List(moduleRoot.sourceModule, moduleRoot.symbol, classRoot.symbol)) {