fields phase

the info-transformed of constructors:
  - traits receive trait-setters for vals
  - classes receive fields & accessors for mixed in traits

Constructors tree transformer
  - makes trees for decls added during above info transform
  - adds mixin super calls to the primary constructor

```
trait OneConcreteVal[T] {
var x = 1 // : T = ???
def foo = x
}

trait OneOtherConcreteVal[T] {
var y: T = ???
}

class C extends OneConcreteVal[Int] with OneOtherConcreteVal[String]
```

we don't have a field -- only a getter -- so,
where will we keep non-getter but-field annotations?

mixin only deals with lazy accessors/vals

do not used referenced to correlate getter/setter
it messes with paramaccessor's usage, and we don't really need it

make sure to clone info's, so we don't share symbols for method args
this manifests itself as an exception in lambdalift, finding proxies

Use NEEDS_TREES for all comms between InfoTransform and tree transform

yep, need SYNTHESIZE_IMPL_IN_SUBCLASS

distinguish accessors that should be mixed into subclass,
and those that simply need to be implemented in tree transform,
after info transform added the decl

commit 4b4932e
Author: Adriaan Moors <[email protected]>
Date:   6 days ago

    do assignment to trait fields in AddInterfaces

    regular class vals get assignments during constructors, as before

impl classes get accessors + assignments through trait setters in addinterfaces
so that constructors acts on them there,
and produced the init method in the required spot (the impl class)

bootstrapped compiler needs new partest

commit baf568d
Author: Adriaan Moors <[email protected]>
Date:   3 weeks ago

    produce identical bytecode for constant trait val getters

    I couldn't bring myself to emit the unused fields that we
    used to emit for constant vals, even though the getters
    immediately return the constant, and thus the field goes unused.

    In the next version, there's no need to synthesize impls
    for these in subclasses -- the getter can be implemented
    in the interface.

commit b9052da
Author: Lukas Rytz <[email protected]>
Date:   3 weeks ago

    Fix enclosing method attribute for classes nested in trait fields

    Trait fields are now created as MethodSymbol (no longer TermSymbol).
    This symbol shows up in the `originalOwner` chain of a class declared
    within the field initializer. This promoted the field getter to
    being the enclosing method of the nested class, which it is not
    (the EnclosingMethod attribute is a source-level property).

commit cf845ab
Author: Adriaan Moors <[email protected]>
Date:   3 weeks ago

    don't suppress field for unit-typed vals

    it affects the memory model -- even a write of unit to a field is relevant...

commit 337a9dd
Author: Adriaan Moors <[email protected]>
Date:   4 weeks ago

    unit-typed lazy vals should never receive a field

    this need was unmasked by test/files/run/t7843-jsr223-service.scala,
    which no longer printed the output expected from the `0 to 10 foreach`

    Currently failing tests:

     - test/files/pos/t6780.scala
     - test/files/neg/anytrait.scala
     - test/files/neg/delayed-init-ref.scala
     - test/files/neg/t562.scala
     - test/files/neg/t6276.scala
     - test/files/run/delambdafy_uncurry_byname_inline.scala
     - test/files/run/delambdafy_uncurry_byname_method.scala
     - test/files/run/delambdafy_uncurry_inline.scala
     - test/files/run/delambdafy_uncurry_method.scala
     - test/files/run/inner-obj-auto.scala
     - test/files/run/lazy-traits.scala
     - test/files/run/reify_lazyunit.scala
     - test/files/run/showraw_mods.scala
     - test/files/run/t3670.scala
     - test/files/run/t3980.scala
     - test/files/run/t4047.scala
     - test/files/run/t6622.scala
     - test/files/run/t7406.scala
     - test/files/run/t7843-jsr223-service.scala
     - test/files/jvm/innerClassAttribute
     - test/files/specialized/SI-7343.scala
     - test/files/specialized/constant_lambda.scala
     - test/files/specialized/spec-early.scala
     - test/files/specialized/spec-init.scala
     - test/files/specialized/spec-matrix-new.scala
     - test/files/specialized/spec-matrix-old.scala
     - test/files/presentation/scope-completion-3

