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.

Author: adriaanm

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

@@ -1372,12 +1372,31 @@ trait Namers extends MethodSynthesis {
           MissingParameterOrValTypeError(tpt)
           ErrorType
         }
-        else assignTypeToTree(vdef, typer, WildcardType)
+        else {
+          val valOwner = owner.owner
+          val pt =
+            // there's no overriding outside of classes
+            if (!valOwner.isClass) WildcardType
+            else {
+              // Pretend we're an erroneous symbol, for now, so that we match while finding the overridden symbol,
+              // but are not considered during implicit search.
+              // The symbol's info is currently being determined (up the call stack, you'll find a TypeCompleter's complete method),
+              // so the info will be set to whatever type we return here by the complete method.
+              val saved = vdef.symbol.rawInfo
+              try {
+                vdef.symbol setInfo ErrorType
+                val overridden = vdef.symbol.nextOverriddenSymbol
+                if (overridden == NoSymbol || overridden.isOverloaded) WildcardType
+                else valOwner.thisType.memberType(overridden).resultType
+              } finally vdef.symbol.setInfo(saved)
+            }
+
+          assignTypeToTree(vdef, typer, pt) // defines (based on `pt`) and returns `vdef.tpt.tpe`
+        }
       } else {
         typer.typedType(tpt).tpe
       }
       pluginsTypeSig(result, typer, vdef, if (tpt.isEmpty) WildcardType else result)
-
     }
 
     //@M! an abstract type definition (abstract type member/type parameter)