Fix select static

Need to do time travel to find out whether members
were created as static symbols. After LambdaLift
and Flatten most symbols are static anyway.

Author: odersky

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

@@ -46,7 +46,7 @@ trait SymDenotations { this: Context =>
       val initial = denot.initial
       val firstPhaseId = initial.validFor.firstPhaseId.max(ctx.typerPhase.id)
       if ((initial ne denot) || ctx.phaseId != firstPhaseId)
-        ctx.withPhase(firstPhaseId).stillValidInOwner(initial.asSymDenotation)
+        ctx.withPhase(firstPhaseId).stillValidInOwner(initial)
       else
         stillValidInOwner(denot)
     }
@@ -77,7 +77,7 @@ trait SymDenotations { this: Context =>
           implicit val ctx: Context = this
           val initial = denot.initial
           if ((initial ne denot) || ctx.phaseId != initial.validFor.firstPhaseId) {
-            ctx.withPhase(initial.validFor.firstPhaseId).traceInvalid(initial.asSymDenotation)
+            ctx.withPhase(initial.validFor.firstPhaseId).traceInvalid(initial)
           } else try {
             val owner = denot.owner.denot
             if (!traceInvalid(owner)) explainSym("owner is invalid")
@@ -346,14 +346,14 @@ object SymDenotations {
       else {
         def legalize(name: Name): Name = // JVM method names may not contain `<' or `>' characters
           if (is(Method)) name.replace('<', '(').replace('>', ')') else name
-        legalize(name.expandedName(initial.asSymDenotation.owner))
+        legalize(name.expandedName(initial.owner))
       }
         // need to use initial owner to disambiguate, as multiple private symbols with the same name
         // might have been moved from different origins into the same class
 
     /** The name with which the denoting symbol was created */
     final def originalName(implicit ctx: Context) = {
-      val d = initial.asSymDenotation
+      val d = initial
       if (d is ExpandedName) d.name.unexpandedName else d.name // !!!DEBUG, was: effectiveName
     }
 
@@ -435,13 +435,13 @@ object SymDenotations {
 
     /** Is this symbol an anonymous class? */
     final def isAnonymousClass(implicit ctx: Context): Boolean =
-      isClass && (initial.asSymDenotation.name startsWith tpnme.ANON_CLASS)
+      isClass && (initial.name startsWith tpnme.ANON_CLASS)
 
     final def isAnonymousFunction(implicit ctx: Context) =
-      this.symbol.is(Method) && (initial.asSymDenotation.name startsWith nme.ANON_FUN)
+      this.symbol.is(Method) && (initial.name startsWith nme.ANON_FUN)
 
     final def isAnonymousModuleVal(implicit ctx: Context) =
-      this.symbol.is(ModuleVal) && (initial.asSymDenotation.name startsWith nme.ANON_CLASS)
+      this.symbol.is(ModuleVal) && (initial.name startsWith nme.ANON_CLASS)
 
     /** Is this a companion class method or companion object method?
      *  These methods are generated by Symbols#synthesizeCompanionMethod
@@ -606,7 +606,7 @@ object SymDenotations {
 
     /** Is this symbol a class that extends `AnyVal`? */
     final def isValueClass(implicit ctx: Context): Boolean = {
-      val di = this.initial.asSymDenotation
+      val di = initial
       di.isClass &&
       di.derivesFrom(defn.AnyValClass)(ctx.withPhase(di.validFor.firstPhaseId))
         // We call derivesFrom at the initial phase both because AnyVal does not exist
@@ -1164,6 +1164,8 @@ object SymDenotations {
       d
     }
 
+    override def initial: SymDenotation = super.initial.asSymDenotation
+
     /** Install this denotation as the result of the given denotation transformer. */
     override def installAfter(phase: DenotTransformer)(implicit ctx: Context): Unit =
       super.installAfter(phase)
@@ -1226,10 +1228,13 @@ object SymDenotations {
       if (myTypeParams == null)
         myTypeParams =
           if (ctx.erasedTypes || is(Module)) Nil // fast return for modules to avoid scanning package decls
-          else if (this ne initial) initial.asSymDenotation.typeParams
-          else infoOrCompleter match {
-            case info: TypeParamsCompleter => info.completerTypeParams(symbol)
-            case _ => typeParamsFromDecls
+          else {
+            val di = initial
+            if (this ne di) di.typeParams
+            else infoOrCompleter match {
+              case info: TypeParamsCompleter => info.completerTypeParams(symbol)
+              case _ => typeParamsFromDecls
+            }
           }
       myTypeParams
     }

src/dotty/tools/dotc/transform/SelectStatic.scala

@@ -19,25 +19,21 @@ class SelectStatic extends MiniPhaseTransform with IdentityDenotTransformer { th
   import ast.tpd._
 
   override def phaseName: String = "selectStatic"
-  private val isPackage = FlagConjunction(PackageCreationFlags.bits)
 
   override def transformSelect(tree: tpd.Select)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
     val sym = tree.symbol
-    val r1 =
-      if (!sym.is(isPackage) && !sym.maybeOwner.is(isPackage) &&
-        (
-          ((sym is Flags.Module) && sym.maybeOwner.isStaticOwner) ||
-            (sym is Flags.JavaStatic) ||
-            (sym.maybeOwner is Flags.ImplClass) ||
-            sym.hasAnnotation(ctx.definitions.ScalaStaticAnnot)
-          )
-      )
-        if (!tree.qualifier.symbol.is(JavaModule) && !tree.qualifier.isType)
-          Block(List(tree.qualifier), ref(sym))
-        else tree
+    def isStaticMember =
+      (sym is Flags.Module) && sym.initial.maybeOwner.initial.isStaticOwner ||
+      (sym is Flags.JavaStatic) ||
+      (sym.maybeOwner is Flags.ImplClass) ||
+      sym.hasAnnotation(ctx.definitions.ScalaStaticAnnot)
+    val isStaticRef = !sym.is(Package) && !sym.maybeOwner.is(Package) && isStaticMember
+    val tree1 =
+      if (isStaticRef && !tree.qualifier.symbol.is(JavaModule) && !tree.qualifier.isType)
+        Block(List(tree.qualifier), ref(sym))
       else tree
 
-    normalize(r1)
+    normalize(tree1)
   }
 
   private def normalize(t: Tree)(implicit ctx: Context) = t match {