Make some types of definitions symbolic

This is needed to ensure that the type of a definition node
(ValDef, TypeDef, or DefDef) always refers to the symbol of
that definition.

Caused a spurious error in selfReq to go away (so error count was
updated).

1 files changed, 11 insertions, 11 deletions

diff --git a/tests/neg/overrides.scala b/tests/neg/overrides.scala
index 9fe06d930..727759e3c 100644
--- a/tests/neg/overrides.scala
+++ b/tests/neg/overrides.scala
@@ -8,7 +8,7 @@
   }
   trait FooB extends FooA {
     type A <: Ax;
-    trait Ax extends super.Ax { def xxx : Int; }
+    trait Ax extends super.Ax { def xxx : Int; } // error: classes cannot be overridden
     abstract class InnerB extends InnerA {
       // type B <: A;
       val a : A = doB;
@@ -31,7 +31,7 @@ package p2 { // all being in the same package compiles fine
   }
 
   abstract class T3 extends T2 {
-    class A {
+    class A {   // error: classes cannot be overridden
       bug()
     }
   }
@@ -45,7 +45,7 @@ class A[T] {
 
 class B extends A[Int] {
 
-  def f(x: Int)(y: Int) = y
+  def f(x: Int)(y: Int) = y // error: needs `override' modifier
 
   f(2)()
 
@@ -55,7 +55,7 @@ class X {
   def f: A[Int] = ???
 }
 class Y extends X {
-  def f: A[Int] = ???
+  def f: A[Int] = ??? // error: needs `override' modifier
 }
 
 
@@ -66,18 +66,18 @@ class X1 {
   def f(): A1 = ???
 }
 class Y1 extends X1 {
-  override def f(): B1 = ???
+  override def f(): B1 = ??? // error: has incompatible type
 }
 
 class X2 {
   type T = A1
 }
 class Y2 extends X2 {
-  type T = B1
+  type T = B1 // error: needs `override' modifier
 }
 
 class X3 {
-  override type T = A1
+  override type T = A1 // error: overrides nothing
 }
 
 package p3 {
@@ -97,14 +97,14 @@ trait TOverrider { this: TCommon =>
   override def f = "in TOverrider"   // The overridden self-type member...
 }
 
-class C2 extends C1 with TOverrider  // ... fails to override, here.
+class C2 extends C1 with TOverrider  // ... fails to override, here. // error: accidental override
 
 }
 
 package p4 {
 
   abstract class C[T] { def head: T }
-  case class D[T](head: Int) extends C[T]
+  case class D[T](head: Int) extends C[T] // error: has incompatible type
 
 }
 
@@ -114,10 +114,10 @@ class A {
 }
 
 class B extends A {
-  override val m: Int = 42
+  override val m: Int = 42 // error: has incompatible type
 }
 
 class C extends A {
-  override def m: Int = 42
+  override def m: Int = 42 // error: has incompatible type
 }
 }