commit b1b4e5c
Author: Adriaan Moors <[email protected]>
Date:   4 weeks ago

    wip: lambdalift fix

    test/files/trait-defaults/lambdalift.scala works,
    but still some related tests failing

    (note that we can't use a bootstrapped compiler yet
    due to binary incompatibility in partest)

commit eae7dac
Author: Adriaan Moors <[email protected]>
Date:   4 weeks ago

    update check now that trait vals can be concrete, use names not letters

    note the progression in a concrete trait val now being recognized as such
    ```
    -trait T => true
    -method $init$ => false
    -value z1 => true
    -value z2 => true // z2 is actually concrete!
    ```

commit 6555c74
Author: Adriaan Moors <[email protected]>
Date:   4 weeks ago

    bootstraps again by running info transform once per class...

    not sure how this ever worked, as separate compilation would transform a trait's info
    multiple times, resulting in double defs...

commit 273cb20
Author: Adriaan Moors <[email protected]>
Date:   6 weeks ago

    skip presuper vals in new encoding

commit 728e71e
Author: Adriaan Moors <[email protected]>
Date:   6 weeks ago

    incoherent cyclic references between synthesized members

    must replace old trait accessor symbols by mixed in symbols
    in the infos of the mixed in symbols

    ```
    trait T { val a: String ; val b: a.type }
    class C extends T {
      // a, b synthesized, but the a in b's type, a.type, refers to the original symbol, not the clone in C
    }
    ```

    symbols occurring in types of synthesized members
    do not get rebound to other synthesized symbols

    package <empty>#4 {
      abstract <defaultparam/trait> trait N#7352 extends scala#22.AnyRef#2378 {
        <method> <deferred> <mutable> <accessor> <triedcooking> <sub_synth> def N$_setter_$self_$eq#15011(x$1#15012: <empty>#3.this.N#7352): scala#23.this.Unit#2340;
        <method> <deferred> <mutable> <accessor> <triedcooking> <sub_synth> def N$_setter_$n_$eq#15013(x$1#15014: N#7352.this.self#7442.type): scala#23.this.Unit#2340;
        <method> def /*N*/$init$scala#7441(): scala#23.this.Unit#2340 = {
          ()
        };
        <method> <deferred> <stable> <accessor> <triedcooking> <sub_synth> def self#7442: <empty>#3.this.N#7352;
        N#7352.this.N$_setter_$self_$eq#15011(scala#22.Predef#1729.$qmark$qmark$qmark#6917);
        <method> <deferred> <stable> <accessor> <sub_synth> def n#7443: N#7352.this.self#7442.type;
        N#7352.this.N$_setter_$n_$eq#15013(N#7352.this.self#7442)
      };
      abstract class M#7353 extends scala#22.AnyRef#2378 {
        <method> <triedcooking> def <init>#13465(): <empty>#3.this.M#7353 = {
          M#7353.super.<init>scala#2719();
          ()
        };
        <method> <deferred> <stable> <accessor> <triedcooking> def self#13466: <empty>#3.this.N#7352;
        <method> <deferred> <stable> <accessor> def n#13467: M#7353.this.self#13466.type
      };
      class C#7354 extends M#7353 with <empty>#3.this.N#7352 {
        <method> <stable> <accessor> <triedcooking> def self#15016: <empty>#3.this.N#7352 = C#7354.this.self #15015;
        <triedcooking> private[this] val self #15015: <empty>#3.this.N#7352 = _;
        <method> <stable> <accessor> def n#15018: C#7354.this.self#7442.type = C#7354.this.n #15017;
        <triedcooking> private[this] val n #15017: C#7354.this.self#7442.type = _;
        <method> <mutable> <accessor> <triedcooking> def N$_setter_$self_$eq#15019(x$1#15021: <empty>#3.this.N#7352): scala#23.this.Unit#2340 = C#7354.this.self #15015 = x$1#15021;
        <method> <mutable> <accessor> <triedcooking> def N$_setter_$n_$eq#15022(x$1#15025: C#7354.this.self#7442.type): scala#23.this.Unit#2340 = C#7354.this.n #15017 = x$1#15025;
        <method> def <init>#14997(): <empty>#3.this.C#7354 = {
          C#7354.super.<init>#13465();
          ()
        }
      }
    }

    [running phase pickler on dependent_rebind.scala]
    [running phase refchecks on dependent_rebind.scala]
    test/files/trait-defaults/dependent_rebind.scala:16: error: overriding field n#15049 in trait N#7352 of type C#7354.this.self#15016.type;
     value n #15017 has incompatible type;
     found   : => C#7354.this.self#7442.type (with underlying type => C#7354.this.self#7442.type)
     required: => N#7352.this.self#7442.type
    class C extends M with N
          ^

    pos/t9111-inliner-workaround revealed need for:
