Do Variance checking at PostTyper

The plan is that by then we know when a members is private[this].

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -150,6 +150,8 @@ object desugar {
    *  ==>
    *    def x: Int = expr
    *    def x_=($1: <TypeTree()>): Unit = ()
+   *
+   *  Generate the setter only for non-private class members and all trait members.
    */
   def valDef(vdef0: ValDef)(implicit ctx: Context): Tree = {
     val vdef @ ValDef(name, tpt, rhs) = transformQuotedPatternName(vdef0)

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -243,10 +243,12 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case tree: TypeDef =>
           val sym = tree.symbol
           if (sym.isClass)
+            VarianceChecker.check(tree)
             // Add SourceFile annotation to top-level classes
-            if (sym.owner.is(Package) &&
-              ctx.compilationUnit.source.exists &&
-              sym != defn.SourceFileAnnot)
+            if sym.owner.is(Package)
+               && ctx.compilationUnit.source.exists
+               && sym != defn.SourceFileAnnot
+            then
               sym.addAnnotation(Annotation.makeSourceFile(ctx.compilationUnit.source.file.path))
           processMemberDef(super.transform(tree))
         case tree: New if isCheckable(tree) =>

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

@@ -130,7 +130,6 @@ class ReTyper extends Typer with ReChecking {
 
   override def inlineExpansion(mdef: DefDef)(implicit ctx: Context): Tree = mdef
 
-  override def checkVariance(tree: Tree)(implicit ctx: Context): Unit = ()
   override def inferView(from: Tree, to: Type)(implicit ctx: Context): Implicits.SearchResult =
     Implicits.NoMatchingImplicitsFailure
   override def checkCanEqual(ltp: Type, rtp: Type, span: Span)(implicit ctx: Context): Unit = ()

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

@@ -1740,7 +1740,6 @@ class Typer extends Namer
         checkEnum(cdef, cls, firstParent)
       }
       val cdef1 = assignType(cpy.TypeDef(cdef)(name, impl1), cls)
-      checkVariance(cdef1)
 
       val reportDynamicInheritance =
         ctx.phase.isTyper &&
@@ -1828,9 +1827,6 @@ class Typer extends Namer
     else parents
   }
 
-  /** Overridden in retyper */
-  def checkVariance(tree: Tree)(implicit ctx: Context): Unit = VarianceChecker.check(tree)
-
   def localDummy(cls: ClassSymbol, impl: untpd.Template)(implicit ctx: Context): Symbol =
     ctx.newLocalDummy(cls, impl.span)
 

tests/neg-custom-args/matchtype-loop.scala

@@ -2,7 +2,7 @@ object Test {
   type L[X] = X match {
     case Int => L[X]
   }
-  type LL[X] = X match {  // error: recursion limit exceeded
+  type LL[X] = X match {
     case Int => LL[LL[X]]
   }
   def a: L[Boolean] = ???
@@ -11,7 +11,7 @@ object Test {
   val x: Int = g[Int]     // error: found: L[Int], required: Int
 
   def aa: LL[Boolean] = ???
-  def bb: LL[Int] = ???   // error: recursion limit exceeded with  reduce type  LazyRef(Test.LL[Int]) match ... // error
+  def bb: LL[Int] = ???   // error: recursion limit exceeded with  reduce type  LazyRef(Test.LL[Int]) match ...
   def gg[X]: LL[X] = ???
   val xx: Int = gg[Int]   // error: recursion limit exceeded with  reduce type  LazyRef(Test.LL[Int]) match ...
 }

tests/neg/i4385.scala

@@ -1,6 +1,7 @@
 class i0 {
   class i1 { type i2 }
-  type i3 = i1.i2 // error
+  val i1 = new i1()
+  type i3 = i1.i2
   type i4 = i0 { type i1 <: i4 } // error: recursion limit exceeded
   // This test ensures the above stack overflow is reported and not hidden by the earlier error.
 }

tests/neg/i5202.scala

@@ -9,7 +9,7 @@ class Foo[A] {
   def foo(a: A): Unit = {}
 }
 class Co[+A] {
-  def foo(a: A): Unit = {} // error: contravariant occurs in covariant position
+  def foo(a: A): Unit = {}
   def bar: A = ???
 }
 class Contra[-A] {

tests/neg/i5202a.scala

@@ -0,0 +1,4 @@
+class Co[+A] {
+  def foo(a: A): Unit = {} // error: contravariant occurs in covariant position
+  def bar: A = ???
+}

tests/neg/matchtype-loop2.scala

@@ -0,0 +1,8 @@
+object Test {
+  type L[X] = X match {
+    case Int => L[X]
+  }
+  type LL[X] = X match {   // error: recursion limit exceeded
+    case Int => LL[LL[X]]
+  }
+}

tests/neg/toplevel-cyclic/defs_1.scala

@@ -1,2 +1,2 @@
-type A = B  // error: recursion limit exceeded // error: recursion limit exceeded
+type A = B  // error: recursion limit exceeded