This maps @native, @volatile, and @transient in...

This maps @native, @volatile, and @transient in java source to the
relevant annotations in scala, rather than discarding the modifiers
completely. I have no specific motivation for this other than it seems
better to do it than not. Also cleans up some old flailing of mine in
the dept. of mapping java access to scala. No review.

3 files changed, 36 insertions, 39 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index 57e41d9867..49d3251448 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -99,11 +99,7 @@ abstract class GenJVM extends SubComponent {
     val MethodHandleType  = new JObjectType("java.dyn.MethodHandle")
 
     // Scala attributes
-    import definitions.{ SerializableAttr, SerialVersionUIDAttr }
-    val CloneableAttr    = definitions.getClass("scala.cloneable")
-    val TransientAtt     = definitions.getClass("scala.transient")
-    val VolatileAttr     = definitions.getClass("scala.volatile")
-    val RemoteAttr       = definitions.getClass("scala.remote")
+    import definitions.{ SerializableAttr, SerialVersionUIDAttr, VolatileAttr, TransientAttr, CloneableAttr, RemoteAttr }
     val BeanInfoAttr     = definitions.getClass("scala.reflect.BeanInfo")
     val BeanInfoSkipAttr = definitions.getClass("scala.reflect.BeanInfoSkip")
     val BeanDisplayNameAttr = definitions.getClass("scala.reflect.BeanDisplayName")
@@ -607,7 +603,7 @@ abstract class GenJVM extends SubComponent {
         log("Adding field: " + f.symbol.fullName)
 
       val attributes = f.symbol.annotations.map(_.atp.typeSymbol).foldLeft(0) {
-        case (res, TransientAtt)  => res | ACC_TRANSIENT
+        case (res, TransientAttr) => res | ACC_TRANSIENT
         case (res, VolatileAttr)  => res | ACC_VOLATILE
         case (res, _)             => res
       }
diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
index 0388df7005..3c9cdbf878 100644
--- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
+++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
@@ -378,8 +378,11 @@ trait JavaParsers extends JavaScanners {
     def modifiers(inInterface: Boolean): Modifiers = {
       var flags: Long = Flags.JAVA
       // assumed true unless we see public/private/protected - see bug #1240
-      var privateWithin: Name =
-        if (inInterface) nme.EMPTY.toTypeName else thisPackageName
+      // Todo: look at pos/t1176, #1240, #1840, #1842, see what current access issues are.
+      var isPackageAccess = true
+      var annots: List[Tree] = Nil
+      def addAnnot(sym: Symbol) =
+        annots :+= New(TypeTree(sym.tpe), List(Nil))
 
       while (true) {
         in.token match {
@@ -387,15 +390,14 @@ trait JavaParsers extends JavaScanners {
             in.nextToken
             annotation()
           case PUBLIC =>
-            privateWithin = nme.EMPTY.toTypeName
+            isPackageAccess = false
             in.nextToken
           case PROTECTED =>
             flags |= Flags.PROTECTED
-            //privateWithin = thisPackageName
             in.nextToken
           case PRIVATE =>
+            isPackageAccess = false
             flags |= Flags.PRIVATE
-            privateWithin = nme.EMPTY.toTypeName
             in.nextToken
           case STATIC =>
             flags |= Flags.STATIC
@@ -406,26 +408,23 @@ trait JavaParsers extends JavaScanners {
           case FINAL =>
             flags |= Flags.FINAL
             in.nextToken
-          case NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | STRICTFP =>
+          case NATIVE =>
+            addAnnot(NativeAttr)
+            in.nextToken
+          case TRANSIENT =>
+            addAnnot(TransientAttr)
+            in.nextToken
+          case VOLATILE =>
+            addAnnot(VolatileAttr)
+            in.nextToken
+          case SYNCHRONIZED | STRICTFP =>
             in.nextToken
           case _ =>
-            // XXX both these checks are definitely necessary, which would
-            // seem to indicate the empty package situation needs review
-            // def isEmptyPkg() =
-            //   privateWithin == nme.EMPTY.toTypeName ||
-            //   privateWithin == nme.EMPTY_PACKAGE_NAME_tn
-            // XXX I think this test should just be "if (defaultAccess)"
-            // but then many cases like pos/t1176 fail because scala code
-            // with no package cannot access java code with no package.
-            // if (defaultAccess && !isEmptyPkg)
-            //   flags |= Flags.PROTECTED    // package private
-
-            // my every attempt so far has left some combination of
-            // #1240, #1840, #1842, or other java/scala mixes failing.
-            // Reverting to original code, which means #1240 won't
-            // work but other variations should.
-
-            return Modifiers(flags, privateWithin)
+            val privateWithin: Name =
+              if (isPackageAccess && !inInterface) thisPackageName
+              else nme.EMPTY.toTypeName
+
+            return Modifiers(flags, privateWithin) withAnnotations annots
         }
       }
       abort("should not be here")
diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala
index 99e7979e0b..116b3923ef 100644
--- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala
@@ -454,14 +454,19 @@ trait Definitions extends reflect.generic.StandardDefinitions {
       def BoxedUnit_TYPE = getMember(BoxedUnitModule, "TYPE")
 
     // special attributes
-    lazy val SerializableAttr: Symbol = getClass("scala.serializable")
-    lazy val SerialVersionUIDAttr: Symbol = getClass("scala.SerialVersionUID")
-    lazy val DeprecatedAttr: Symbol = getClass("scala.deprecated")
-    lazy val DeprecatedNameAttr: Symbol = getClass("scala.deprecatedName")
-    lazy val MigrationAnnotationClass: Symbol = getClass("scala.annotation.migration")
+    lazy val BeanPropertyAttr: Symbol           = getClass(sn.BeanProperty)
+    lazy val BooleanBeanPropertyAttr: Symbol    = getClass(sn.BooleanBeanProperty)
+    lazy val CloneableAttr: Symbol              = getClass("scala.cloneable")
+    lazy val DeprecatedAttr: Symbol             = getClass("scala.deprecated")
+    lazy val DeprecatedNameAttr: Symbol         = getClass("scala.deprecatedName")
+    lazy val MigrationAnnotationClass: Symbol   = getClass("scala.annotation.migration")
+    lazy val NativeAttr: Symbol                 = getClass("scala.native")
+    lazy val RemoteAttr: Symbol                 = getClass("scala.remote")
+    lazy val SerialVersionUIDAttr: Symbol       = getClass("scala.SerialVersionUID")
+    lazy val SerializableAttr: Symbol           = getClass("scala.serializable")
     lazy val TraitSetterAnnotationClass: Symbol = getClass("scala.runtime.TraitSetter")
-    lazy val BeanPropertyAttr: Symbol = getClass(sn.BeanProperty)
-    lazy val BooleanBeanPropertyAttr: Symbol = getClass(sn.BooleanBeanProperty)
+    lazy val TransientAttr: Symbol              = getClass("scala.transient")
+    lazy val VolatileAttr: Symbol               = getClass("scala.volatile")
 
     lazy val AnnotationDefaultAttr: Symbol = {
       val attr = newClass(RuntimePackageClass, nme.AnnotationDefaultATTR, List(AnnotationClass.typeConstructor))
@@ -470,9 +475,6 @@ trait Definitions extends reflect.generic.StandardDefinitions {
       attr
     }
 
-    lazy val NativeAttr: Symbol = getClass("scala.native")
-    lazy val VolatileAttr: Symbol = getClass("scala.volatile")
-
     def getModule(fullname: Name): Symbol = getModuleOrClass(fullname, true)
     def getModule2(name1: Name, name2: Name) = try {
       getModuleOrClass(name1, true)