Fix #8022: Refactor MoveStatics

Author: liufengyun

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

@@ -59,7 +59,6 @@ class Compiler {
          new CheckReentrant,         // Internal use only: Check that compiled program has no data races involving global vars
          new ElimPackagePrefixes,    // Eliminate references to package prefixes in Select nodes
          new CookComments,           // Cook the comments: expand variables, doc, etc.
-         new CheckStatic,            // Check restrictions that apply to @static members
          new BetaReduce,             // Reduce closure applications
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
          new init.Checker) ::        // Check initialization of objects
@@ -94,6 +93,7 @@ class Compiler {
          new ParamForwarding,        // Add forwarders for aliases of superclass parameters
          new TupleOptimizations,     // Optimize generic operations on tuples
          new LetOverApply,            // Lift blocks from receivers of applications
+         new MoveStatics,            // Move static methods from companion to the class itself
          new ArrayConstructors) ::   // Intercept creation of (non-generic) arrays and intrinsify.
     List(new Erasure) ::             // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
     List(new ElimErasedValueType,    // Expand erased value types to their underlying implmementation types
@@ -120,7 +120,6 @@ class Compiler {
          new Flatten,                // Lift all inner classes to package scope
          new RenameLifted,           // Renames lifted classes to local numbering scheme
          new TransformWildcards,     // Replace wildcards with default values
-         new MoveStatics,            // Move static methods from companion to the class itself
          new ExpandPrivate,          // Widen private definitions accessed from nested classes
          new RestoreScopes,          // Repair scopes rendered invalid by moving definitions in prior phases of the group
          new SelectStatic,           // get rid of selects that would be compiled into GetStatic

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -1943,7 +1943,7 @@ import transform.SymUtils._
   }
 
   class StaticFieldsOnlyAllowedInObjects(member: Symbol)(using Context) extends SyntaxMsg(StaticFieldsOnlyAllowedInObjectsID) {
-    def msg = em"${hl("@static")} $member in ${member.owner} must be defined inside an ${hl("object")}."
+    def msg = em"${hl("@static")} $member in ${member.owner} must be defined inside a static ${hl("object")}."
     def explain =
       em"${hl("@static")} members are only allowed inside objects."
   }

compiler/src/dotty/tools/dotc/transform/CheckStatic.scala

@@ -3,20 +3,25 @@ package transform
 
 import core._
 import MegaPhase._
-import dotty.tools.dotc.ast.tpd._
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.StdNames._
-import ast._
-import Trees._
+import Contexts._
 import Flags._
+import StdNames._
 import NameOps._
 import SymUtils._
 import Symbols._
 import Decorators._
 import DenotTransformers._
 import Constants.Constant
+import Annotations.Annotation
+import Types.MethodType
+
+import ast._
+import Trees._
+import tpd._
+
 import collection.mutable
 
+
 object Constructors {
   val name: String = "constructors"
 }
@@ -31,7 +36,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
   import tpd._
 
   override def phaseName: String = Constructors.name
-  override def runsAfter: Set[String] = Set(HoistSuperArgs.name)
+  override def runsAfter: Set[String] = Set(HoistSuperArgs.name, MoveStatics.name)
   override def runsAfterGroupsOf: Set[String] = Set(Memoize.name)
     // Memoized needs to be finished because we depend on the ownerchain after Memoize
     // when checking whether an ident is an access in a constructor or outside it.
@@ -311,6 +316,19 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
       }
       else cpy.DefDef(constr)(rhs = Block(finalConstrStats, unitLiteral))
 
+
+    val staticFields = clsStats.filter(x => x.isInstanceOf[ValDef] && x.symbol.hasAnnotation(defn.ScalaStaticAnnot)).toList.asInstanceOf[List[ValDef]]
+    if (staticFields.nonEmpty) {
+      /* do NOT put Flags.JavaStatic here. It breaks .enclosingClass */
+      val staticCostructor = newSymbol(cls, nme.STATIC_CONSTRUCTOR, Flags.Synthetic | Flags.Method | Flags.Private, MethodType(Nil, defn.UnitType))
+      staticCostructor.addAnnotation(Annotation(defn.ScalaStaticAnnot))
+      staticCostructor.entered
+
+      val staticAssigns = staticFields.map(x => Assign(ref(x.symbol), x.rhs.changeOwner(x.symbol, staticCostructor)))
+      val staticConstr = tpd.DefDef(staticCostructor, Block(staticAssigns, tpd.unitLiteral))
+      clsStats.prepend(staticConstr)
+    }
+
     cpy.Template(tree)(constr = expandedConstr, body = clsStats.toList)
   }
 }

