Why is PRESUPER special to the typer?

Hi

I am again trying to battle the early inits and allowing abstract
val/vars in the early defs, but there is somethink that puzles me, why
is PRESUPER so special regarding the typer? Let me show an example

This little program (with the new early syntax):

trait NeedsXEarly {
val x: Int
super
val s: Int
}

Fails with the following error.

test.scala:2: error: missing parameter type
val x: Int
^
This error is generated in the Namers.scala, in the typeSig method in
the pattern match at line 1114 and down.
So that is the error, but I looked at what the ValDef contain in the
above pattern match by adding this line in the beginning of the case:

println("In namer: " + name + " with flags " + flagsToString(mods.flags)
+ " tpt=" + tpt + ",tpt.isEmpty=" + tpt.isEmpty + ",tpt.isType=" +
tpt.isType + " rhs=" + rhs)

This will print the information in the ValDef, now running the example
again through the compiler I get:

In namer: x with flags tpt=,tpt.isEmpty=true,tpt.isType=true rhs=
test.scala:2: error: missing parameter type
val x: Int
^
In namer: s with flags tpt=Int,tpt.isEmpty=false,tpt.isType=true rhs=
[[syntax trees at end of typer]]// Scala source: test.scala
package {
abstract trait NeedsXEarly extends scala.AnyRef {
def x: ;
def s: Int
}
}

one error found

It is clearly the case that both x and s are abstract vals, but only s
has a concrete type Int and x has an "original type" of int, but why...
because it is a PRESUPER? Does the typer handle that in any special way?

The reason I ask is because I have looked at all the usages of the
PRESUPER flag in the parser, namer and typer and I cant really see why
is should matter that x is a PRESUPER at this stage. The unwanted stuff
(things that are not supposed to be in the PRESUPER part) are rejected
in the parser.

/Anders