-  override def transformInfo(sym: Symbol, tp: Type): Type = synthFieldsAndAccessors(tp)
+  override def transformInfo(sym: Symbol, tp: Type): Type = if (!sym.isJavaDefined) synthFieldsAndAccessors(tp) else tp

commit b56ca2f
Author: Adriaan Moors <[email protected]>
Date:   6 weeks ago

    static forwarders & private[this] val in trait

    object Properties extends PropertiesTrait

    trait PropertiesTrait {
      // the protected member is not emitted as a static member of  -- it works when dropping the access modifier
      // somehow, the module class member is considered deferred in BForwardersGen
      protected val propFilename: String = /
    }

    // [log jvm] No forwarder for 'getter propFilename' from Properties to 'module class Properties': false || m.isDeferred == true || false || false

    // the following method is missing compared to scalac
    // public final class Properties {
    //     public static String propFilename() {
    //         return Properties$.MODULE$.propFilename();
    //     }

    trait Chars {
      private[this] val char2uescapeArray = Array[Char]('\', 'u', 0, 0, 0, 0)
    }

    object Chars extends Chars

    // +++ w/reflect/scala/reflect/internal/Chars$.class
    // -  private final [C scala83014char2uescapeArray

    constant fold in forwarder for backwards compat
    constant-typed final val in trait should yield impl method

    bean{setter,getter} delegates to setter/getter (commit 1655d1b)

Author: adriaanm

src/compiler/scala/tools/nsc/Global.scala

@@ -458,10 +458,18 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     val runsRightAfter = None
   } with ExtensionMethods
 
+  // phaseName = "fields"
+  object fields extends {
+    val global: Global.this.type = Global.this
+    // somewhere between typers, before erasure (so we get bridges for getters) and pickler (separate compilation of trait with fields and subclass)
+    val runsAfter = List("extmethods")
+    val runsRightAfter = None
+  } with Fields
+
   // phaseName = "pickler"
   object pickler extends {
     val global: Global.this.type = Global.this
-    val runsAfter = List("extmethods")
+    val runsAfter = List("fields")
     val runsRightAfter = None
   } with Pickler
 
