Merge pull request #2623 from paulp/pr/merge

Merge 2.10.x/2.10.2 into master.

2 files changed, 23 insertions, 8 deletions

diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 1b46d9e00b..851fc98a32 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -111,8 +111,10 @@ trait Definitions extends api.StandardDefinitions {
     /** Is symbol a numeric value class? */
     def isNumericValueClass(sym: Symbol) = ScalaNumericValueClasses contains sym
 
-    def isGetClass(sym: Symbol) =
-      (sym.name == nme.getClass_) && flattensToEmpty(sym.paramss)
+    def isGetClass(sym: Symbol) = (
+         sym.name == nme.getClass_ // this condition is for performance only, this is called from `Typer#stabliize`.
+      && getClassMethods(sym)
+    )
 
     lazy val UnitClass    = valueClassSymbol(tpnme.Unit)
     lazy val ByteClass    = valueClassSymbol(tpnme.Byte)
@@ -777,6 +779,12 @@ trait Definitions extends api.StandardDefinitions {
     lazy val Any_isInstanceOf = newT1NullaryMethod(AnyClass, nme.isInstanceOf_, FINAL)(_ => BooleanTpe)
     lazy val Any_asInstanceOf = newT1NullaryMethod(AnyClass, nme.asInstanceOf_, FINAL)(_.typeConstructor)
 
+    lazy val primitiveGetClassMethods = Set[Symbol](Any_getClass, AnyVal_getClass) ++ (
+      ScalaValueClasses map (_.tpe member nme.getClass_)
+    )
+
+    lazy val getClassMethods: Set[Symbol] = primitiveGetClassMethods + Object_getClass
+
   // A type function from T => Class[U], used to determine the return
     // type of getClass calls.  The returned type is:
     //
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 00a929003e..3725f570a8 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -1066,6 +1066,14 @@ trait Types
           continue = false
           val bcs0 = baseClasses
           var bcs = bcs0
+          // omit PRIVATE LOCALS unless selector class is contained in class owning the def.
+          def admitPrivateLocal(owner: Symbol): Boolean = {
+            val selectorClass = this match {
+              case tt: ThisType => tt.sym // SI-7507 the first base class is not necessarily the selector class.
+              case _            => bcs0.head
+            }
+            selectorClass.hasTransOwner(owner)
+          }
           while (!bcs.isEmpty) {
             val decls = bcs.head.info.decls
             var entry = decls.lookupEntry(name)
@@ -1075,10 +1083,10 @@ trait Types
               if ((flags & required) == required) {
                 val excl = flags & excluded
                 if (excl == 0L &&
-                      (// omit PRIVATE LOCALS unless selector class is contained in class owning the def.
+                      (
                     (bcs eq bcs0) ||
                     (flags & PrivateLocal) != PrivateLocal ||
-                    (bcs0.head.hasTransOwner(bcs.head)))) {
+                    admitPrivateLocal(bcs.head))) {
                   if (name.isTypeName || (stableOnly && sym.isStable && !sym.hasVolatileType)) {
                     if (Statistics.canEnable) Statistics.popTimer(typeOpsStack, start)
                     return sym
@@ -3118,10 +3126,9 @@ trait Types
           sameLength(typeArgs, tp.typeArgs) && {
             val lhs = if (isLowerBound) tp.typeArgs else typeArgs
             val rhs = if (isLowerBound) typeArgs else tp.typeArgs
-            // this is a higher-kinded type var with same arity as tp.
-            // side effect: adds the type constructor itself as a bound
-            addBound(tp.typeConstructor)
-            isSubArgs(lhs, rhs, params, AnyDepth)
+            // This is a higher-kinded type var with same arity as tp.
+            // If so (see SI-7517), side effect: adds the type constructor itself as a bound.
+            isSubArgs(lhs, rhs, params, AnyDepth) && { addBound(tp.typeConstructor); true }
           }
         }
         // The type with which we can successfully unify can be hidden