Remove type currying

This adds back the TypeApply case that was present in Applications.scala.
With it is an improved error message that shows a potential fix.

Author: Sporarum

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3101,7 +3101,7 @@ object Parsers {
 
     end typeOrTermParamClause
 
-    /** DefParamClauses       ::= DefParamClause { DefParamClause }
+    /** DefParamClauses       ::= DefParamClause { DefParamClause }  -- and two DefTypeParamClause cannot be adjacent
      */
     def typeOrTermParamClauses(
       ownerKind: ParamOwner,
@@ -3111,7 +3111,7 @@ object Parsers {
       numLeadParams: Int = 0
     ): List[List[TypeDef] | List[ValDef]] =
 
-      def recur(firstClause: Boolean, numLeadParams: Int): List[List[TypeDef] | List[ValDef]] =
+      def recur(firstClause: Boolean, numLeadParams: Int, prevIsTypeClause: Boolean): List[List[TypeDef] | List[ValDef]] =
         newLineOptWhenFollowedBy(LPAREN)
         newLineOptWhenFollowedBy(LBRACKET)
         if in.token == LPAREN then
@@ -3125,13 +3125,18 @@ object Parsers {
           val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
           params :: (
             if lastClause then Nil
-            else recur(firstClause = false, numLeadParams + params.length))
+            else recur(firstClause = false, numLeadParams + params.length, prevIsTypeClause = false))
         else if in.token == LBRACKET then
-          typeParamClause(ownerKind) :: recur(firstClause, numLeadParams)
+          if prevIsTypeClause then
+            syntaxError(
+              em"Type parameter lists must be separated by a term or using parameter list",
+              in.offset
+            )
+          typeParamClause(ownerKind) :: recur(firstClause, numLeadParams, prevIsTypeClause = true)
         else Nil
       end recur
 
-      recur(firstClause = true, numLeadParams = numLeadParams)
+      recur(firstClause = true, numLeadParams = numLeadParams, prevIsTypeClause = false)
     end typeOrTermParamClauses
 
 

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1151,6 +1151,12 @@ trait Applications extends Compatibility {
     val typedArgs = if (isNamed) typedNamedArgs(tree.args) else tree.args.mapconserve(typedType(_))
     record("typedTypeApply")
     typedExpr(tree.fun, PolyProto(typedArgs, pt)) match {
+      case fun: TypeApply if !ctx.isAfterTyper =>
+        val function = fun.fun
+        val args = (fun.args ++ tree.args).map(_.show).mkString(", ")
+        errorTree(tree, em"""illegal repeated type application
+                            |You might have meant something like:
+                            |${function}[${args}]""")
       case typedFn =>
         typedFn.tpe.widen match {
           case pt: PolyType =>

docs/_docs/internals/syntax.md

@@ -361,7 +361,7 @@ ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation}                                             ValDef(mods, id, tpe, expr) -- point of mods on val/var
                        [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
 
-DefParamClauses   ::=  DefParamClause { DefParamClause }
+DefParamClauses   ::=  DefParamClause { DefParamClause } -- and two DefTypeParamClause cannot be adjacent
 DefParamClause    ::=  DefTypeParamClause 
                     |  DefTermParamClause 
                     |  UsingParamClause
@@ -427,7 +427,7 @@ Dcl               ::=  RefineDcl
                     |  ‘var’ VarDcl
 ValDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 VarDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
-DefDcl            ::=  DefSig ‘:’ Type                                          DefDef(_, name, tparams, vparamss, tpe, EmptyTree)
+DefDcl            ::=  DefSig ‘:’ Type                                          DefDef(_, name, paramss, tpe, EmptyTree)
 DefSig            ::=  id [DefParamClauses] [DefImplicitClause]
 TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds         TypeDefTree(_, name, tparams, bound
                        [‘=’ Type]

docs/_docs/reference/other-new-features/generalized-method-syntax.md

@@ -18,11 +18,11 @@ def foo[T, U](x: T)(y: U)(z: Int, s: String)(a: Array[T])(implicit ordInt: Ord[I
 
 ### In Scala 3
 
-The new syntax allows any number of type, term and using clause, in any order, optionnaly followed by an implicit clause:
+The new syntax allows any number of type clauses, as long as they are not adjacent:
 (do note however that [implicit clause are discouraged, in favor of using clauses](https://docs.scala-lang.org/scala3/reference/contextual/relationship-implicits.html))
 
 ```scala
-def foo[T, U](x: T)(y: U)[V](z: V, s: String)[A](a: Array[A])(implicit List[U])
+def foo[T, U](x: T)(y: U)[V](z: V, s: String)(using Ord[Int])[A](a: Array[A])(implicit List[U])
 ```
 
 ### Unchanged
@@ -48,15 +48,6 @@ trait DB {
 Note that simply replacing `V` by `k.Value` would not be equivalent. For example, if `k.Value` is `Some[Int]`, only the above allows: 
 `getOrElse(k)[Option[Int]](None)`, which returns a `Number`.
 
-### Partial Inference
-
-It is now possible to only infer some of the type parameters, this reduces boilerplate at the use site:
-```scala
-trait StaticSizeList[S <: Int & Singleton, T]
-def filled[S <: Int & Singleton][T](x: T): StaticSizeList[S,T] = ???
-val helloes = filled[4]("Hello!") // S=4, and T is inferred
-```
-
 ## Details
 
 ### Application
@@ -90,9 +81,9 @@ On the other hand, the `getOrElse` method is recommended as-is, as it cannot be
 DefDcl            ::=  DefSig ‘:’ Type
 DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr
 DefSig            ::=  id [DefParamClauses] [DefImplicitClause]
-DefParamClauses   ::=  DefParamClause { DefParamClause }
-DefParamClause    ::=  DefTypeParamClause 
-                    |  DefTermParamClause 
+DefParamClauses   ::=  DefParamClause { DefParamClause } -- and two DefTypeParamClause cannot be adjacent
+DefParamClause    ::=  DefTypeParamClause
+                    |  DefTermParamClause
                     |  UsingParamClause
 DefTypeParamClause::=  [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
 DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds

docs/_docs/reference/syntax.md

@@ -350,7 +350,7 @@ ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
 ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation} [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
 
-DefParamClauses   ::=  DefParamClause { DefParamClause }
+DefParamClauses   ::=  DefParamClause { DefParamClause } -- and two DefTypeParamClause cannot be adjacent
 DefParamClause    ::=  DefTypeParamClause 
                     |  DefTermParamClause 
                     |  UsingParamClause