compiler/src/dotty/tools/dotc/transform/Constructors.scala

@@ -695,7 +695,7 @@ object Erasure {
 
       val owner = mapOwner(origSym)
       val sym = if (owner eq origSym.maybeOwner) origSym else owner.info.decl(tree.name).symbol
-      assert(sym.exists, origSym.showLocated)
+      assert(sym.exists, tree.show)
 
       if owner == defn.ObjectClass then checkValue(qual1)
 

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -1,26 +1,42 @@
-package dotty.tools.dotc.transform
-
-import dotty.tools.dotc.ast.{Trees, tpd}
-import dotty.tools.dotc.core.Annotations.Annotation
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.DenotTransformers.SymTransformer
-import dotty.tools.dotc.core.SymDenotations.SymDenotation
-import dotty.tools.dotc.core.NameOps._
-import dotty.tools.dotc.core.Flags
-import dotty.tools.dotc.core.Names.Name
-import dotty.tools.dotc.core.StdNames.nme
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Types.MethodType
-import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+package dotty.tools.dotc
+package transform
 
-object MoveStatics {
-  val name: String = "moveStatic"
-}
+import core._
+import Flags._
+import Contexts._
+import Symbols._
+import Decorators._
+import DenotTransformers.SymTransformer
+import Types.MethodType
+import Annotations.Annotation
+import SymDenotations.SymDenotation
+import Names.Name
+import NameOps._
 
-/** Move static methods from companion to the class itself */
+import reporting._
+import ast._
+
+import SymUtils._
+import MegaPhase._
+
+/** A transformer that check that requirements of Static fields\methods are implemented:
+ *
+ *  1. Only objects can have members annotated with `@static`
+ *  2. The fields annotated with `@static` should precede any non-`@static` fields.
+ *     This ensures that we do not introduce surprises for users in initialization order.
+ *  3. If a member `foo` of an `object C` is annotated with `@static`,
+ *     the companion class `C` is not allowed to define term members with name `foo`.
+ *  4. If a member `foo` of an `object C` is annotated with `@static`, the companion class `C`
+ *     is not allowed to inherit classes that define a term member with name `foo`.
+ *  5. Only `@static` methods and vals are supported in companions of traits.
+ *     Java8 supports those, but not vars, and JavaScript does not have interfaces at all.
+ *  6. `@static` Lazy vals are currently unsupported.
+ *
+ *  And move static methods from companion to the class itself.
+ */
 class MoveStatics extends MiniPhase with SymTransformer {
+  import ast.tpd._
 
-  import tpd._
   override def phaseName: String = MoveStatics.name
 
   def transformSym(sym: SymDenotation)(using Context): SymDenotation =
@@ -32,50 +48,89 @@ class MoveStatics extends MiniPhase with SymTransformer {
     }
     else sym
 
+  override def transformTemplate(tree: tpd.Template)(using Context): tpd.Tree = {
+    val defns = tree.body.collect{case t: ValOrDefDef => t}
+    var hadNonStaticField = false
+    for (defn <- defns)
+      if (defn.symbol.isScalaStatic) {
+        if (!ctx.owner.isStatic)
+          report.error(StaticFieldsOnlyAllowedInObjects(defn.symbol), defn.srcPos)
+          defn.symbol.resetFlag(JavaStatic)
+
+        if (defn.isInstanceOf[ValDef] && hadNonStaticField)
+          report.error(StaticFieldsShouldPrecedeNonStatic(defn.symbol, defns), defn.srcPos)
+
+        val companion = ctx.owner.companionClass
+        def clashes = companion.typeRef.decl(defn.name)
+
+        if (!companion.exists)
+          report.error(MissingCompanionForStatic(defn.symbol), defn.srcPos)
+        else if (clashes.isOverloaded)
+          report.error(MemberWithSameNameAsStatic(), defn.srcPos)
+        else if (defn.symbol.is(Flags.Mutable) && companion.is(Flags.Trait))
+          report.error(TraitCompanionWithMutableStatic(), defn.srcPos)
+        else if (defn.symbol.is(Flags.Lazy))
+          report.error(LazyStaticField(), defn.srcPos)
+        else if (defn.symbol.allOverriddenSymbols.nonEmpty)
+          report.error(StaticOverridingNonStaticMembers(), defn.srcPos)
+      }
+      else hadNonStaticField = hadNonStaticField || defn.isInstanceOf[ValDef]
+
+    tree
+  }
+
+  override def transformSelect(tree: tpd.Select)(using Context): tpd.Tree =
+    if (tree.symbol.hasAnnotation(defn.ScalaStaticAnnot)) {
+      def isSafeQual(t: Tree): Boolean = // follow the desugared paths created by typer
+        t match {
+          case t: This => true
+          case t: Select => isSafeQual(t.qualifier)
+          case t: Block => t.stats.forall(tpd.isPureExpr) && isSafeQual(t.expr)
+          case _ => false
+        }
+      println("tree.qualifier = " + tree.qualifier)
+      if (isSafeQual(tree.qualifier))
+        ref(tree.symbol)
+      else
+        Block(tree.qualifier :: Nil, ref(tree.symbol))
+    }
+    else tree
+
+
   override def transformStats(trees: List[Tree])(using Context): List[Tree] =
     if (ctx.owner.is(Flags.Package)) {
       val (classes, others) = trees.partition(x => x.isInstanceOf[TypeDef] && x.symbol.isClass)
       val pairs = classes.groupBy(_.symbol.name.stripModuleClassSuffix).asInstanceOf[Map[Name, List[TypeDef]]]
 
       def rebuild(orig: TypeDef, newBody: List[Tree]): Tree = {
-        if (orig eq null) return EmptyTree
-
-        val staticFields = newBody.filter(x => x.isInstanceOf[ValDef] && x.symbol.hasAnnotation(defn.ScalaStaticAnnot)).asInstanceOf[List[ValDef]]
-        val newBodyWithStaticConstr =
-          if (staticFields.nonEmpty) {
-            /* do NOT put Flags.JavaStatic here. It breaks .enclosingClass */
-            val staticCostructor = newSymbol(orig.symbol, nme.STATIC_CONSTRUCTOR, Flags.Synthetic | Flags.Method | Flags.Private, MethodType(Nil, defn.UnitType))
-            staticCostructor.addAnnotation(Annotation(defn.ScalaStaticAnnot))
-            staticCostructor.entered
-
-            val staticAssigns = staticFields.map(x => Assign(ref(x.symbol), x.rhs.changeOwner(x.symbol, staticCostructor)))
-            tpd.DefDef(staticCostructor, Block(staticAssigns, tpd.unitLiteral)) :: newBody
-          }
-          else newBody
-
         val oldTemplate = orig.rhs.asInstanceOf[Template]
-        cpy.TypeDef(orig)(rhs = cpy.Template(oldTemplate)(body = newBodyWithStaticConstr))
+        cpy.TypeDef(orig)(rhs = cpy.Template(oldTemplate)(body = newBody))
       }
 
       def move(module: TypeDef, companion: TypeDef): List[Tree] = {
         assert(companion != module)
         if (!module.symbol.is(Flags.Module)) move(companion, module)
         else {
-          val allMembers =
-            (if (companion != null) {companion.rhs.asInstanceOf[Template].body} else Nil) ++
-            module.rhs.asInstanceOf[Template].body
-          val (newModuleBody, newCompanionBody) = allMembers.partition(x => {assert(x.symbol.exists); x.symbol.owner == module.symbol})
-          Trees.flatten(rebuild(companion, newCompanionBody) :: rebuild(module, newModuleBody) :: Nil)
+          val moduleTmpl = module.rhs.asInstanceOf[Template]
+          val companionTmpl = companion.rhs.asInstanceOf[Template]
+          val (staticDefs, remainingDefs) = moduleTmpl.body.partition {
+            case memberDef: MemberDef => memberDef.symbol.isScalaStatic
+            case _ => false
+          }
+
+          rebuild(companion, companionTmpl.body ++ staticDefs) :: rebuild(module, remainingDefs) :: Nil
         }
       }
       val newPairs =
         for ((name, classes) <- pairs)
           yield
-            if (classes.tail.isEmpty)
-              if (classes.head.symbol.is(Flags.Module)) move(classes.head, null)
-              else List(rebuild(classes.head, classes.head.rhs.asInstanceOf[Template].body))
+            if (classes.tail.isEmpty) classes
             else move(classes.head, classes.tail.head)
       Trees.flatten(newPairs.toList.flatten ++ others)
     }
     else trees
 }
+
+object MoveStatics {
+  val name: String = "moveStatic"
+}