Merge pull request #7436 from dotty-staging/fix-#7428

Fix #7428: Don't make enum values JavaStatic

Author: anatoliykmetyuk

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

@@ -274,23 +274,6 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     case _ => tree
   }
 
-  /** True iff definition is a val or def with no right-hand-side, or it
-   *  is an abstract typoe declaration
-   */
-  def lacksDefinition(mdef: MemberDef)(implicit ctx: Context): Boolean = mdef match {
-    case mdef: ValOrDefDef =>
-      mdef.unforcedRhs == EmptyTree && !mdef.name.isConstructorName && !mdef.mods.isOneOf(TermParamOrAccessor)
-    case mdef: TypeDef =>
-      def isBounds(rhs: Tree): Boolean = rhs match {
-        case _: TypeBoundsTree => true
-        case _: MatchTypeTree => true // Typedefs with Match rhs classify as abstract
-        case LambdaTypeTree(_, body) => isBounds(body)
-        case _ => false
-      }
-      mdef.rhs.isEmpty || isBounds(mdef.rhs)
-    case _ => false
-  }
-
   def functionWithUnknownParamType(tree: Tree): Option[Tree] = tree match {
     case Function(args, _) =>
       if (args.exists {

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

@@ -526,7 +526,7 @@ object Flags {
   val DeferredOrLazyOrMethod: FlagSet        = Deferred | Lazy | Method
   val DeferredOrTermParamOrAccessor: FlagSet = Deferred | ParamAccessor | TermParam           // term symbols without right-hand sides
   val DeferredOrTypeParam: FlagSet           = Deferred | TypeParam                           // type symbols without right-hand sides
-  val EnumValue: FlagSet                     = Enum | JavaStatic | StableRealizable           // A Scala enum value
+  val EnumValue: FlagSet                     = Enum | StableRealizable           // A Scala enum value
   val StableOrErased: FlagSet                = Erased | StableRealizable                      // Assumed to be pure
   val ExtensionMethod: FlagSet               = Extension | Method
   val FinalOrInline: FlagSet                 = Final | Inline

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -352,14 +352,25 @@ class Namer { typer: Typer =>
         cls
       case tree: MemberDef =>
         val name = checkNoConflict(tree.name)
-        val flags = checkFlags(tree.mods.flags)
-        val isDeferred = lacksDefinition(tree)
-        val deferred = if (isDeferred) Deferred else EmptyFlags
-        val method = if (tree.isInstanceOf[DefDef]) Method else EmptyFlags
-        val higherKinded = tree match {
-          case TypeDef(_, LambdaTypeTree(_, _)) if isDeferred => HigherKinded
-          case _ => EmptyFlags
-        }
+        var flags = checkFlags(tree.mods.flags)
+        tree match
+          case tree: ValOrDefDef =>
+            if tree.unforcedRhs == EmptyTree
+               && !flags.isOneOf(TermParamOrAccessor)
+               && !tree.name.isConstructorName
+            then
+              flags |= Deferred
+            if (tree.isInstanceOf[DefDef]) flags |= Method
+            else if flags.isAllOf(EnumValue) && ctx.owner.isStaticOwner then flags |= JavaStatic
+          case tree: TypeDef =>
+            def analyzeRHS(rhs: Tree): Unit = rhs match
+              case _: TypeBoundsTree | _: MatchTypeTree =>
+                flags |= Deferred // Typedefs with Match rhs classify as abstract
+              case LambdaTypeTree(_, body) =>
+                flags |= HigherKinded
+                analyzeRHS(body)
+              case _ =>
+            if tree.rhs.isEmpty then flags |= Deferred else analyzeRHS(tree.rhs)
 
         // to complete a constructor, move one context further out -- this
         // is the context enclosing the class. Note that the context in which a
@@ -370,7 +381,7 @@ class Namer { typer: Typer =>
         // Don't do this for Java constructors because they need to see the import
         // of the companion object, and it is not necessary for them because they
         // have no implementation.
-        val cctx = if (tree.name == nme.CONSTRUCTOR && !tree.mods.is(JavaDefined)) ctx.outer else ctx
+        val cctx = if (tree.name == nme.CONSTRUCTOR && !flags.is(JavaDefined)) ctx.outer else ctx
 
         val completer = tree match {
           case tree: TypeDef =>
@@ -380,8 +391,7 @@ class Namer { typer: Typer =>
             new Completer(tree)(cctx)
         }
         val info = adjustIfModule(completer, tree)
-        createOrRefine[Symbol](tree, name, flags | deferred | method | higherKinded,
-          ctx.owner, _ => info,
+        createOrRefine[Symbol](tree, name, flags, ctx.owner, _ => info,
           (fs, _, pwithin) => ctx.newSymbol(ctx.owner, name, fs, info, pwithin, tree.nameSpan))
       case tree: Import =>
         recordSym(ctx.newImportSymbol(ctx.owner, new Completer(tree), tree.span), tree)

tests/pos/i7428.scala

@@ -0,0 +1,6 @@
+class ABug
+  enum Tag
+    case first
+  import Tag.first
+  val xx = first
+