Fields phase expands lazy vals like modules

They remain ValDefs until then.

- remove lazy accessor logic
  now that we have a single ValDef for lazy vals,
  with the underlying machinery being hidden until the fields phase
  leave a `@deprecated def lazyAccessor` for scala-refactoring

- don't skolemize in purely synthetic getters,
  but *do* skolemize in lazy accessor during typers

  Lazy accessors have arbitrary user code, so have to skolemize.
  We exempt the purely synthetic accessors (`isSyntheticAccessor`)
  for strict vals, and lazy accessors emitted by the fields phase
  to avoid spurious type mismatches due to issues with existentials
  (That bug is tracked as https://github.com/scala/scala-dev/issues/165)

  When we're past typer, lazy accessors are synthetic,
  but before they are user-defined to make this hack less hacky,
  we could rework our flag usage to allow for
  requiring both the ACCESSOR and the SYNTHETIC bits
  to identify synthetic accessors and trigger the exemption.

  see also https://github.com/scala/scala-dev/issues/165

  ok 7 - pos/existentials-harmful.scala
  ok 8 - pos/t2435.scala
  ok 9 - pos/existentials.scala

  previous attempt: skolemize type of val inside the private[this] val

  because its type is only observed from inside the
  accessor methods (inside the method scope its existentials are skolemized)

- bean accessors have regular method types, not nullary method types

- must re-infer type for param accessor
  some weirdness with scoping of param accessor vals and defs?

- tailcalls detect lazy vals, which are defdefs after fields

- can inline constant lazy val from trait

- don't mix in fields etc for an overridden lazy val

- need try-lift in lazy vals: the assign is not seen in uncurry
  because fields does the transform (see run/t2333.scala)

- ensure field members end up final in bytecode

- implicit class companion method: annot filter in completer

- update check: previous error message was tangled up with unrelated
  field definitions (`var s` and `val s_scope`),
  now it behaves consistently whether those are val/vars or defs

- analyzer plugin check update seems benign, but no way to know...

- error message gen: there is no underlying symbol for a deferred var
  look for missing getter/setter instead

- avoid retypechecking valdefs while duplicating for specialize
  see pos/spec-private

- Scaladoc uniformly looks to field/accessor symbol

- test updates to innerClassAttribute by Lukas

6 files changed, 206 insertions, 339 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
index 78e72cf771..df014b5161 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
@@ -151,8 +151,12 @@ abstract class Duplicators extends Analyzer {
             ldef.symbol = newsym
             debuglog("newsym: " + newsym + " info: " + newsym.info)
 
-          case vdef @ ValDef(mods, name, _, rhs) if mods.hasFlag(Flags.LAZY) =>
-            debuglog("ValDef " + name + " sym.info: " + vdef.symbol.info)
+          // don't retypecheck val members or local lazy vals -- you'll end up with duplicate symbols because
+          // entering a valdef results in synthesizing getters etc
+          // TODO: why retype check any valdefs?? I checked and the rhs is specialized just fine this way
+          // (and there are no args/type params/... to warrant full type checking?)
+          case vdef @ ValDef(mods, name, _, rhs) if mods.hasFlag(Flags.LAZY) || owner.isClass =>
+            debuglog(s"ValDef $name in $owner sym.info: ${vdef.symbol.info}")
             invalidSyms(vdef.symbol) = vdef
             val newowner = owner orElse context.owner
             val newsym = vdef.symbol.cloneSymbol(newowner)
diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
index e0b64a7600..d11417192d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
@@ -5,6 +5,7 @@
 package scala.tools.nsc
 package typechecker
 
+import scala.reflect.NameTransformer
 import symtab.Flags._
 import scala.reflect.internal.util.StringOps.ojoin
 import scala.reflect.internal.util.ListOfNil
@@ -116,38 +117,53 @@ trait MethodSynthesis {
 
     import NamerErrorGen._
 
-    def enterImplicitWrapper(tree: ClassDef): Unit = {
-      enterSyntheticSym(ImplicitClassWrapper(tree).derivedTree)
-    }
 
-    // trees are later created by addDerivedTrees (common logic is encapsulated in field/standardAccessors/beanAccessors)
+    import treeInfo.noFieldFor
+
+    // populate synthetics for this unit with trees that will later be added by the typer
+    // we get here when entering the symbol for the valdef, so its rhs has not yet been type checked
     def enterGetterSetter(tree: ValDef): Unit = {
+      val fieldSym =
+        if (noFieldFor(tree, owner)) NoSymbol
+        else owner.newValue(tree.name append NameTransformer.LOCAL_SUFFIX_STRING, tree.pos, tree.mods.flags & FieldFlags | PrivateLocal)
+
       val getter = Getter(tree)
       val getterSym = getter.createSym
-      val setterSym = if (getter.needsSetter) Setter(tree).createSym else NoSymbol
-
-      // a lazy field is linked to its lazy accessor (TODO: can we do the same for field -> getter -> setter)
-      val fieldSym = if (Field.noFieldFor(tree)) NoSymbol else Field(tree).createSym(getterSym)
 
       // only one symbol can have `tree.pos`, the others must focus their position
       // normally the field gets the range position, but if there is none, give it to the getter
       tree.symbol = fieldSym orElse (getterSym setPos tree.pos)
+      val namer = namerOf(tree.symbol)
+
+      // the valdef gets the accessor symbol for a lazy val (too much going on in its RHS)
+      // the fields phase creates the field symbol
+      if (!tree.mods.isLazy) {
+        // if there's a field symbol, the getter is considered a synthetic that must be added later
+        // if there's no field symbol, the ValDef tree receives the getter symbol and thus is not a synthetic
+        if (fieldSym != NoSymbol) {
+          context.unit.synthetics(getterSym) = getter.derivedTree(getterSym)
+          getterSym setInfo namer.accessorTypeCompleter(tree, tree.tpt.isEmpty, isBean = false, isSetter = false)
+        } else getterSym setInfo namer.valTypeCompleter(tree)
+
+        enterInScope(getterSym)
+
+        if (getter.needsSetter) {
+          val setter = Setter(tree)
+          val setterSym = setter.createSym
+          context.unit.synthetics(setterSym) = setter.derivedTree(setterSym)
+          setterSym setInfo namer.accessorTypeCompleter(tree, tree.tpt.isEmpty, isBean = false, isSetter = true)
+          enterInScope(setterSym)
+        }
 
-      val namer = if (fieldSym != NoSymbol) namerOf(fieldSym) else namerOf(getterSym)
-
-      // There's no reliable way to detect all kinds of setters from flags or name!!!
-      // A BeanSetter's name does not end in `_=` -- it does begin with "set", but so could the getter
-      // for a regular Scala field... TODO: can we add a flag to distinguish getter/setter accessors?
-      val getterCompleter = namer.accessorTypeCompleter(tree, isSetter = false)
-      val setterCompleter = namer.accessorTypeCompleter(tree, isSetter = true)
-
-      getterSym setInfo getterCompleter
-      setterSym andAlso (_ setInfo setterCompleter)
-      fieldSym andAlso (_ setInfo namer.valTypeCompleter(tree))
-
-      enterInScope(getterSym)
-      setterSym andAlso (enterInScope(_))
-      fieldSym andAlso (enterInScope(_))
+        // TODO: delay emitting the field to the fields phase (except for private[this] vals, which only get a field and no accessors)
+        if (fieldSym != NoSymbol) {
+          fieldSym setInfo namer.valTypeCompleter(tree)
+          enterInScope(fieldSym)
+        }
+      } else {
+        getterSym setInfo namer.valTypeCompleter(tree)
+        enterInScope(getterSym)
+      }
 
       deriveBeanAccessors(tree, namer)
     }
@@ -188,242 +204,82 @@ trait MethodSynthesis {
           sym
         }
 
-        val getterCompleter = namer.beanAccessorTypeCompleter(tree, missingTpt, isSetter = false)
+        val getterCompleter = namer.accessorTypeCompleter(tree, missingTpt, isBean = true, isSetter = false)
         enterInScope(deriveBeanAccessor(if (hasBeanProperty) "get" else "is") setInfo getterCompleter)
 
         if (tree.mods.isMutable) {
-          val setterCompleter = namer.beanAccessorTypeCompleter(tree, missingTpt, isSetter = true)
+          val setterCompleter = namer.accessorTypeCompleter(tree, missingTpt, isBean = true, isSetter = true)
           enterInScope(deriveBeanAccessor("set") setInfo setterCompleter)
         }
       }
     }
 
 
-    import AnnotationInfo.{mkFilter => annotationFilter}
-    def addDerivedTrees(typer: Typer, stat: Tree): List[Tree] = stat match {
-      case vd @ ValDef(mods, name, tpt, rhs) if deriveAccessors(vd) && !vd.symbol.isModuleVar && !vd.symbol.isJava =>
-        stat.symbol.initialize // needed!
-
-        val getter = Getter(vd)
-        getter.validate()
-        val accessors = getter :: (if (getter.needsSetter) Setter(vd) :: Nil else Nil)
-        (Field(vd) :: accessors).map(_.derivedTree).filter(_ ne EmptyTree)
-
-      case cd @ ClassDef(mods, _, _, _) if mods.isImplicit =>
-        val annotations = stat.symbol.initialize.annotations
-        // TODO: need to shuffle annotations between wrapper and class.
-        val wrapper = ImplicitClassWrapper(cd)
-        val meth = wrapper.derivedSym
-        context.unit.synthetics get meth match {
-          case Some(mdef) =>
-            context.unit.synthetics -= meth
-            meth setAnnotations (annotations filter annotationFilter(MethodTargetClass, defaultRetention = false))
-            cd.symbol setAnnotations (annotations filter annotationFilter(ClassTargetClass, defaultRetention = true))
-            List(cd, mdef)
-          case _ =>
-            // Shouldn't happen, but let's give ourselves a reasonable error when it does
-            context.error(cd.pos, s"Internal error: Symbol for synthetic factory method not found among ${context.unit.synthetics.keys.mkString(", ")}")
-            // Soldier on for the sake of the presentation compiler
-            List(cd)
-        }
-      case _ =>
-        stat :: Nil
-      }
-
-
-    sealed trait Derived {
-      /** The derived symbol. It is assumed that this symbol already exists and has been
-        * entered in the parent scope when derivedSym is called
-        */
-      def derivedSym: Symbol
-
-      /** The definition tree of the derived symbol. */
-      def derivedTree: Tree
+    def enterImplicitWrapper(classDef: ClassDef): Unit = {
+      val methDef = factoryMeth(classDef.mods & AccessFlags | METHOD | IMPLICIT | SYNTHETIC, classDef.name.toTermName, classDef)
+      val methSym = assignAndEnterSymbol(methDef)
+      context.unit.synthetics(methSym) = methDef
+      methSym setInfo implicitFactoryMethodCompleter(methDef, classDef.symbol, completerOf(methDef).asInstanceOf[LockingTypeCompleter])
     }
 
 
-    /** A synthetic method which performs the implicit conversion implied by
-      *  the declaration of an implicit class.
-      */
-    case class ImplicitClassWrapper(tree: ClassDef) extends Derived {
-      def derivedSym = {
-        val enclClass = tree.symbol.owner.enclClass
-        // Only methods will do! Don't want to pick up any stray
-        // companion objects of the same name.
-        val result = enclClass.info decl derivedName filter (x => x.isMethod && x.isSynthetic)
-        if (result == NoSymbol || result.isOverloaded)
-          context.error(tree.pos, s"Internal error: Unable to find the synthetic factory method corresponding to implicit class $derivedName in $enclClass / ${enclClass.info.decls}")
-        result
-      }
-
-      def derivedTree = factoryMeth(derivedMods, derivedName, tree)
-
-      def derivedName = tree.name.toTermName
-      def derivedMods = tree.mods & AccessFlags | METHOD | IMPLICIT | SYNTHETIC
-    }
-
-    trait DerivedAccessor extends Derived {
+    trait DerivedAccessor {
       def tree: ValDef
       def derivedName: TermName
       def derivedFlags: Long
+      def derivedTree(sym: Symbol): Tree
 
       def derivedPos = tree.pos.focus
       def createSym = createMethod(tree, derivedName, derivedPos, derivedFlags)
     }
 
     case class Getter(tree: ValDef) extends DerivedAccessor {
-      def derivedName = tree.name
-
-      def derivedSym =
-        if (tree.mods.isLazy) tree.symbol.lazyAccessor
-        else if (Field.noFieldFor(tree)) tree.symbol
-        else tree.symbol.getterIn(tree.symbol.enclClass)
-
+      def derivedName  = tree.name
       def derivedFlags = tree.mods.flags & GetterFlags | ACCESSOR.toLong | ( if (needsSetter) 0 else STABLE )
+      def needsSetter  = tree.mods.isMutable  // implies !lazy
 
-      def needsSetter = tree.mods.isMutable  // implies !lazy
-
-      override def derivedTree =
-        if (tree.mods.isLazy) deriveLazyAccessor
-        else newDefDef(derivedSym, if (Field.noFieldFor(tree)) tree.rhs else Select(This(tree.symbol.enclClass), tree.symbol))(tpt = derivedTpt)
-
-      /** Implements lazy value accessors:
-        *    - for lazy values of type Unit and all lazy fields inside traits,
-        *      the rhs is the initializer itself, because we'll just "compute" the result on every access
-        *     ("computing" unit / constant type is free -- the side-effect is still only run once, using the init bitmap)
-        *    - for all other lazy values z the accessor is a block of this form:
-        *      { z = <rhs>; z } where z can be an identifier or a field.
-        */
-      private def deriveLazyAccessor: DefDef = {
-        val ValDef(_, _, tpt0, rhs0) = tree
-        val rhs1 = context.unit.transformed.getOrElse(rhs0, rhs0)
-        val body =
-          if (tree.symbol.owner.isTrait || Field.noFieldFor(tree)) rhs1 // TODO move tree.symbol.owner.isTrait into noFieldFor
-          else gen.mkAssignAndReturn(tree.symbol, rhs1)
-
-        derivedSym setPos tree.pos // TODO: can we propagate `tree.pos` to `derivedSym` when the symbol is created?
-        val ddefRes = DefDef(derivedSym, new ChangeOwnerTraverser(tree.symbol, derivedSym)(body))
-        // ValDef will have its position focused whereas DefDef will have original correct rangepos
-        // ideally positions would be correct at the creation time but lazy vals are really a special case
-        // here so for the sake of keeping api clean we fix positions manually in LazyValGetter
-        ddefRes.tpt.setPos(tpt0.pos)
-        tpt0.setPos(tpt0.pos.focus)
-        ddefRes
-      }
+      override def derivedTree(derivedSym: Symbol) = {
+        val missingTpt = tree.tpt.isEmpty
+        val tpt = if (missingTpt) TypeTree() else tree.tpt.duplicate
 
-      // 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
-        // the getter. Let the typer do all the work. You might think "why only for
-        // existentials, why not always," and you would be right, except: a single test
-        // fails, but it looked like some work to deal with it. Test neg/t0606.scala
-        // starts compiling (instead of failing like it's supposed to) because the typer
-        // expects to be able to identify escaping locals in typedDefDef, and fails to
-        // spot that brand of them. In other words it's an artifact of the implementation.
-        //
-        // JZ: ... or we could go back to uniformly using explicit result types in all cases
-        //         if we fix `dropExistential`. More details https://github.com/scala/scala-dev/issues/165
-        val getterTp = derivedSym.tpe_*.finalResultType
-        // Range position errors ensue if we don't duplicate this in some
-        // circumstances (at least: concrete vals with existential types.)
-        def inferredTpt = TypeTree() setOriginal (tree.tpt.duplicate setPos tree.tpt.pos.focus)
-        val tpt = getterTp match {
-          case _: ExistentialType => inferredTpt
-          case _ => getterTp.widen match {
-            case _: ExistentialType => inferredTpt
-            case _ if tree.mods.isDeferred => TypeTree() setOriginal tree.tpt // keep type tree of original abstract field
-            case _ => TypeTree(getterTp)
-          }
-        }
-        tpt setPos tree.tpt.pos.focus
-      }
+        val rhs =
+          if (noFieldFor(tree, owner)) tree.rhs // context.unit.transformed.getOrElse(tree.rhs, tree.rhs)
+          else Select(This(tree.symbol.enclClass), tree.symbol)
 
-      def validate() = {
-        assert(derivedSym != NoSymbol, tree)
-        if (derivedSym.isOverloaded)
-          GetterDefinedTwiceError(derivedSym)
+        newDefDef(derivedSym, rhs)(tparams = Nil, vparamss = Nil, tpt = tpt)
       }
 
+//        derivedSym setPos tree.pos
+//        // ValDef will have its position focused whereas DefDef will have original correct rangepos
+//        // ideally positions would be correct at the creation time but lazy vals are really a special case
+//        // here so for the sake of keeping api clean we fix positions manually in LazyValGetter
+//        tpt.setPos(tree.tpt.pos)
+//        tree.tpt.setPos(tree.tpt.pos.focus)
+
     }
 
     case class Setter(tree: ValDef) extends DerivedAccessor {
       def derivedName  = tree.setterName
-      def derivedSym   = tree.symbol.setterIn(tree.symbol.enclClass)
       def derivedFlags = tree.mods.flags & SetterFlags | ACCESSOR
-      def derivedTree  =
-        derivedSym.paramss match {
-          case (setterParam :: Nil) :: _ =>
-            // assert(!derivedSym.isOverloaded, s"Unexpected overloaded setter $derivedSym for ${tree.symbol} in ${tree.symbol.enclClass}")
-            val rhs =
-              if (Field.noFieldFor(tree) || derivedSym.isOverloaded) EmptyTree
-              else Assign(Select(This(tree.symbol.enclClass), tree.symbol), Ident(setterParam))
-
-            DefDef(derivedSym, rhs)
-          case _ => EmptyTree
-        }
-    }
-
-    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
-      //   - concrete vals in traits don't yield a field here either (their getter's RHS has the initial value)
-      //     Constructors 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
-      // 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)
-    }
+      def derivedTree(derivedSym: Symbol)  = {
+        val setterParam = nme.syntheticParamName(1)
 
-    case class Field(tree: ValDef) extends Derived {
-      private val isLazy = tree.mods.isLazy
-
-      // If the owner is not a class, this is a lazy val from a method,
-      // with no associated field.  It has an accessor with $lzy appended to its name and
-      // its flags are set differently.  The implicit flag is reset because otherwise
-      // a local implicit "lazy val x" will create an ambiguity with itself
-      // via "x$lzy" as can be seen in test #3927.
-      private val localLazyVal = isLazy && !owner.isClass
-      private val nameSuffix =
-        if (!localLazyVal) reflect.NameTransformer.LOCAL_SUFFIX_STRING
-        else reflect.NameTransformer.LAZY_LOCAL_SUFFIX_STRING
-
-      def derivedName = tree.name.append(nameSuffix)
-
-      def createSym(getter: MethodSymbol) = {
-        val sym = owner.newValue(derivedName, tree.pos, derivedMods.flags)
-        if (isLazy) sym setLazyAccessor getter
-        sym
-      }
+        // note: tree.tpt may be EmptyTree, which will be a problem when use as the tpt of a parameter
+        // the completer will patch this up (we can't do this now without completing the field)
+        val missingTpt = tree.tpt.isEmpty
+        val tptToPatch = if (missingTpt) TypeTree() else tree.tpt.duplicate
 
-      def derivedSym = tree.symbol
+        val vparams = List(ValDef(Modifiers(PARAM | SYNTHETIC), setterParam, tptToPatch, EmptyTree))
 
-      def derivedMods =
-        if (!localLazyVal) tree.mods & FieldFlags | PrivateLocal | (if (isLazy) MUTABLE else 0)
-        else (tree.mods | ARTIFACT | MUTABLE) & ~IMPLICIT
+        val tpt = TypeTree(UnitTpe)
 
-      // TODO: why is this different from the symbol!?
-      private def derivedModsForTree = tree.mods | PrivateLocal
+        val rhs =
+          if (noFieldFor(tree, owner)) EmptyTree
+          else Assign(Select(This(tree.symbol.enclClass), tree.symbol), Ident(setterParam))
 
-      def derivedTree =
-        if (Field.noFieldFor(tree)) EmptyTree
-        else if (isLazy) copyValDef(tree)(mods = derivedModsForTree, name = derivedName, rhs = EmptyTree).setPos(tree.pos.focus)
-        else copyValDef(tree)(mods = derivedModsForTree, name = derivedName)
+        newDefDef(derivedSym, rhs)(tparams = Nil, vparamss = List(vparams), tpt = tpt)
 
+      }
     }
 
   }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 99c1b6991e..033b6cc0cd 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -129,6 +129,7 @@ trait Namers extends MethodSynthesis {
       !(vd.name startsWith nme.OUTER) && // outer accessors are added later, in explicitouter
       !isEnumConstant(vd)                // enums can only occur in classes, so only check here
 
+
     /** Determines whether this field holds an enum constant.
       * To qualify, the following conditions must be met:
       *  - The field's class has the ENUM flag set
@@ -803,86 +804,89 @@ trait Namers extends MethodSynthesis {
 
     import AnnotationInfo.{mkFilter => annotationFilter}
 
-    def valTypeCompleter(tree: ValDef) = mkTypeCompleter(tree) { sym =>
-      val annots =
-        if (tree.mods.annotations.isEmpty) Nil
-        else annotSig(tree.mods.annotations) filter annotationFilter(FieldTargetClass, !tree.mods.isParamAccessor)
+    def implicitFactoryMethodCompleter(tree: DefDef, classSym: Symbol, sigCompleter: LockingTypeCompleter) = mkTypeCompleter(tree) { methSym =>
+      sigCompleter.completeImpl(methSym)
 
-      sym setInfo typeSig(tree, annots)
+      val annotations = classSym.initialize.annotations
 
-      validate(sym)
+      methSym setAnnotations (annotations filter annotationFilter(MethodTargetClass, defaultRetention = false))
+      classSym setAnnotations (annotations filter annotationFilter(ClassTargetClass, defaultRetention = true))
     }
 
-    /* Explicit isSetter required for bean setters (beanSetterSym.isSetter is false) */
-    def accessorTypeCompleter(tree: ValDef, isSetter: Boolean) = mkTypeCompleter(tree) { sym =>
-      // println(s"triaging for ${sym.debugFlagString} $sym from $valAnnots to $annots")
-
-      // typeSig calls valDefSig (because tree: ValDef)
-      // sym is an accessor, while tree is the field (which may have the same symbol as the getter, or maybe it's the field)
-      // TODO: can we make this work? typeSig is called on same tree (valdef) to complete info for field and all its accessors
-      // reuse work done in valTypeCompleter if we already computed the type signature of the val
-      // (assuming the field and accessor symbols are distinct -- i.e., we're not in a trait)
-//      val valSig =
-//        if ((sym ne tree.symbol) && tree.symbol.isInitialized) tree.symbol.info
-//        else typeSig(tree, Nil) // don't set annotations for the valdef -- we just want to compute the type sig
-
-      val valSig = typeSig(tree, Nil) // don't set annotations for the valdef -- we just want to compute the type sig
-
-      val sig = accessorSigFromFieldTp(sym, isSetter, valSig)
 
+    // complete the type of a value definition (may have a method symbol, for those valdefs that never receive a field,
+    // as specified by Field.noFieldFor)
+    def valTypeCompleter(tree: ValDef) = mkTypeCompleter(tree) { fieldOrGetterSym =>
       val mods = tree.mods
-      if (mods.annotations.nonEmpty) {
-        val annotSigs = annotSig(mods.annotations)
-
-        // neg/t3403: check that we didn't get a sneaky type alias/renamed import that we couldn't detect because we only look at names during synthesis
-        // (TODO: can we look at symbols earlier?)
-        if (!((mods hasAnnotationNamed tpnme.BeanPropertyAnnot) || (mods hasAnnotationNamed tpnme.BooleanBeanPropertyAnnot))
-           && annotSigs.exists(ann => (ann.matches(BeanPropertyAttr)) || ann.matches(BooleanBeanPropertyAttr)))
-          BeanPropertyAnnotationLimitationError(tree)
+      val isGetter = fieldOrGetterSym.isMethod
+      val annots =
+        if (mods.annotations.isEmpty) Nil
+        else {
+          val annotSigs = annotSig(mods.annotations)
+            if (isGetter) filterAccessorAnnots(annotSigs, tree) // if this is really a getter, retain annots targeting either field/getter
+            else annotSigs filter annotationFilter(FieldTargetClass, !mods.isParamAccessor)
+        }
 
-        sym setAnnotations (annotSigs filter filterAccessorAnnotations(isSetter))
-      }
+      // must use typeSig, not memberSig (TODO: when do we need to switch namers?)
+      val sig = typeSig(tree, annots)
 
-      sym setInfo pluginsTypeSigAccessor(sig, typer, tree, sym)
+      fieldOrGetterSym setInfo (if (isGetter) NullaryMethodType(sig) else sig)
 
-      validate(sym)
+      validate(fieldOrGetterSym)
     }
 
-    /* Explicit isSetter required for bean setters (beanSetterSym.isSetter is false) */
-    def beanAccessorTypeCompleter(tree: ValDef, missingTpt: Boolean, isSetter: Boolean) = mkTypeCompleter(tree) { sym =>
-      context.unit.synthetics get sym match {
+    // knowing `isBean`, we could derive `isSetter` from `valDef.name`
+    def accessorTypeCompleter(valDef: ValDef, missingTpt: Boolean, isBean: Boolean, isSetter: Boolean) = mkTypeCompleter(valDef) { accessorSym =>
+      context.unit.synthetics get accessorSym match {
         case Some(ddef: DefDef) =>
-          // sym is an accessor, while tree is the field (for traits it's actually the getter, and we're completing the setter)
+          // `accessorSym` is the accessor for which we're completing the info (tree == ddef),
+          // while `valDef` is the field definition that spawned the accessor
+          // NOTE: `valTypeCompleter` handles abstract vals, trait vals and lazy vals, where the ValDef carries the getter's symbol
+
           // reuse work done in valTypeCompleter if we already computed the type signature of the val
           // (assuming the field and accessor symbols are distinct -- i.e., we're not in a trait)
           val valSig =
-            if ((sym ne tree.symbol) && tree.symbol.isInitialized) tree.symbol.info
-            else typeSig(tree, Nil) // don't set annotations for the valdef -- we just want to compute the type sig
+            if ((accessorSym ne valDef.symbol) && valDef.symbol.isInitialized) valDef.symbol.info
+            else typeSig(valDef, Nil) // don't set annotations for the valdef -- we just want to compute the type sig (TODO: dig deeper and see if we can use memberSig)
 
           // patch up the accessor's tree if the valdef's tpt was not known back when the tree was synthesized
-          if (missingTpt) { // can't look at tree.tpt here because it may have been completed by now
+          // can't look at `valDef.tpt` here because it may have been completed by now (this is why we pass in `missingTpt`)
+          // HACK: a param accessor `ddef.tpt.tpe` somehow gets out of whack with `accessorSym.info`, so always patch it back...
+          //       (the tpt is typed in the wrong namer, using the class as owner instead of the outer context, which is where param accessors should be typed)
+          if (missingTpt || accessorSym.isParamAccessor) {
             if (!isSetter) ddef.tpt setType valSig
             else if (ddef.vparamss.nonEmpty && ddef.vparamss.head.nonEmpty) ddef.vparamss.head.head.tpt setType valSig
-            else throw new TypeError(tree.pos, s"Internal error: could not complete parameter/return type for $ddef from $sym")
+            else throw new TypeError(valDef.pos, s"Internal error: could not complete parameter/return type for $ddef from $accessorSym")
           }
 
+          val mods = valDef.mods
           val annots =
-            if (tree.mods.annotations.isEmpty) Nil
-            else annotSig(tree.mods.annotations) filter filterBeanAccessorAnnotations(isSetter)
+            if (mods.annotations.isEmpty) Nil
+            else filterAccessorAnnots(annotSig(mods.annotations), valDef, isSetter, isBean)
 
-          val sig = typeSig(ddef, annots)
+          // for a setter, call memberSig to attribute the parameter (for a bean, we always use the regular method sig completer since they receive method types)
+          // for a regular getter, make sure it gets a NullaryMethodType (also, no need to recompute it: we already have the valSig)
+          val sig =
+            if (isSetter || isBean) typeSig(ddef, annots)
+            else {
+              if (annots.nonEmpty) annotate(accessorSym, annots)
 
-          sym setInfo pluginsTypeSigAccessor(sig, typer, tree, sym)
+              NullaryMethodType(valSig)
+            }
+
+          accessorSym setInfo pluginsTypeSigAccessor(sig, typer, valDef, accessorSym)
 
-          validate(sym)
+          if (!isBean && accessorSym.isOverloaded)
+            if (isSetter) ddef.rhs.setType(ErrorType)
+            else GetterDefinedTwiceError(accessorSym)
+
+          validate(accessorSym)
 
         case _ =>
-          throw new TypeError(tree.pos, s"Internal error: no synthetic tree found for bean accessor $sym")
+          throw new TypeError(valDef.pos, s"Internal error: no synthetic tree found for bean accessor $accessorSym")
       }
-
     }
 
-
     // 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:
@@ -893,24 +897,33 @@ trait Namers extends MethodSynthesis {
     //
     // 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)
-    private def filterAccessorAnnotations(isSetter: Boolean): AnnotationInfo => Boolean =
-      if (isSetter || !owner.isTrait)
-        annotationFilter(if (isSetter) SetterTargetClass else GetterTargetClass, defaultRetention = false)
-      else (ann =>
-        annotationFilter(FieldTargetClass, defaultRetention = true)(ann) ||
-        annotationFilter(GetterTargetClass, defaultRetention = true)(ann))
-
-    private def filterBeanAccessorAnnotations(isSetter: Boolean): AnnotationInfo => Boolean =
-      if (isSetter || !owner.isTrait)
-        annotationFilter(if (isSetter) BeanSetterTargetClass else BeanGetterTargetClass, defaultRetention = false)
-      else (ann =>
-        annotationFilter(FieldTargetClass, defaultRetention = true)(ann) ||
-          annotationFilter(BeanGetterTargetClass, defaultRetention = true)(ann))
-
-
-    private def accessorSigFromFieldTp(sym: Symbol, isSetter: Boolean, tp: Type): Type =
-      if (isSetter) MethodType(List(sym.newSyntheticValueParam(tp)), UnitTpe)
-      else NullaryMethodType(tp)
+    private def filterAccessorAnnots(annotSigs: List[global.AnnotationInfo], tree: global.ValDef, isSetter: Boolean = false, isBean: Boolean = false): List[AnnotationInfo] = {
+      val mods = tree.mods
+      if (!isBean) {
+        // neg/t3403: check that we didn't get a sneaky type alias/renamed import that we couldn't detect because we only look at names during synthesis
+        // (TODO: can we look at symbols earlier?)
+        if (!((mods hasAnnotationNamed tpnme.BeanPropertyAnnot) || (mods hasAnnotationNamed tpnme.BooleanBeanPropertyAnnot))
+          && annotSigs.exists(ann => (ann.matches(BeanPropertyAttr)) || ann.matches(BooleanBeanPropertyAttr)))
+          BeanPropertyAnnotationLimitationError(tree)
+      }
+
+      def filterAccessorAnnotations: AnnotationInfo => Boolean =
+        if (isSetter || !owner.isTrait)
+          annotationFilter(if (isSetter) SetterTargetClass else GetterTargetClass, defaultRetention = false)
+        else (ann =>
+          annotationFilter(FieldTargetClass, defaultRetention = true)(ann) ||
+            annotationFilter(GetterTargetClass, defaultRetention = true)(ann))
+
+      def filterBeanAccessorAnnotations: AnnotationInfo => Boolean =
+        if (isSetter || !owner.isTrait)
+          annotationFilter(if (isSetter) BeanSetterTargetClass else BeanGetterTargetClass, defaultRetention = false)
+        else (ann =>
+          annotationFilter(FieldTargetClass, defaultRetention = true)(ann) ||
+            annotationFilter(BeanGetterTargetClass, defaultRetention = true)(ann))
+
+      annotSigs filter (if (isBean) filterBeanAccessorAnnotations else filterAccessorAnnotations)
+    }
+
 
     def selfTypeCompleter(tree: Tree) = mkTypeCompleter(tree) { sym =>
       val selftpe = typer.typedType(tree).tpe
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 8449260fe6..8034d056d7 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -450,9 +450,9 @@ abstract class RefChecks extends Transform {
           } else if (other.isStable && !member.isStable) { // (1.4)
             overrideError("needs to be a stable, immutable value")
           } else if (member.isValue && member.isLazy &&
-                     other.isValue && !other.isSourceMethod && !other.isDeferred && !other.isLazy) {
+                     other.isValue && other.hasFlag(STABLE) && !(other.isDeferred || other.isLazy)) {
             overrideError("cannot override a concrete non-lazy value")
-          } else if (other.isValue && other.isLazy && !other.isSourceMethod && !other.isDeferred && // !(other.hasFlag(MODULE) && other.hasFlag(PACKAGE | JAVA)) && other.hasFlag(LAZY)  && (!other.isMethod || other.hasFlag(STABLE)) && !other.hasFlag(DEFERRED)
+          } else if (other.isValue && other.isLazy &&
                      member.isValue && !member.isLazy) {
             overrideError("must be declared lazy to override a concrete lazy value")
           } else if (other.isDeferred && member.isTermMacro && member.extendedOverriddenSymbols.forall(_.isDeferred)) { // (1.9)
@@ -609,7 +609,7 @@ abstract class RefChecks extends Transform {
           val (missing, rest) = memberList partition (m => m.isDeferred && !ignoreDeferred(m))
           // Group missing members by the name of the underlying symbol,
           // to consolidate getters and setters.
-          val grouped = missing groupBy (sym => analyzer.underlyingSymbol(sym).name)
+          val grouped = missing groupBy (_.name.getterName)
           val missingMethods = grouped.toList flatMap {
             case (name, syms) =>
               if (syms exists (_.isSetter)) syms filterNot (_.isGetter)
@@ -651,15 +651,16 @@ abstract class RefChecks extends Transform {
 
             // Give a specific error message for abstract vars based on why it fails:
             // It could be unimplemented, have only one accessor, or be uninitialized.
-            if (underlying.isVariable) {
-              val isMultiple = grouped.getOrElse(underlying.name, Nil).size > 1
+            val groupedAccessors = grouped.getOrElse(member.name.getterName, Nil)
+            val isMultiple = groupedAccessors.size > 1
 
+            if (groupedAccessors.exists(_.isSetter) || (member.isGetter && !isMultiple && member.setterIn(member.owner).exists)) {
               // If both getter and setter are missing, squelch the setter error.
               if (member.isSetter && isMultiple) ()
               else undefined(
                 if (member.isSetter) "\n(Note that an abstract var requires a setter in addition to the getter)"
                 else if (member.isGetter && !isMultiple) "\n(Note that an abstract var requires a getter in addition to the setter)"
-                else analyzer.abstractVarMessage(member)
+                else "\n(Note that variables need to be initialized to be defined)"
               )
             }
             else if (underlying.isMethod) {
@@ -919,17 +920,11 @@ abstract class RefChecks extends Transform {
       var index = -1
       for (stat <- stats) {
         index = index + 1
-        def enterSym(sym: Symbol) = if (sym.isLocalToBlock) {
-          currentLevel.scope.enter(sym)
-          symIndex(sym) = index
-        }
 
         stat match {
-          case DefDef(_, _, _, _, _, _) if stat.symbol.isLazy                 =>
-            enterSym(stat.symbol)
-          case ClassDef(_, _, _, _) | DefDef(_, _, _, _, _, _) | ModuleDef(_, _, _) | ValDef(_, _, _, _) =>
-            //assert(stat.symbol != NoSymbol, stat);//debug
-            enterSym(stat.symbol.lazyAccessorOrSelf)
+          case _ : MemberDef if stat.symbol.isLocalToBlock =>
+            currentLevel.scope.enter(stat.symbol)
+            symIndex(stat.symbol) = index
           case _ =>
         }
       }
@@ -1180,10 +1175,10 @@ abstract class RefChecks extends Transform {
         val tree1 = transform(tree) // important to do before forward reference check
         if (tree1.symbol.isLazy) tree1 :: Nil
         else {
-          val lazySym = tree.symbol.lazyAccessorOrSelf
-          if (lazySym.isLocalToBlock && index <= currentLevel.maxindex) {
+          val sym = tree.symbol
+          if (sym.isLocalToBlock && index <= currentLevel.maxindex) {
             debuglog("refsym = " + currentLevel.refsym)
-            reporter.error(currentLevel.refpos, "forward reference extends over definition of " + lazySym)
+            reporter.error(currentLevel.refpos, "forward reference extends over definition of " + sym)
           }
           tree1 :: Nil
         }
@@ -1451,9 +1446,9 @@ abstract class RefChecks extends Transform {
             )
       }
 
-      sym.isSourceMethod &&
+      sym.name == nme.apply &&
+        !(sym hasFlag STABLE) && // ???
         sym.isCase &&
-        sym.name == nme.apply &&
         isClassTypeAccessible(tree) &&
         !tree.tpe.finalResultType.typeSymbol.primaryConstructor.isLessAccessibleThan(tree.symbol)
     }
diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala
index bee327c760..b66dbf21c0 100644
--- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala
@@ -97,7 +97,7 @@ trait TypeDiagnostics {
   /** An explanatory note to be added to error messages
    *  when there's a problem with abstract var defs */
   def abstractVarMessage(sym: Symbol): String =
-    if (underlyingSymbol(sym).isVariable)
+    if (sym.isSetter || sym.isGetter && sym.setterIn(sym.owner).exists)
       "\n(Note that variables need to be initialized to be defined)"
     else ""
 
@@ -140,7 +140,7 @@ trait TypeDiagnostics {
     * TODO: is it wise to create new symbols simply to generate error message? is this safe in interactive/resident mode?
     */
   def underlyingSymbol(member: Symbol): Symbol =
-    if (!member.hasAccessorFlag || member.owner.isTrait) member
+    if (!member.hasAccessorFlag || member.accessed == NoSymbol) member
     else if (!member.isDeferred) member.accessed
     else {
       val getter = if (member.isSetter) member.getterIn(member.owner) else member
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index a95ecd360c..3360599c1b 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -128,6 +128,15 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
     def canTranslateEmptyListToNil    = true
     def missingSelectErrorTree(tree: Tree, qual: Tree, name: Name): Tree = tree
 
+    // used to exempt synthetic accessors (i.e. those that are synthesized by the compiler to access a field)
+    // from skolemization because there's a weird bug that causes spurious type mismatches
+    // (it seems to have something to do with existential abstraction over values
+    // https://github.com/scala/scala-dev/issues/165
+    // when we're past typer, lazy accessors are synthetic, but before they are user-defined
+    // to make this hack less hacky, we could rework our flag assignment to allow for
+    // requiring both the ACCESSOR and the SYNTHETIC bits to trigger the exemption
+    private def isSyntheticAccessor(sym: Symbol) = sym.isAccessor && (!sym.isLazy || isPastTyper)
+
     // when type checking during erasure, generate erased types in spots that aren't transformed by erasure
     // (it erases in TypeTrees, but not in, e.g., the type a Function node)
     def phasedAppliedType(sym: Symbol, args: List[Type]) = {
@@ -1159,7 +1168,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           adapt(tree setType restpe, mode, pt, original)
         case TypeRef(_, ByNameParamClass, arg :: Nil) if mode.inExprMode => // (2)
           adapt(tree setType arg, mode, pt, original)
-        case tp if mode.typingExprNotLhs && isExistentialType(tp) =>
+        case tp if mode.typingExprNotLhs && isExistentialType(tp) && !isSyntheticAccessor(context.owner) =>
           adapt(tree setType tp.dealias.skolemizeExistential(context.owner, tree), mode, pt, original)
         case PolyType(tparams, restpe) if mode.inNone(TAPPmode | PATTERNmode) && !context.inTypeConstructorAllowed => // (3)
           // assert((mode & HKmode) == 0) //@M a PolyType in HKmode represents an anonymous type function,
@@ -1373,13 +1382,7 @@ 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 =>
@@ -1956,11 +1959,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       if (!phase.erasedTypes && !clazz.info.resultType.isError) // @S: prevent crash for duplicated type members
         checkFinitary(clazz.info.resultType.asInstanceOf[ClassInfoType])
 
-      val body2 = {
-        val body2 =
-          if (isPastTyper || reporter.hasErrors) body1
-          else body1 flatMap rewrappingWrapperTrees(namer.addDerivedTrees(Typer.this, _))
-        val primaryCtor = treeInfo.firstConstructor(body2)
+      val bodyWithPrimaryCtor = {
+        val primaryCtor = treeInfo.firstConstructor(body1)
         val primaryCtor1 = primaryCtor match {
           case DefDef(_, _, _, _, _, Block(earlyVals :+ global.pendingSuperCall, unit)) =>
             val argss = superArgs(parents1.head) getOrElse Nil
@@ -1969,10 +1969,10 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
             deriveDefDef(primaryCtor)(block => Block(earlyVals :+ superCall, unit) setPos pos) setPos pos
           case _ => primaryCtor
         }
-        body2 mapConserve { case `primaryCtor` => primaryCtor1; case stat => stat }
+        body1 mapConserve { case `primaryCtor` => primaryCtor1; case stat => stat }
       }
 
-      val body3 = typedStats(body2, templ.symbol)
+      val body3 = typedStats(bodyWithPrimaryCtor, templ.symbol)
 
       if (clazz.info.firstParent.typeSymbol == AnyValClass)
         validateDerivedValueClass(clazz, body3)
@@ -2436,13 +2436,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
             case _ =>
           }
         }
-        val stats1 = if (isPastTyper) block.stats else
-          block.stats.flatMap {
-            case vd@ValDef(_, _, _, _) if vd.symbol.isLazy =>
-              namer.addDerivedTrees(Typer.this, vd)
-            case stat => stat::Nil
-          }
-        val stats2 = typedStats(stats1, context.owner, warnPure = false)
+        val statsTyped = typedStats(block.stats, context.owner, warnPure = false)
         val expr1 = typed(block.expr, mode &~ (FUNmode | QUALmode), pt)
 
         // sanity check block for unintended expr placement
@@ -2456,18 +2450,18 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           def checkPure(t: Tree, supple: Boolean): Unit =
             if (treeInfo.isPureExprForWarningPurposes(t)) {
               val msg = "a pure expression does nothing in statement position"
-              val parens = if (stats2.length + count > 1) "multiline expressions might require enclosing parentheses" else ""
+              val parens = if (statsTyped.length + count > 1) "multiline expressions might require enclosing parentheses" else ""
               val discard = if (adapted) "; a value can be silently discarded when Unit is expected" else ""
               val text =
                 if (supple) s"${parens}${discard}"
                 else if (!parens.isEmpty) s"${msg}; ${parens}" else msg
               context.warning(t.pos, text)
             }
-          stats2.foreach(checkPure(_, supple = false))
+          statsTyped.foreach(checkPure(_, supple = false))
           if (result0.nonEmpty) checkPure(result0, supple = true)
         }
 
-        treeCopy.Block(block, stats2, expr1)
+        treeCopy.Block(block, statsTyped, expr1)
           .setType(if (treeInfo.isExprSafeToInline(block)) expr1.tpe else expr1.tpe.deconst)
       } finally {
         // enable escaping privates checking from the outside and recycle
@@ -3171,6 +3165,10 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
             case (ClassDef(cmods, cname, _, _), DefDef(dmods, dname, _, _, _, _)) =>
               cmods.isImplicit && dmods.isImplicit && cname.toTermName == dname
 
+            // ValDef and Accessor
+            case (ValDef(_, cname, _, _), DefDef(_, dname, _, _, _, _)) =>
+              cname.getterName == dname.getterName
+
             case _ => false
           }
 
@@ -4455,8 +4453,9 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
         def narrowRhs(tp: Type) = { val sym = context.tree.symbol
           context.tree match {
             case ValDef(mods, _, _, Apply(Select(`tree`, _), _)) if !mods.isMutable && sym != null && sym != NoSymbol =>
-              val sym1 = if (sym.owner.isClass && sym.getterIn(sym.owner) != NoSymbol) sym.getterIn(sym.owner)
-                else sym.lazyAccessorOrSelf
+              val sym1 =
+                if (sym.owner.isClass && sym.getterIn(sym.owner) != NoSymbol) sym.getterIn(sym.owner)
+                else sym
               val pre = if (sym1.owner.isClass) sym1.owner.thisType else NoPrefix
               intersectionType(List(tp, singleType(pre, sym1)))
             case _ => tp