Syntax change for type parameters of extension methods

[odersky]

The new syntax has the type parameters come first. I.e.

  def [T](xs: List[T]) append (ys: List[T]): List[T] = ...

instead of

  def (xs: List[T]) append [T] (ys: List[T]): List[T] = ...

Application is unchanged, so it is still

  xs.append[String](ys)

An argument for the old syntax is that it aligns definition and call syntax.
On the other hand, the new syntax maintains the general rule that parameter introductions
always com before parameter uses. The decisive argument to switch is to be consistent
with the new collective parameter syntax, where append would be written like this:

  given [T](xs: List[T])
    def append (ys: List[T]): List[T] = ...

To avoid misalignment of type parameters between definition and call syntax, we considered
disallowing explicit type parameters for extension methods altogether, and to require
that the method is called as a normal method instead. But that would not work for anonymous
givens as in the last exaple above.

[allanrenucci]

I would add a neg test:

// dotc -Xfatal-warnings

def (self: T) foo[T] = ??? // error
def [T1](self: T1) bar[T2] = ??? // error

[allanrenucci]

Nit: def extParamss() since the function is effectful

[allanrenucci]

As usual, type parameters of the extension method follow the defined method name. Nevertheless, such type parameters can already be used in the preceding parameter clause.

This need to be updated. Also I would add a paragraph about the position of explicit type parameters at call site.

[yinshurman]

Aha, another weird special rule which breaks again the consistency of the language.
it just looks like the type parameter T belongs to a anonymous method rather than the append.

another funny thing is that to support
"the general rule that parameter introductions
always come before parameter uses" , scala now is full of special rule and breaks the logic that a parameter always belongs to and hence comes after some thing like function or class.
besides, to support this weird special exceptional syntax, you introduce another special limits.on extension methods,and the final syntax becomes quite ugly.