Remove variance check for escaping locals

Author: joroKr21

src/compiler/scala/tools/nsc/typechecker/RefChecks.scala

@@ -1566,8 +1566,6 @@ abstract class RefChecks extends Transform {
 
       if (!sym.exists)
         devWarning("Select node has NoSymbol! " + tree + " / " + tree.tpe)
-      else if (sym.isLocalToThis)
-        varianceValidator.checkForEscape(sym, currentClass)
 
       def checkSuper(mix: Name) =
         // term should have been eliminated by super accessors

src/reflect/scala/reflect/internal/Variances.scala

@@ -28,7 +28,6 @@ trait Variances {
    *  TODO - eliminate duplication with varianceInType
    */
   class VarianceValidator extends InternalTraverser {
-    private[this] val escapedLocals = mutable.HashSet[Symbol]()
     // A flag for when we're in a refinement, meaning method parameter types
     // need to be checked.
     private[this] var inRefinement = false
@@ -38,17 +37,6 @@ trait Variances {
       try body finally inRefinement = saved
     }
 
-    /** Is every symbol in the owner chain between `site` and the owner of `sym`
-     *  either a term symbol or private[this]? If not, add `sym` to the set of
-     *  escaped locals.
-     *  @pre  sym.isLocalToThis
-     */
-    @tailrec final def checkForEscape(sym: Symbol, site: Symbol): Unit = {
-      if (site == sym.owner || site == sym.owner.moduleClass || site.hasPackageFlag) () // done
-      else if (site.isTerm || site.isPrivateLocal) checkForEscape(sym, site.owner) // ok - recurse to owner
-      else escapedLocals += sym
-    }
-
     protected def issueVarianceError(base: Symbol, sym: Symbol, required: Variance, tpe: Type): Unit = ()
 
     // Flip occurrences of type parameters and parameters, unless
@@ -62,10 +50,9 @@ trait Variances {
     )
 
     // Is `sym` is local to a term or is private[this] or protected[this]?
-    def isExemptFromVariance(sym: Symbol): Boolean = !sym.owner.isClass || (
-         (sym.isLocalToThis || sym.isSuperAccessor) // super accessors are implicitly local #4345
-      && !escapedLocals(sym)
-    )
+    def isExemptFromVariance(sym: Symbol): Boolean =
+      // super accessors are implicitly local #4345
+      !sym.owner.isClass || sym.isLocalToThis || sym.isSuperAccessor
 
     private object ValidateVarianceMap extends VariancedTypeMap {
       private[this] var base: Symbol = _

test/files/pos/variance-holes.scala

@@ -29,9 +29,19 @@ object Test {
   class RefinedUpper2[+A, x <: { type T[_ <: A] }]
   trait RefinedLower[+A, x <: { type T[_ >: A] }]
 
-  class PrivateThis[+A] {
+  class PrivateThis1[+A] {
     private[this] object Foo { var x: A = _ }
   }
 
+  class PrivateThis2[-A] {
+    private[this] val x: Set[A] = Set.empty
+    private[this] var y: Set[A] = Set.empty
+
+    class Escape {
+      println(x)
+      println(y)
+    }
+  }
+
   def generic[A]: Unit = ()
 }