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

3 files changed, 25 insertions, 19 deletions

diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 487aadf5e5..10ae68cdd1 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -655,7 +655,6 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       isClass && isFinal && loop(typeParams)
     }
 
-    final def isLazyAccessor       = isLazy && lazyAccessor != NoSymbol
     final def isOverridableMember  = !(isClass || isEffectivelyFinal) && safeOwner.isClass
 
     /** Does this symbol denote a wrapper created by the repl? */
@@ -2075,11 +2074,11 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
      */
     def alias: Symbol = NoSymbol
 
-    /** For a lazy value, its lazy accessor. NoSymbol for all others. */
+    @deprecated("No longer applicable, as lazy vals are not desugared until the fields phase", "2.12.0") // used by scala-refactoring
     def lazyAccessor: Symbol = NoSymbol
 
-    /** If this is a lazy value, the lazy accessor; otherwise this symbol. */
-    def lazyAccessorOrSelf: Symbol = if (isLazy) lazyAccessor else this
+    @deprecated("No longer applicable, as lazy vals are not desugared until the fields phase", "2.12.0")
+    def lazyAccessorOrSelf: Symbol = NoSymbol
 
     /** `accessed`, if this is an accessor that should have an underlying field. Otherwise, `this`.
       *  Note that a "regular" accessor in a trait does not have a field, as an interface cannot define a field.
@@ -2088,7 +2087,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       *  as they are an implementation detail that's irrelevant to type checking.
       */
     def accessedOrSelf: Symbol =
-      if (hasAccessorFlag && (!owner.isTrait || hasFlag(PRESUPER | LAZY))) accessed
+      if (hasAccessorFlag && (!owner.isTrait || hasFlag(PRESUPER))) accessed
       else this
 
     /** For an outer accessor: The class from which the outer originates.
@@ -2834,17 +2833,6 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       this
     }
 
-    def setLazyAccessor(sym: Symbol): TermSymbol = {
-      assert(isLazy && (referenced == NoSymbol || referenced == sym), (this, debugFlagString, referenced, sym))
-      referenced = sym
-      this
-    }
-
-    override def lazyAccessor: Symbol = {
-      assert(isLazy, this)
-      referenced
-    }
-
     /** change name by appending $$<fully-qualified-name-of-class `base`>
      *  Do the same for any accessed symbols or setters/getters
      */
diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index b9f3e987ee..61937958dd 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -293,6 +293,26 @@ abstract class TreeInfo {
     }
   }
 
+
+  // No field for these vals, which means the ValDef carries the symbol of the getter (and not the field symbol)
+  //   - abstract vals have no value we could store (until they become concrete, potentially)
+  //   - lazy vals: the ValDef carries the symbol of the lazy accessor.
+  //     The sausage factory will spew out the inner workings during the fields phase (actual bitmaps won't follow
+  //     until lazyvals & mixins, though we should move this stuff from mixins to lazyvals now that fields takes care of mixing in lazy vals)
+  //   - 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
+  //
+  // The following case does receive a field symbol (until it's eliminated during the fields phase):
+  //   - 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.
+  def noFieldFor(vd: ValDef, owner: Symbol) = vd.mods.isDeferred || vd.mods.isLazy || (owner.isTrait && !vd.mods.hasFlag(PRESUPER))
+
+
   def isDefaultGetter(tree: Tree) = {
     tree.symbol != null && tree.symbol.isDefaultGetter
   }
diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
index 4bc804445c..c6cb0d0223 100644
--- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
@@ -227,9 +227,7 @@ abstract class UnPickler {
             return NoSymbol
 
           if (tag == EXTMODCLASSref) {
-            val moduleVar = owner.info.decl(nme.moduleVarName(name.toTermName))
-            if (moduleVar.isLazyAccessor)
-              return moduleVar.lazyAccessor.lazyAccessor
+            owner.info.decl(nme.moduleVarName(name.toTermName))
           }
           NoSymbol
         }