Infer result type for vals, like we do for defs

The lack of result type inference caused pos/t6780 to fail
in the new field encoding for traits, as there is no separate accessor,
and method synthesis computes the type signature based on the ValDef tree.
This caused a cyclic error in implicit search, because now the
implicit val's result type was not inferred from the super member,
and inferring it from the RHS would cause implicit search to consider
the member in question, so that a cycle is detected and type checking fails...

Regardless of the new encoding, we should consistently infer result types
for `def`s and `val`s.

Removed test/files/run/t4287inferredMethodTypes.scala and test/files/presentation/t4287c,
since they were relying on inferring argument types from "overridden" constructors
in a test for range positions of default arguments. Constructors don't override,
so that was a mis-feature of -Yinfer-argument-types.

Had to slightly refactor test/files/presentation/doc, as it was relying
on scalac inferring a big intersection type to approximate the anonymous
class that's instantiated for `override lazy val analyzer`.
Now that we infer `Global` as the expected type based on the overridden val,
we make `getComment` private in navigating between good old Skylla and Charybdis.
I'm not sure why we need this restriction for anonymous classes though;
only structural calls are restricted in the way that we're trying to avoid.

Author: adriaanm

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

@@ -0,0 +1,6 @@
+val_infer.scala:3: error: type mismatch;
+ found   : String("")
+ required: Int
+  trait Sub extends Base { val foo = "" }
+                                     ^
+one error found

test/files/neg/val_infer.check

@@ -0,0 +1,4 @@
+class Test {
+  trait Base { def foo: Int }
+  trait Sub extends Base { val foo = "" }
+}

test/files/neg/val_infer.scala

@@ -0,0 +1,5 @@
+abstract class A { def foo(a: Int): A }
+class B extends A {
+  implicit def spackle(x: Int): A = new B
+  def foo(a) = a
+}

test/files/presentation/t4287c.flags renamed to test/files/pos/infer_override_def_args.flags

@@ -0,0 +1,5 @@
+class Test {
+  implicit def s2i(s: String): Int = s.length
+  trait Base { def foo: Int }
+  trait Sub extends Base { val foo = "" }
+}

test/files/pos/infer_override_def_args.scala

@@ -37,7 +37,7 @@ object Test extends InteractiveTest {
     prepre + docComment(nTags) + prepost + post
   }
 
-  override lazy val compiler = {
+  override lazy val compiler: Global { def getComment(sym: Symbol, source: SourceFile, fragments: List[(Symbol,SourceFile)]): Option[Comment] } = {
     prepareSettings(settings)
     new Global(settings, compilerReporter) with MemberLookupBase with CommentFactoryBase with doc.ScaladocGlobalTrait {
       outer =>

test/files/pos/val_infer.scala

@@ -8,7 +8,7 @@ initialized y: lazy val y: Int
 uninitialized z: def z: <?>
 initialized z: def z: Int
 uninitialized t: def t: <?>
-initialized t: def t[T <: Int](x: D)(y: x.W): Int
+initialized t: def t[T <: <?>](x: D)(y: x.W): Int
 uninitialized W: type W = String
 initialized W: type W = String
 uninitialized C: class C extends 

test/files/presentation/doc/doc.scala

@@ -9,7 +9,7 @@ object Macros {
     import c.universe._
     def test(sym: Symbol): Unit = {
       println(s"uninitialized ${sym.name}: ${showDecl(sym)}")
-      sym.info
+      sym.info // NOTE: not fullyInitializeSymbol, so some parts may still be LazyTypes
       println(s"initialized ${sym.name}: ${showDecl(sym)}")
     }