Disallow variances in type lambdas

Since variances are associated conceptually with higher-kinded type variables,
it makes no sense to write them on type lambdas. I believe it's better to disallow
writing variances there because it will only need to variance-bike-shedding otherwise.

Author: odersky

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

@@ -2845,27 +2845,33 @@ object Parsers {
      *  HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (id [HkTypePamClause] | ‘_’) TypeBounds
      */
     def typeParamClause(ownerKind: ParamOwner.Value): List[TypeDef] = inBrackets {
+
+      def variance(vflag: FlagSet): FlagSet =
+        if ownerKind == ParamOwner.Def || ownerKind == ParamOwner.TypeParam then
+          syntaxError(i"no `+/-` variance annotation allowed here")
+          in.nextToken()
+          EmptyFlags
+        else
+          in.nextToken()
+          vflag
+
       def typeParam(): TypeDef = {
         val isAbstractOwner = ownerKind == ParamOwner.Type || ownerKind == ParamOwner.TypeParam
         val start = in.offset
         val mods =
-          annotsAsMods() | {
-            if (ownerKind == ParamOwner.Class) Param | PrivateLocal
-            else Param
-          } | {
-            if (ownerKind == ParamOwner.Def) EmptyFlags
-            else if (isIdent(nme.raw.PLUS)) { in.nextToken(); Covariant }
-            else if (isIdent(nme.raw.MINUS)) { in.nextToken(); Contravariant }
-            else EmptyFlags
-          }
+          annotsAsMods()
+          | (if (ownerKind == ParamOwner.Class) Param | PrivateLocal else Param)
+          | (if isIdent(nme.raw.PLUS) then variance(Covariant)
+             else if isIdent(nme.raw.MINUS) then variance(Contravariant)
+             else EmptyFlags)
         atSpan(start, nameStart) {
           val name =
             if (isAbstractOwner && in.token == USCORE) {
               in.nextToken()
               WildcardParamName.fresh().toTypeName
             }
             else ident().toTypeName
-          val hkparams = typeParamClauseOpt(ParamOwner.TypeParam)
+          val hkparams = typeParamClauseOpt(ParamOwner.Type)
           val bounds = if (isAbstractOwner) typeBounds() else typeParamBounds(name)
           TypeDef(name, lambdaAbstract(hkparams, bounds)).withMods(mods)
         }

docs/docs/internals/syntax.md

@@ -295,7 +295,7 @@ TypTypeParamClause::=  ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
 TypTypeParam      ::=  {Annotation} id [HkTypeParamClause] SubtypeBounds
 
 HkTypeParamClause ::=  ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
-HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (Id[HkTypeParamClause] | ‘_’)
+HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (id [HkTypeParamClause] | ‘_’)
                        SubtypeBounds
 
 ClsParamClauses   ::=  {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]

docs/docs/reference/new-types/type-lambdas-spec.md

@@ -6,9 +6,9 @@ title: "Type Lambdas - More Details"
 ## Syntax
 
 ```
-Type              ::=  ... |  HkTypeParamClause ‘=>>’ Type
-HkTypeParamClause ::=  ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
-HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (Id[HkTypeParamClause] | ‘_’) TypeBounds
+Type            ::=  ... |  TypeParamClause ‘=>>’ Type
+TypeParamClause ::=  ‘[’ TypeParam {‘,’ TypeParam} ‘]’
+TypeParam       ::=  {Annotation} (id [HkTypeParamClause] | ‘_’) TypeBounds
 TypeBounds        ::=  [‘>:’ Type] [‘<:’ Type]
 ```
 
@@ -18,44 +18,28 @@ A type lambda such as `[X] =>> F[X]` defines a function from types to types. The
 If a parameter is bounded, as in `[X >: L <: H] =>> F[X]` it is checked that arguments to the parameters conform to the bounds `L` and `H`.
 Only the upper bound `H` can be F-bounded, i.e. `X` can appear in it.
 
-A variance annotation on a parameter indicates a subtyping relationship on type instances. For instance, given
-```scala
-type TL1 = [+A] =>> F[A]
-type TL2 = [-A] =>> F[A]
-```
-and two types `S <: T`, we have
-```scala
-TL1[S] <: TL1[T]
-TL2[T] <: TL2[S]
-```
-It is checked that variance annotations on parameters of type lambdas are respected by the parameter occurrences on the type lambda's body.
-
-**Note** No requirements hold for the variances of occurrences of type variables in their bounds. It is an open question whether we need to impose additional requirements here
-(`scalac` doesn't check variances in bounds either).
-
 ## Subtyping Rules
 
 Assume two type lambdas
 ```scala
-type TL1  =  [v1 X >: L1 <: U1] =>> R1
-type TL2  =  [v2 X >: L2 <: U2] =>> R2
+type TL1  =  [X >: L1 <: U1] =>> R1
+type TL2  =  [X >: L2 <: U2] =>> R2
 ```
-where `v1` and `v2` are optional variance annotations: `+`, `-`, or absent.
 Then `TL1 <: TL2`, if
 
  - the type interval `L2..U2` is contained in the type interval `L1..U1` (i.e.
 `L1 <: L2` and `U2 <: U1`),
- - either `v2` is absent or `v1 = v2`
  - `R1 <: R2`
 
 Here we have relied on alpha renaming to bring match the two bound types `X`.
 
 A partially applied type constructor such as `List` is assumed to be equivalent to
-its eta expansion. I.e, `List = [+X] =>> List[X]`. This allows type constructors
-to be compared with type lambdas.
+its eta expansion. I.e, `List = [X] =>> List[X]`. This allows type constructors to be compared with type lambdas.
 
 ## Relationship with Parameterized Type Definitions
 
+type F[X] <: List[F[X]]
+
 A parameterized type definition
 ```scala
 type T[X] = R
@@ -64,6 +48,17 @@ is regarded as a shorthand for an unparameterized definition with a type lambda
 ```scala
 type T = [X] =>> R
 ```
+If the a type definition carries `+` or `-` variance annotations,
+it is checked that the variance annotations are satisfied by the type lambda.
+For instance,
+```scala
+type F2[A, +B] = A => B
+```scala
+expands to
+```scala
+type F2 = [A, B] =>> A => B
+```
+and at the same time it is checked that the parameter `B` appears covariantly in `A => B`.
 
 A parameterized abstract type
 ```scala
@@ -75,15 +70,15 @@ type T >: ([X] =>> L) <: ([X] =>> U)
 ```
 However, if `L` is `Nothing` it is not parameterized, since `Nothing` is treated as a bottom type for all kinds. For instance,
 ```scala
-type T[-X] <: X => ()
+type T[X] <: X => X
 ```
 is expanded to
 ```scala
-type T >: Nothing <: ([-X] =>> X => ())
+type T >: Nothing <: ([X] =>> X => X)
 ```
 instead of
 ```scala
-type T >: ([X] =>> Nothing) <: ([-X] =>> X => ())
+type T >: ([X] =>> Nothing) <: ([X] =>> X => X)
 ```
 
 The same expansions apply to type parameters. E.g.
@@ -94,6 +89,20 @@ is treated as a shorthand for
 ```scala
 [F >: Nothing <: [X] =>> Coll[X]]
 ```
+Abstract types and opaque type aliases remember the variances they were created with. So the type
+```scala
+def F2[-A, +B]
+```
+is known to be covariant in `A` and contravariant in `B` and can be instantiated only
+with types that satisfy these constraints. Likewise
+```scala
+opaque type O[X] = List[X]
+```
+`O` is known to be invariant (and not covariant, as its right hand side would suggest). On the other hand, a transparent alias
+```scala
+type O2[X] = List[X]
+```
+would be treated as covariant, `X` is used covariantly on its right-hand side.
 
 **Note**: The decision to treat `Nothing` as universal bottom type is provisional, and might be changed afer further discussion.
 

docs/docs/reference/new-types/type-lambdas.md

@@ -7,24 +7,12 @@ A _type lambda_ lets one express a higher-kinded type directly, without
 a type definition.
 
 ```scala
-[+X, Y] =>> Map[Y, X]
+[X, Y] =>> Map[Y, X]
 ```
 
-For instance, the type above defines a binary type constructor, with a
-covariant parameter `X` and a non-variant parameter `Y`. The
+For instance, the type above defines a binary type constructor, which
 constructor maps arguments `X` and `Y` to `Map[Y, X]`. Type parameters
-of type lambdas can have variances and bounds. A parameterized type
-definition or declaration such as
-
-```scala
-type T[X] = (X, X)
-```
-
-is a shorthand for a plain type definition with a type-lambda as its
-right-hand side:
-
-```scala
-type T = [X] =>> (X, X)
-```
+of type lambdas can have bounds but they cannot carry `+` or `-` variance
+annotations.
 
 [More details](./type-lambdas-spec.md)

tests/neg/i6475.scala

@@ -0,0 +1,4 @@
+object Foo1 { type T[+A] = (A, Int) }
+object Foo2 { type T[+A] = [+B] =>> (A, B) }   // error no `+/-` variance annotation allowed here
+object Foo3 { type T[+A] = [+B] =>> [C] =>> (A, B) }  // error
+object Foo4 { type T = [+A] =>> [+B] =>> [C] =>> (A, B) } // error // error

tests/neg/type-lambdas-posttyper.scala

@@ -16,7 +16,7 @@ object Test extends App {
   type TL3[+X] = Ref[X] // error: covariant type parameter X occurs in nonvariant position in Test.Ref[X]
   type TL4[-X] = X => X // error: contravariant type parameter X occurs in covariant position in X => X
 
-  def f[F <: [+X] =>> Any](x: F[String]): F[Any] = x
+  def f[F[+X]](x: F[String]): F[Any] = x
 
   val sref = new Ref[String]("abc")
   val aref: Ref[Any] = f[TL3](sref)
@@ -27,15 +27,15 @@ object Test extends App {
   type Neg2[-X] >: X // error
   type Neg3[-X] <: X // error
 
-  type Neg4 = [-X] =>> X // error
+  type Neg4[-X] = X // error
   type Neg5[-X] >: X <: Any // error
   type Neg6[-X] <: X // error
 
   type Pos1[+X] = Ref[X] // error
   type Pos2[+X] >: Ref[X] // error
   type Pos3[+X] <: Ref[X] // error
 
-  type Pos4 = [+X] =>> Ref[X] // error
+  type Pos4[+X] = Ref[X] // error
   type Pos5[+X] >: Ref[X] <: Any // error
   type Pos6[+X] <: Ref[X] // error
 }

tests/pos-custom-args/erased/i7868.scala

@@ -25,7 +25,7 @@ object Coproduct {
   def upCast[A, B](a: A) with (erased evidence: (A <:< B) ): B = a.asInstanceOf[B]
 
   def from[Set, Value, Index <: Int](value: Value) with (erased at: At[Set, Value, Index]) : ValueOf[Index] ?=> Coproduct[Set, Value, Index] = {
-    Coproduct[Set, Value, Index](upCast(value: Value).with(at.cast.liftCo[[+X] =>> Value & X]), valueOf[Index])
+    Coproduct[Set, Value, Index](upCast(value: Value).with(at.cast.liftCo[[X] =>> Value & X]), valueOf[Index])
   }
 
 }

tests/pos/i6475.scala

@@ -2,7 +2,7 @@ package typeLambdas
 
 object Test {
 
-  type T =  [+X, Y] =>> Map[Y, X]
+  type T[+X, Y] = Map[Y, X]
 
   type CTL = [X] =>> [Y] =>> (X, Y)
   type T3 = CTL[Int][String]