Prefer ownersIterator

src/compiler/scala/reflect/reify/codegen/GenSymbols.scala

@@ -83,7 +83,7 @@ trait GenSymbols {
        *    object B { object B } => selectType(staticModule("B"), "B")
        *    object B { package B } => impossible
        */
-      val hasPackagelessParent = sym.ownerChain.tail.tail exists (_.isEmptyPackageClass)
+      val hasPackagelessParent = sym.ownersIterator.drop(2).exists(_.isEmptyPackageClass)
       if (sym.isStatic && (sym.isClass || sym.isModule) && !hasPackagelessParent) {
         // scala/bug#6238: if applicable, emit references to StandardDefinitions instead of staticClass/staticModule calls
         val resolver = if (sym.isType) nme.staticClass else nme.staticModule

src/compiler/scala/tools/nsc/Global.scala

@@ -1082,11 +1082,9 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
   @inline final def enteringUncurry[T](op: => T): T       = enteringPhase(currentRun.uncurryPhase)(op)
 
   // Owners which aren't package classes.
-  private def ownerChainString(sym: Symbol): String = (
+  private def ownerChainString(sym: Symbol): String =
     if (sym == null) ""
-    else sym.ownerChain takeWhile (!_.isPackageClass) mkString " -> "
-  )
-
+    else sym.ownersIterator.takeWhile(!_.isPackageClass).mkString(" -> ")
 
   /** Don't want to introduce new errors trying to report errors,
    *  so swallow exceptions.

src/compiler/scala/tools/nsc/ast/DocComments.scala

@@ -454,17 +454,17 @@ trait DocComments { self: Global =>
       }
 
       def getSite(name: Name): Type = {
-        def findIn(sites: List[Symbol]): Type = sites match {
-          case site1 :: sites1 => select(site1.thisType, name, findIn(sites1))
-          case _ => NoType
-        }
-        // Previously, searching was taking place *only* in the current package and in the root package
-        // now we're looking for it everywhere in the hierarchy, so we'll be able to link variable expansions like
-        // immutable.Seq in package immutable
-        //val (classes, pkgs) = site.ownerChain.span(!_.isPackageClass)
-        //val sites = (classes ::: List(pkgs.head, rootMirror.RootClass)))
-        //findIn(sites)
-        findIn(site.ownerChain ::: List(rootMirror.EmptyPackage))
+        def findIn(sites: Iterator[Symbol]): Type =
+          if (sites.hasNext) {
+            val tp = sites.next().thisType
+            val member = tp.nonPrivateMember(name)
+            if (member.isTerm) singleType(tp, member)
+            else if (member.isType) tp.memberType(member)
+            else findIn(sites)
+          }
+          else NoType
+
+        findIn(site.ownersIterator ++ Iterator.single(rootMirror.EmptyPackage))
       }
 
       def getType(str: String, variable: String): Type = {
@@ -486,7 +486,7 @@ trait DocComments { self: Global =>
         val (start, rest) = parts match {
           case "this" :: _      => (site.thisType, partnames.tail)
           case _ :: "this" :: _ =>
-            site.ownerChain.find(_.name == partnames.head) match {
+            site.ownersIterator.find(_.name == partnames.head) match {
               case Some(clazz)  => (clazz.thisType, partnames drop 2)
               case _            => (NoType, Nil)
             }

src/compiler/scala/tools/nsc/symtab/SymbolTrackers.scala

@@ -49,7 +49,7 @@ trait SymbolTrackers {
     def containsSymbol(t: Tree) = t.symbol != null && t.symbol != NoSymbol
 
     // This is noise reduction only.
-    def dropSymbol(sym: Symbol) = sym.ownerChain exists (_ hasFlag Flags.SPECIALIZED)
+    def dropSymbol(sym: Symbol) = sym.ownersIterator.exists(_.hasFlag(Flags.SPECIALIZED))
 
     def symbolSnapshot(unit: CompilationUnit): Map[Symbol, Set[Tree]] = {
       if (unit.body == null) Map.empty
@@ -84,7 +84,7 @@ trait SymbolTrackers {
         def descendents(s: Symbol) = (syms - s) filter (_ hasTransOwner s)
         def rooted(root: Symbol)   = new Node(root, nodes(descendents(root)))
 
-        val roots    = syms filterNot (_.ownerChain drop 1 exists syms)
+        val roots    = syms.filterNot(_.ownersIterator.drop(1).exists(syms))
         val deep     = roots map rooted
         val deepSyms = deep flatMap (_.flatten)
 

src/compiler/scala/tools/nsc/transform/TailCalls.scala

@@ -119,8 +119,8 @@ abstract class TailCalls extends Transform {
 
       def newThis(pos: Position) = {
         def msg = "Creating new `this` during tailcalls\n  method: %s\n  current class: %s".format(
-          method.ownerChain.mkString(" -> "),
-          currentClass.ownerChain.mkString(" -> ")
+          method.ownersIterator.mkString(" -> "),
+          currentClass.ownersIterator.mkString(" -> ")
         )
         logResult(msg)(method.newValue(nme.THIS, pos, SYNTHETIC) setInfo currentClass.typeOfThis)
       }

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

@@ -1015,8 +1015,10 @@ trait Implicits extends splain.SplainData {
           if (sym.hasAccessorFlag) {
             val symAcc = sym.accessed // #3373
             symAcc.pos.pointOrElse(0) < ownerPos &&
-            !(owner.ownerChain exists (o => (o eq sym) || (o eq symAcc))) // probably faster to iterate only once, don't feel like duplicating hasTransOwner for this case
-          } else !(owner hasTransOwner sym)) // faster than owner.ownerChain contains sym
+            !owner.ownersIterator.exists(o => (o eq sym) || (o eq symAcc)) // probably faster to iterate only once, don't feel like duplicating hasTransOwner for this case
+          }
+          else !owner.hasTransOwner(sym)
+        )
       }
 
       sym.isInitialized || {

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

@@ -621,8 +621,8 @@ trait MacroAnnotationNamers { self: Analyzer =>
       if (!currentRun.compiles(owner) &&
           // NOTE: the following three lines of code are added to work around #7
           !owner.enclosingTopLevelClass.isRefinementClass &&
-          !owner.ownerChain.exists(_.isLocalDummy) &&
-          owner.ownerChain.forall(!currentRun.compiles(_))) {
+          !owner.ownersIterator.exists(_.isLocalDummy) &&
+          owner.ownersIterator.forall(!currentRun.compiles(_))) {
         owner.initialize
       }
       original.companionSymbol orElse {

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

@@ -566,7 +566,7 @@ abstract class RefChecks extends Transform {
         }
 
         def checkOverrideDeprecated(): Unit = {
-          if (other.hasDeprecatedOverridingAnnotation && !(member.hasDeprecatedOverridingAnnotation || member.ownerChain.exists(_.isDeprecated))) {
+          if (other.hasDeprecatedOverridingAnnotation && !(member.hasDeprecatedOverridingAnnotation || member.ownersIterator.exists(_.isDeprecated))) {
             val version = other.deprecatedOverridingVersion.getOrElse("")
             val since   = if (version.isEmpty) version else s" (since $version)"
             val message = other.deprecatedOverridingMessage map (msg => s": $msg") getOrElse ""
@@ -1343,14 +1343,14 @@ abstract class RefChecks extends Transform {
         if (changed)
           refchecksWarning(pos, s"${sym.fullLocationString} has changed semantics in version ${sym.migrationVersion.get}:\n${sym.migrationMessage.get}", WarningCategory.OtherMigration)
       }
-      if (sym.isExperimental && !currentOwner.ownerChain.exists(x => x.isExperimental)) {
+      if (sym.isExperimental && !currentOwner.ownersIterator.exists(x => x.isExperimental)) {
         val msg =
           s"${sym.fullLocationString} is marked @experimental and therefore its enclosing scope must be experimental."
         reporter.error(pos, msg)
       }
       // See an explanation of compileTimeOnly in its scaladoc at scala.annotation.compileTimeOnly.
       // async/await is expanded after erasure
-      if (sym.isCompileTimeOnly && !inAnnotation && !currentOwner.ownerChain.exists(x => x.isCompileTimeOnly)) {
+      if (sym.isCompileTimeOnly && !inAnnotation && !currentOwner.ownersIterator.exists(x => x.isCompileTimeOnly)) {
         if (!async.deferCompileTimeOnlyError(sym)) {
           def defaultMsg =
             sm"""Reference to ${sym.fullLocationString} should not have survived past type checking,

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

@@ -71,7 +71,7 @@ abstract class TreeCheckers extends Analyzer {
     case s: Symbol => s.shortSymbolClass
     case x         => shortClassOfInstance(x.asInstanceOf[AnyRef])
   }
-  private def nonPackageOwners(s: Symbol) = s.ownerChain drop 1 takeWhile (!_.hasPackageFlag)
+  private def nonPackageOwners(s: Symbol) = s.ownerChain.drop(1).takeWhile(!_.hasPackageFlag)
   private def nonPackageOwnersPlusOne(s: Symbol) = nonPackageOwners(s) ::: (s.ownerChain dropWhile (!_.hasPackageFlag) take 1)
   private def ownersString(s: Symbol) = nonPackageOwnersPlusOne(s) match {
     case Nil => "NoSymbol"

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

@@ -1902,7 +1902,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           val sameSourceFile = context.unit.source.file == psym.sourceFile
 
           if (!isPastTyper && psym.hasDeprecatedInheritanceAnnotation &&
-            !sameSourceFile && !context.owner.ownerChain.exists(_.isDeprecated)) {
+            !sameSourceFile && !context.owner.ownersIterator.exists(_.isDeprecated)) {
             val version = psym.deprecatedInheritanceVersion.getOrElse("")
             val since   = if (version.isEmpty) version else s" (since $version)"
             val message = psym.deprecatedInheritanceMessage.map(msg => s": $msg").getOrElse("")
@@ -2489,7 +2489,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
                   DeprecatedParamNameError(p, alt)
             }
 
-          if (settings.multiargInfix && !meth.isConstructor && meth.owner.isClass && !meth.isDeprecated && !meth.hasAnnotation(UnusedClass) && !meth.ownerChain.exists(_.isDeprecated) && !meth.isSynthetic)
+          if (settings.multiargInfix && !meth.isConstructor && meth.owner.isClass && !meth.isDeprecated && !meth.hasAnnotation(UnusedClass) && !meth.ownersIterator.exists(_.isDeprecated) && !meth.isSynthetic)
             meth.paramss match {
               case (h :: _ :: _) :: Nil if !h.isImplicit && Chars.isOperatorPart(meth.name.decoded.head) =>
                 warnMultiargInfix(ddef)

src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala

@@ -68,7 +68,7 @@ trait TraceSymbolActivity {
     show(dashes(s1), ss map dashes: _*)
   }
   private def showSym(sym: Symbol): Unit = {
-    def prefix = ("  " * (sym.ownerChain.length - 1)) + sym.id
+    def prefix = ("  " * (sym.ownersIterator.size - 1)) + sym.id
     try println("%s#%s %s".format(prefix, sym.accurateKindString, sym.name.decode))
     catch {
       case x: Throwable => println(prefix + " failed: " + x)
@@ -111,7 +111,7 @@ trait TraceSymbolActivity {
     println("")
 
     showHeader("descendants", "symbol")
-    showFreq(allSymbols.values flatMap (_.ownerChain drop 1))(_.id, symbolStr)
+    showFreq(allSymbols.values.flatMap(_.ownersIterator.drop(1)))(_.id, symbolStr)
 
     showHeader("children", "symbol")
     showMapFreq(allChildren)(symbolStr)

src/reflect/scala/reflect/runtime/JavaMirrors.scala

@@ -254,7 +254,7 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive
     def moduleSymbol(rtcls: RuntimeClass): ModuleSymbol = classToScala(rtcls).companionModule.asModule
 
     private def ensuringNotFree(sym: Symbol)(body: => Any): Unit = {
-      val freeType = sym.ownerChain find (_.isFreeType)
+      val freeType = sym.ownersIterator.find(_.isFreeType)
       freeType match {
         case Some(freeType) => ErrorFree(sym, freeType)
         case _ => body

src/sbt-bridge/scala/tools/xsbt/CallbackGlobal.scala

@@ -210,8 +210,8 @@ sealed class ZincCompiler(settings: Settings, dreporter: DelegatingReporter, out
   }
 
   private def flattenedOwner(g: Global)(sym: g.Symbol): g.Symbol = {
-    val chain = sym.owner.ownerChain.dropWhile(o => o.isClass && !o.hasPackageFlag)
-    if (chain.isEmpty) g.NoSymbol else chain.head
+    val chain = sym.owner.ownersIterator.dropWhile(o => o.isClass && !o.hasPackageFlag)
+    if (!chain.hasNext) g.NoSymbol else chain.next()
   }
 
   private def flattenedName(g: Global)(sym: g.Symbol): g.Name = {

src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala

@@ -76,7 +76,7 @@ trait MemberLookup extends base.MemberLookupBase {
     Option(s.associatedFile).flatMap(_.underlyingSource).map { src =>
       val path = src.canonicalPath
       if(path.endsWith(".class")) { // Individual class file -> Classpath entry is root dir
-        val nesting = s.ownerChain.count(_.hasPackageFlag)
+        val nesting = s.ownersIterator.count(_.hasPackageFlag)
         if(nesting > 0) {
           val p = 0.until(nesting).foldLeft(src) {
             case (null, _) => null

src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala

@@ -983,7 +983,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
   }
 
   def makeQualifiedName(sym: Symbol, relativeTo: Option[Symbol] = None): String = {
-    val stop = relativeTo map (_.ownerChain.toSet) getOrElse Set[Symbol]()
+    val stop = relativeTo.map(_.ownersIterator.toSet).getOrElse(Set.empty[Symbol])
     var sym1 = sym
     val path = new StringBuilder()
     // var path = List[Symbol]()

src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala

@@ -16,7 +16,6 @@ package model
 
 import base._
 import diagram._
-import scala.annotation.nowarn
 import scala.collection.{immutable, mutable}
 
 /** This trait extracts all required information for documentation from compilation units */
@@ -119,36 +118,27 @@ trait ModelFactoryTypeSupport {
           // type is inherited from one template to another. There may be multiple symbols with the same name in scope,
           // but we won't show the prefix if our symbol is among them, only if *it's not* -- that's equal to showing
           // the prefix only for ambiguous references, not for overloaded ones.
-          @nowarn("cat=lint-nonlocal-return")
-          def needsPrefix: Boolean = {
-            if ((owner != bSym.owner || preSym.isRefinementClass) && (normalizeTemplate(owner) != inTpl.sym))
-              return true
+          def needsPrefix: Boolean =
+            ((owner != bSym.owner || preSym.isRefinementClass) && normalizeTemplate(owner) != inTpl.sym) || (
             // don't get tricked into prefixing method type params and existentials:
             // I tried several tricks BUT adding the method for which I'm creating the type => that simply won't scale,
             // as ValueParams are independent of their parent member, and I really don't want to add this information to
             // all terms, as we're already over the allowed memory footprint
-            if (aSym.isTypeParameterOrSkolem || aSym.isExistentiallyBound /* existential or existential skolem */)
-              return false
+            !(aSym.isTypeParameterOrSkolem || aSym.isExistentiallyBound /* existential or existential skolem */) &&
 
-            for (tpl <- inTpl.sym.ownerChain) {
-              tpl.info.member(bSym.name) match {
-                case NoSymbol =>
-                  // No syms with that name, look further inside the owner chain
-                case sym =>
-                  // Symbol found -- either the correct symbol, another one OR an overloaded alternative
-                  if (sym == bSym)
-                    return false
-                  else sym.info match {
-                    case OverloadedType(owner, alternatives) =>
-                      return alternatives.contains(bSym)
-                    case _ =>
-                      return true
+            inTpl.sym.ownersIterator
+              .map(_.info.member(bSym.name))
+              .collectFirst {
+                // the correct symbol, another one OR an overloaded alternative
+                case `bSym` => false
+                case sym if sym ne NoSymbol =>
+                  sym.info match {
+                    case OverloadedType(_, alternatives) => alternatives.contains(bSym)
+                    case _ => true
                   }
               }
-            }
-            // if it's not found in the owner chain, we can safely leave out the prefix
-            false
-          }
+              .getOrElse(false) // if it's not found in the owner chain, we can safely leave out the prefix
+          )
 
           val prefix =
             if (!settings.docNoPrefixes.value && needsPrefix && (bSym != AnyRefClass /* which we normalize */)) {