@@ -605,7 +613,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
    *  This implementation creates a description map at the same time.
    */
   protected def computeInternalPhases(): Unit = {
-    // Note: this fits -Xshow-phases into 80 column width, which it is
+    // Note: this fits -Xshow-phases into 80 column width, which is
     // desirable to preserve.
     val phs = List(
       syntaxAnalyzer          -> "parse source into ASTs, perform simple desugaring",
@@ -615,6 +623,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       patmat                  -> "translate match expressions",
       superAccessors          -> "add super accessors in traits and nested classes",
       extensionMethods        -> "add extension methods for inline classes",
+      fields                  -> "synthesize accessors and fields",
       pickler                 -> "serialize symbol tables",
       refChecks               -> "reference/override checking, translate nested objects",
       uncurry                 -> "uncurry, translate function values to anonymous classes",

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

@@ -155,7 +155,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
     def enclosingMethod(sym: Symbol): Option[Symbol] = {
       if (sym.isClass || sym == NoSymbol) None
-      else if (sym.isMethod) {
+      else if (sym.isMethod && !sym.isGetter) {
         if (doesNotExist(sym)) None else Some(sym)
       }
       else enclosingMethod(nextEnclosing(sym))

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

@@ -646,7 +646,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
       (((sym.rawflags & symtab.Flags.FINAL) != 0) || isTopLevelModuleClass(sym))
         && !sym.enclClass.isTrait
         && !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

@@ -131,11 +131,10 @@ trait MethodSynthesis {
           val getterSym = getter.createAndEnterSymbol()
 
           // Create the setter if necessary.
-          if (getter.needsSetter)
-            Setter(tree).createAndEnterSymbol()
+          if (getter.needsSetter) Setter(tree).createAndEnterSymbol()
 
-          // If the getter's abstract the tree gets the getter's symbol,
-          // otherwise, create a field (assume the getter requires storage).
+          // If the getter's abstract, the tree gets the getter's symbol,
+          // otherwise, create a field (we have to assume the getter requires storage for now).
           // NOTE: we cannot look at symbol info, since we're in the process of deriving them
           // (luckily, they only matter for lazy vals, which we've ruled out in this else branch,
           // and `doNotDeriveField` will skip them if `!mods.isLazy`)
@@ -304,46 +303,54 @@ trait MethodSynthesis {
 
         result
       }
+
       final def derive(initial: List[AnnotationInfo]): Tree = {
         validate()
 
         // see scala.annotation.meta's package class for more info
         // Annotations on ValDefs can be targeted towards the following: field, getter, setter, beanGetter, beanSetter, param.
         // The defaults are:
         //   - (`val`-, `var`- or plain) constructor parameter annotations end up on the parameter, not on any other entity.
-        //   - val/var member annotations solely end up on the underlying field.
+        //   - val/var member annotations solely end up on the underlying field, except in traits (@since 2.12),
+        //     where there is no field, and the getter thus holds annotations targetting both getter & field.
+        //     As soon as there is a field/getter (in subclasses mixing in the trait), we triage the annotations.
         //
         // TODO: these defaults can be surprising for annotations not meant for accessors/fields -- should we revisit?
         // (In order to have `@foo val X` result in the X getter being annotated with `@foo`, foo needs to be meta-annotated with @getter)
         val annotFilter: AnnotationInfo => Boolean = this match {
           case _: Param                       => annotationFilter(ParamTargetClass,      defaultRetention = true)
           // By default annotations go to the field, except if the field is generated for a class parameter (PARAMACCESSOR).
           case _: Field                       => annotationFilter(FieldTargetClass,      defaultRetention = !mods.isParamAccessor)
+          case _: BaseGetter if owner.isTrait => annotationFilter(List(FieldTargetClass, GetterTargetClass), defaultRetention = true)
           case _: BaseGetter                  => annotationFilter(GetterTargetClass,     defaultRetention = false)
           case _: Setter                      => annotationFilter(SetterTargetClass,     defaultRetention = false)
           case _: BeanSetter                  => annotationFilter(BeanSetterTargetClass, defaultRetention = false)
+          // TODO do bean getters need special treatment to collect field-targeting annotations in traits?
           case _: AnyBeanGetter               => annotationFilter(BeanGetterTargetClass, defaultRetention = false)
         }
 
         // The annotations amongst those found on the original symbol which
         // should be propagated to this kind of accessor.
         derivedSym setAnnotations (initial filter annotFilter)
 
+        if (derivedSym.isSetter && owner.isTrait && !isDeferred)
+          derivedSym addAnnotation TraitSetterAnnotationClass
+
         logDerived(derivedTree)
       }
     }
+
     sealed trait DerivedGetter extends DerivedFromValDef {
-      // A getter must be accompanied by a setter if the ValDef is mutable.
       def needsSetter = mods.isMutable
     }
     sealed trait DerivedSetter extends DerivedFromValDef {
       override def isSetter = true
-      private def setterParam = derivedSym.paramss match {
+      protected def setterParam = derivedSym.paramss match {
         case (p :: Nil) :: _  => p
         case _                => NoSymbol
       }
 
-      private def setterRhs = {
+      protected def setterRhs = {
         assert(!derivedSym.isOverloaded, s"Unexpected overloaded setter $derivedSym for $basisSym in $enclClass")
         if (Field.noFieldFor(tree) || derivedSym.isOverloaded) EmptyTree
         else Assign(fieldSelection, Ident(setterParam))
@@ -390,6 +397,7 @@ trait MethodSynthesis {
       override def derivedSym = if (Field.noFieldFor(tree)) basisSym else basisSym.getterIn(enclClass)
       private def derivedRhs  = if (Field.noFieldFor(tree)) tree.rhs else fieldSelection
 
+      // TODO: more principled approach -- this is a bit bizarre
       private def derivedTpt = {
         // For existentials, don't specify a type for the getter, even one derived
         // from the symbol! This leads to incompatible existentials for the field and
@@ -457,24 +465,31 @@ trait MethodSynthesis {
       def flagsMask  = SetterFlags
       def flagsExtra = ACCESSOR
 
+      // TODO: double check logic behind need for name expansion in context of new fields phase
       override def derivedSym = basisSym.setterIn(enclClass)
     }
 
     object Field {
       // No field for these vals (either never emitted or eliminated later on):
       //   - abstract vals have no value we could store (until they become concrete, potentially)
       //   - lazy vals of type Unit
-      //   - [Emitted, later removed during AddInterfaces/Mixins] concrete vals in traits can't have a field
-      //   - [Emitted, later removed during Constructors] a concrete val with a statically known value (Unit / ConstantType)
+      //   - concrete vals in traits don't yield a field here either (their getter's RHS has the initial value)
+      //     AddInterfaces will move the assignment to the constructor, abstracting over the field using the field setter,
+      //     and Fields will add a field to the class that mixes in the trait, implementing the accessors in terms of it
+      //   - [Emitted, later removed during Constructors] a concrete val with a statically known value (ConstantType)
       //     performs its side effect according to lazy/strict semantics, but doesn't need to store its value
       //     each access will "evaluate" the RHS (a literal) again
       // We would like to avoid emitting unnecessary fields, but the required knowledge isn't available until after typer.
       // The only way to avoid emitting & suppressing, is to not emit at all until we are sure to need the field, as dotty does.
       // NOTE: do not look at `vd.symbol` when called from `enterGetterSetter` (luckily, that call-site implies `!mods.isLazy`),
+      // similarly, the `def field` call-site breaks when you add `|| vd.symbol.owner.isTrait` (detected in test suite)
       // as the symbol info is in the process of being created then.
       // TODO: harmonize tree & symbol creation
-      // TODO: the `def field` call-site breaks when you add `|| vd.symbol.owner.isTrait` (detected in test suite)
-      def noFieldFor(vd: ValDef) = vd.mods.isDeferred || (vd.mods.isLazy && isUnitType(vd.symbol.info))
+      // the middle  `&& !owner.isTrait` is needed after `isLazy` because non-unit-typed lazy vals in traits still get a field -- see neg/t5455.scala
+      def noFieldFor(vd: ValDef) = vd.mods.isDeferred || (vd.mods.isLazy && !owner.isTrait && isUnitType(vd.symbol.info)) || (owner.isTrait && !traitFieldFor(vd))
+
+      // TODO: never emit any fields in traits -- only use getter for lazy/presuper ones as well
+      private def traitFieldFor(vd: ValDef): Boolean = vd.mods.hasFlag(PRESUPER | LAZY)
     }
 
     case class Field(tree: ValDef) extends DerivedFromValDef {
@@ -528,7 +543,10 @@ trait MethodSynthesis {
     }
     case class BooleanBeanGetter(tree: ValDef) extends BeanAccessor("is") with AnyBeanGetter { }
     case class BeanGetter(tree: ValDef) extends BeanAccessor("get") with AnyBeanGetter { }
-    case class BeanSetter(tree: ValDef) extends BeanAccessor("set") with DerivedSetter
+    case class BeanSetter(tree: ValDef) extends BeanAccessor("set") with DerivedSetter {
+      // TODO: document, motivate
+      override protected def setterRhs = Apply(Ident(tree.name.setterName), List(Ident(setterParam)))
+    }
 
     // No Symbols available.
     private def beanAccessorsFromNames(tree: ValDef) = {

src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala

@@ -117,10 +117,10 @@ trait Namers extends MethodSynthesis {
     }
 
     // All lazy vals need accessors, including those owned by terms (e.g., in method) or private[this] in a class
-    def deriveAccessors(vd: ValDef) = vd.mods.isLazy || (owner.isClass && deriveAccessorsInClass(vd))
+    def deriveAccessors(vd: ValDef) = (vd.mods.isLazy || owner.isTrait || (owner.isClass && deriveAccessorsInClass(vd)))
 
     private def deriveAccessorsInClass(vd: ValDef) =
-      !vd.mods.isPrivateLocal &&         // note, private[this] lazy vals do get accessors -- see outer disjunction of deriveAccessors
+      !vd.mods.isPrivateLocal && // note, private[this] lazy vals do get accessors -- see outer disjunction of deriveAccessors
       !(vd.name startsWith nme.OUTER) && // outer accessors are added later, in explicitouter
       !isEnumConstant(vd)                // enums can only occur in classes, so only check here
 

src/compiler/scala/tools/nsc/typechecker/Namers.scala

@@ -423,9 +423,9 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
             overrideError("cannot be used here - class definitions cannot be overridden")
           } else if (!other.isDeferred && member.isClass) {
             overrideError("cannot be used here - classes can only override abstract types")
-          } else if (other.isEffectivelyFinal) { // (1.2)
+          } else if (other.isEffectivelyFinal && !other.hasFlag(SYNTHESIZE_IMPL_IN_SUBCLASS)) { // (1.2)
             overrideError("cannot override final member")
-          } else if (!other.isDeferredOrJavaDefault && !other.hasFlag(JAVA_DEFAULTMETHOD) && !member.isAnyOverride && !member.isSynthetic) { // (*)
+          } else if (!other.isDeferredOrJavaDefault && !other.hasFlag(JAVA_DEFAULTMETHOD) && !member.isAnyOverride && !member.isSynthetic && !other.hasFlag(SYNTHESIZE_IMPL_IN_SUBCLASS)) { // (*)
             // (*) Synthetic exclusion for (at least) default getters, fixes SI-5178. We cannot assign the OVERRIDE flag to
             // the default getter: one default getter might sometimes override, sometimes not. Example in comment on ticket.
               if (isNeitherInClass && !(other.owner isSubClass member.owner))
@@ -465,7 +465,8 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
             overrideError("cannot be used here - only term macros can override term macros")
           } else {
             checkOverrideTypes()
-            checkOverrideDeprecated()
+            if (!other.hasFlag(SYNTHESIZE_IMPL_IN_SUBCLASS))
+              checkOverrideDeprecated()
             if (settings.warnNullaryOverride) {
               if (other.paramss.isEmpty && !member.paramss.isEmpty) {
                 reporter.warning(member.pos, "non-nullary method overrides nullary method")
@@ -1131,22 +1132,16 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
       case _ =>
     }
 
-    // SI-6276 warn for `def foo = foo` or `val bar: X = bar`, which come up more frequently than you might think.
-    def checkInfiniteLoop(valOrDef: ValOrDefDef) {
-      def callsSelf = valOrDef.rhs match {
-        case t @ (Ident(_) | Select(This(_), _)) =>
-          t hasSymbolWhich (_.accessedOrSelf == valOrDef.symbol)
-        case _ => false
+    // SI-6276 warn for trivial recursion, such as `def foo = foo` or `val bar: X = bar`, which come up more frequently than you might think.
+    // TODO: Move to abide rule. Also, this does not check that the def is final or not overridden, for example
+    def checkInfiniteLoop(sym: Symbol, rhs: Tree): Unit =
+      if (!sym.isValueParameter && sym.paramss.isEmpty) {
+        rhs match {
+          case t@(Ident(_) | Select(This(_), _)) if t hasSymbolWhich (_.accessedOrSelf == sym) =>
+            reporter.warning(rhs.pos, s"${sym.fullLocationString} does nothing other than call itself recursively")
+          case _ =>
+        }
       }
-      val trivialInfiniteLoop = (
-        !valOrDef.isErroneous
-     && !valOrDef.symbol.isValueParameter
-     && valOrDef.symbol.paramss.isEmpty
-     && callsSelf
-      )
-      if (trivialInfiniteLoop)
-        reporter.warning(valOrDef.rhs.pos, s"${valOrDef.symbol.fullLocationString} does nothing other than call itself recursively")
-    }
 
 // Transformation ------------------------------------------------------------
 
@@ -1480,7 +1475,21 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
       tree match {
         case m: MemberDef =>
           val sym = m.symbol
-          applyChecks(sym.annotations)
+          val allAnnots = sym.annotations
+
+          // drop field-targeting annotations from getters
+          // (in traits, getters must also hold annotations that target the underlying field,
+          //  because the latter won't be created until the trait is mixed into a class)
+          // TODO do bean getters need special treatment to suppress field-targeting annotations in traits?
+          val annots =
+            if (sym.isGetter && sym.owner.isTrait) {
+              val annots = allAnnots filter AnnotationInfo.mkFilter(GetterTargetClass, defaultRetention = false)
+//              if (annots != allAnnots) println(s"filtering for $sym: $allAnnots to $annots")
+              sym setAnnotations annots
+              annots
+            } else allAnnots
+
+          applyChecks(annots)
 
           def messageWarning(name: String)(warn: String) =
             reporter.warning(tree.pos, f"Invalid $name message for ${sym}%s${sym.locationString}%s:%n$warn")
@@ -1661,9 +1670,13 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
             sym resetFlag DEFERRED
             transform(deriveDefDef(tree)(_ => typed(gen.mkSysErrorCall("native method stub"))))
 
-          case ValDef(_, _, _, _) | DefDef(_, _, _, _, _, _) =>
+          // NOTE: a val in a trait is now a DefDef, with the RHS being moved to an Assign in AddInterfaces
+          case tree: ValOrDefDef =>
             checkDeprecatedOvers(tree)
-            checkInfiniteLoop(tree.asInstanceOf[ValOrDefDef])
+
+            if (!tree.isErroneous)
+              checkInfiniteLoop(tree.symbol, tree.rhs)
+
             if (settings.warnNullaryUnit)
               checkNullaryMethodReturnType(sym)
             if (settings.warnInaccessible) {

src/compiler/scala/tools/nsc/typechecker/RefChecks.scala

@@ -1360,7 +1360,13 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
               notAllowed(s"redefinition of $name method. See SIP-15, criterion 4.")
             else if (stat.symbol != null && stat.symbol.isParamAccessor)
               notAllowed("additional parameter")
+            // concrete accessor (getter) in trait corresponds to a field definition (neg/anytrait.scala)
+            // TODO: only reject accessors that actually give rise to field (e.g., a constant-type val is fine)
+            else if (!isValueClass && stat.symbol.isAccessor && !stat.symbol.isDeferred)
+              notAllowed("field definition")
             checkEphemeralDeep.traverse(rhs)
+          // for value class or "exotic" vals in traits
+          // (traits don't receive ValDefs for regular vals until fields phase -- well, except for early initialized/lazy vals)
           case _: ValDef =>
             notAllowed("field definition")
           case _: ModuleDef =>
@@ -4213,7 +4219,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
 //      if (varsym.isVariable ||
 //        // setter-rewrite has been done above, so rule out methods here, but, wait a minute, why are we assigning to non-variables after erasure?!
 //        (phase.erasedTypes && varsym.isValue && !varsym.isMethod)) {
-        if (varsym.isVariable || varsym.isValue && phase.erasedTypes) {
+        if (varsym.isVariable || varsym.isValue && phase.assignsFields) {
           val rhs1 = typedByValueExpr(rhs, lhs1.tpe)
           treeCopy.Assign(tree, lhs1, checkDead(rhs1)) setType UnitTpe
         }

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -8,6 +8,8 @@
 
 package scala
 
+import scala.annotation.meta._
+
 /** An annotation that designates that inheriting from a class is deprecated.
  *
  *  This is usually done to warn about a non-final class being made final in a future version.
@@ -19,4 +21,5 @@ package scala
  *  @since  2.10
  *  @see    [[scala.deprecatedOverriding]]
  */
+@getter @setter @beanGetter @beanSetter
 class deprecatedInheritance(message: String = "", since: String = "") extends scala.annotation.StaticAnnotation

src/library/scala/deprecatedInheritance.scala

@@ -8,6 +8,8 @@
 
 package scala
 
+import scala.annotation.meta._
+
 /** An annotation that designates that overriding a member is deprecated.
  *
  *  Overriding such a member in  a sub-class then generates a warning.
@@ -17,4 +19,5 @@ package scala
  *  @since  2.10
  *  @see    [[scala.deprecatedInheritance]]
  */
+@getter @setter @beanGetter @beanSetter
 class deprecatedOverriding(message: String = "", since: String = "") extends scala.annotation.StaticAnnotation