finality for trait setters, annotations

traitsetter annot for all concrete trait-owned setters

stumble towards juggling annotations correctly

Author: adriaanm

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

@@ -566,7 +566,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
       (((sym.rawflags & symtab.Flags.FINAL) != 0) || isTopLevelModuleClass(sym))
         && !sym.enclClass.isInterface
         && !sym.isClassConstructor
-        && !sym.isMutable // lazy vals and vars both
+        && (!sym.isMutable || nme.isTraitSetterName(sym.name)) // lazy vals and vars and their setters cannot be final, but trait setters are
       )
 
     // Primitives are "abstract final" to prohibit instantiation

src/compiler/scala/tools/nsc/transform/Fields.scala

@@ -36,7 +36,7 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
   val phaseName: String = "fields"
 
   // used for internal communication between info and tree transform of this phase -- not pickled, not in initialflags
-  override def phaseNewFlags: Long = NEEDS_TREES | OVERRIDDEN_TRAIT_SETTER
+  override def phaseNewFlags: Long = NEEDS_TREES | OVERRIDDEN_TRAIT_SETTER | FINAL_TRAIT_ACCESSOR
 
   protected def newTransformer(unit: CompilationUnit): Transformer =
     new FieldsTransformer(unit)
@@ -91,25 +91,7 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
   // NOTE: this only considers type, filter on flags first!
   def fieldMemoizationIn(accessorOrField: Symbol, site: Symbol) = new FieldMemoization(accessorOrField, site)
 
-  def filterAccessorFieldAnnotations(sym: Symbol, tp: Type) = {
-    if ((sym.isAccessor || (sym.isValue && !sym.isMethod)) && sym.owner.isTrait) {
-      // TODO: beansetter/beangetters...
-      val category = if (sym.isGetter) GetterTargetClass else if (sym.isSetter) SetterTargetClass else FieldTargetClass
-      val defaultRetention = !sym.isSetter // TODO: is this right? consider `@deprecated val x` --> in the trait: `@deprecated def x`
-
-      val annotations = sym.annotations filter AnnotationInfo.mkFilter(category, defaultRetention)
-
-      // TODO: does it matter at which phase we do this?
-      //      println(s"annotations for $sym: $annotations (out of ${sym.annotations})")
-
-      sym setAnnotations annotations
-    }
-
-    tp
-  }
-
-
-  override def transformInfo(sym: Symbol, tp: Type): Type = synthFieldsAndAccessors(filterAccessorFieldAnnotations(sym, tp))
+  override def transformInfo(sym: Symbol, tp: Type): Type = synthFieldsAndAccessors(tp)
 
   private def newTraitSetter(getter: Symbol, clazz: Symbol) = {
     // Add setter for an immutable, memoizing getter
@@ -125,7 +107,6 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
     val fieldTp = fieldTypeForGetterIn(getter, clazz.thisType)
 //    println(s"newTraitSetter in $clazz for $getter = $setterName : $fieldTp")
     setter setInfo MethodType(List(setter.newSyntheticValueParam(fieldTp)), UnitTpe)
-    setter addAnnotation TraitSetterAnnotationClass
     setter
   }
 
@@ -146,7 +127,14 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
             if (!(accessor hasFlag (DEFERRED | LAZY)) && fieldMemoizationIn(accessor, clazz).needsField) {
               // in a trait, a memoized accessor becomes deferred
               // (it'll receive an implementation in the first real class to extend this trait)
-              markAccessorImplementedInSubclass(accessor)
+
+              // can't mark getter as FINAL in trait, but remember for when we synthetisize the impl in the subclass to make it FINAL
+              val finality = if (accessor hasFlag FINAL) FINAL_TRAIT_ACCESSOR else 0
+              accessor setFlag (finality | lateFINAL | DEFERRED | SYNTHESIZE_IMPL_IN_SUBCLASS)
+
+              // trait members cannot be final (but the synthesized ones should be)
+              // LOCAL no longer applies (already made not-private)
+              accessor resetFlag (FINAL | LOCAL)
 
               if ((accessor hasFlag STABLE) && accessor.isGetter) // TODO: isGetter is probably redundant?
                 newSetters += newTraitSetter(accessor, clazz)
@@ -213,7 +201,10 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
         // mixin field accessors
         val mixedInFieldAndAccessors = accessorsMaybeNeedingImpl flatMap { accessor =>
           def cloneAccessor() = {
-            val clonedAccessor = (accessor cloneSymbol clazz) setPos clazz.pos setFlag NEEDS_TREES resetFlag DEFERRED | SYNTHESIZE_IMPL_IN_SUBCLASS
+            val clonedAccessor = (accessor cloneSymbol clazz) setPos clazz.pos setFlag NEEDS_TREES resetFlag DEFERRED | SYNTHESIZE_IMPL_IN_SUBCLASS | FINAL_TRAIT_ACCESSOR
+            if (accessor hasFlag FINAL_TRAIT_ACCESSOR) {
+              clonedAccessor setFlag FINAL | lateFINAL // lateFINAL thrown in for good measure, by analogy to makeNotPrivate
+            }
             // if we don't cloneInfo, method argument symbols are shared between trait and subclasses --> lambalift proxy crash
             // TODO: use derive symbol variant?
             val clonedInfo = accessor.info.cloneInfo(clonedAccessor)
@@ -226,13 +217,15 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
           // a trait setter for an overridden val will receive a unit body in the tree transform
           // (this is communicated using the DEFERRED flag)
           if (nme.isTraitSetterName(accessor.name)) {
-            val overridden = isOverriddenAccessor(accessor.getterIn(accessor.owner), clazz)
+            val getter = accessor.getterIn(accessor.owner)
+            val overridden = isOverriddenAccessor(getter, clazz)
 //            println(s"mixing in trait setter ${accessor.defString}: $overridden")
             val clone = cloneAccessor()
 
             clone filterAnnotations (ai => !ai.matches(TraitSetterAnnotationClass)) // only supposed to be set in trait
 
             if (overridden) clone setFlag OVERRIDDEN_TRAIT_SETTER
+            else if (getter.isEffectivelyFinal) clone setFlag FINAL // TODO: why isn't the FINAL_TRAIT_ACCESSOR carry-over from getter enough?
 //            println(s"mixed in trait setter ${clone.defString}")
 
             List(clone)
@@ -250,6 +243,10 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
                 | (if (accessor.hasStableFlag) 0 else MUTABLE)
               )
 
+            // TODO: filter getter's annotations to exclude those only meant for the field
+            // we must keep them around long enough to see them here, though, when we create the field
+            field setAnnotations (accessor.annotations filter AnnotationInfo.mkFilter(FieldTargetClass, defaultRetention = true))
+
             field setFlag newFlags
             List(cloneAccessor(), field)
           } else List(cloneAccessor())
@@ -276,9 +273,6 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
     }
   }
 
-  private def markAccessorImplementedInSubclass(accessor: Symbol): Symbol =
-    accessor setFlag (DEFERRED | SYNTHESIZE_IMPL_IN_SUBCLASS) resetFlag (FINAL | LOCAL) // already made not-private
-
   private def accessorImplementedInSubclass(accessor: Symbol) =
     accessor hasAllFlags (ACCESSOR | SYNTHESIZE_IMPL_IN_SUBCLASS)
 

src/reflect/scala/reflect/internal/Flags.scala

@@ -175,6 +175,7 @@ class Flags extends ModifierFlags {
   final val SYNTHESIZE_IMPL_IN_SUBCLASS = 1L << 50 // Like MIXEDIN, but used in Fields
   final val NEEDS_TREES   = 1L << 59           // Communicate from Fields' info transform to its tree transform -- this symbol needs a tree. (distinct from SYNTHESIZE_IMPL_IN_SUBCLASS)
   final val OVERRIDDEN_TRAIT_SETTER = 1L << 60 // Communicate from Fields' info transform to its tree transform -- this setter gets a unit body.
+  final val FINAL_TRAIT_ACCESSOR = 1L << 61 // Communicate from Fields' info transform to its tree transform -- this accessor's synthesized implementation should be final.
 
   // ------- shift definitions -------------------------------------------------------
   //
@@ -470,7 +471,7 @@ class Flags extends ModifierFlags {
     case        `notPRIVATE` => "<notprivate>"                        // (1L << 58)
     case SYNTHESIZE_IMPL_IN_SUBCLASS => "<sub_synth>"                 // (1L << 59)
     case OVERRIDDEN_TRAIT_SETTER => "<overridden_trait_setter>"       // (1L << 60)
-    case 0x2000000000000000L => ""                                    // (1L << 61)
+    case FINAL_TRAIT_ACCESSOR => "<final_trait_acc>"                  // (1L << 61)
     case 0x4000000000000000L => ""                                    // (1L << 62)
     case 0x8000000000000000L => ""                                    // (1L << 63)
     case _ => ""

test/files/trait-defaults/fields.scala

@@ -1,3 +1,8 @@
+trait T { final val bla: Int = 123 }
+class C extends T // bla should be final in C
+
+
+
 trait T { final val C = "S" }
 // there should be a C method in `T$class`!
 class C extends T { println(C) }