Correct sorting example for Ordering in scaladoc

	Below code snippet,
    Sorting.quickSort(pairs)(Ordering.by[(String, Int, Int), Int](_._2)

    should be
    Sorting.quickSort(pairs)(Ordering.by[(String, Int, Int), Int](_._2))
SI-6793 Don't use super param accessors if inaccessible.

"Alias replacement" has been with us since 2005 (13c59adf9).

Given:

    package a {
      class C1(val v0: String)
      class C2(v1: String) extends a.C1(v1) { v1 }
    }

The reference to `v1` is rewritten as `C2.super.v0()`, and
no field is generated in `C2`.

(Oddly, this optimization doesn't seem to kick in if
these classes are in the empty package. That's probably
a distinct bug.)

However, this rewriting is done without consideration of
the accessibility of `v0` from `C2`.

This commit disables this optimization if there if `v0` is
not accessible.
SI-7200 Test case for fixed type inference error.

Broken in 2.9.2 and 2.10.0, but working in 2.10.1

--- sandbox/2.10.0.log
+++ sandbox/2.10.1.log
       def coflatMap[A >: Nothing <: Any, B >: Nothing <: Any](f: Test.Nel[A] => B): Test.Nel[A] => Test.Nel[B] = ((l: Test.Nel[A]) => Test.this.Nel.apply[B](f.apply(l), l.tail match {
         case immutable.this.Nil => immutable.this.Nil
-        case (hd: A, tl: List[A])scala.collection.immutable.::[A]((h @ _), (t @ _)) => {
-          val r: Test.Nel[Nothing] = NelFoo.this.coflatMap[A, Nothing](f).apply(Test.this.Nel.apply[A](h, t));
+        case (hd: A, tl: List[A])scala.collection.immutable.::[?A1]((h @ _), (t @ _)) => {
+          val r: Test.Nel[B] = NelFoo.this.coflatMap[A, B](f).apply(Test.this.Nel.apply[A](h, t));
           {
-            <synthetic> val x$1: Nothing = r.head;
-            r.tail.::[Nothing](x$1)
+            <synthetic> val x$1: B = r.head;
+            r.tail.::[B](x$1)
           }
         }
       }))

b74c33eb86 represents the exact moment of progression. Comments
in pos/t7200b.scala, a minimal test that demonstrates the problem
without type constructors or code execution, pinpoint the line of
code responsible for the fix.

Incidentally, I'm currently on a train somewhere between Solothurn
and Biel, and am consequently without the power of scala-bisector.
Undeterred, and inspired by a line I saw in Skyfall last night
("sometimes the olds ways are better"), I just pulled off a two-hop
bisection. Take that, O(log N)!

The one remaining worry is the appearance of the type variable
?A1 in the output of -Xprint:typer for run/t7200.scala.
Add counters to File#{exists, isFile, isDirectory}.

Due to limitations in the Statistics machinery, these are only
reported if this patch is applied.

        --- a/src/reflect/scala/reflect/internal/util/Statistics.scala
        +++ b/src/reflect/scala/reflect/internal/util/Statistics.scala
        @@ -109,7 +109,7 @@ quant)
            *  Quantities with non-empty prefix are printed in the statistics info.
            */
           trait Quantity {
        -    if (enabled && prefix.nonEmpty) {
        +    if (prefix.nonEmpty) {
               val key = s"${if (underlying != this) underlying.prefix else ""}/$prefix"
               qs(key) = this
             }
        @@ -243,7 +243,7 @@ quant)
            *
            *  to remove all Statistics code from build
            */
        -  final val canEnable = _enabled
        +  final val canEnable = true // _enabled
Optimization: avoid isDirectory call in DirectoryClassPath traversal

If we just established that the given path is a File or a Directory,
we don't need to go straight back to disk to re-check.

Background: When profiling an application that was using the interpreter
to compile a script, a lot of time was reported in exists / isDirectory
/ isFile. For the record, I happened to be profiling on Windows.

Turns out some of these calls are redundant, this commit and the
subsequent eliminate two sources thereof.

Here's an example of how it helps:

Taking a Hello, Akka! application, and compiling it with the compiler
and library on a directory classpath (ie, using build/quick):

    class HelloActor extends Actor {
      def receive = {
        case "hello" => println("hello back at you")
        case _       => println("huh?")
      }
    }

    object Main extends App {
      val system = ActorSystem("HelloSystem")
      // default Actor constructor
      val helloActor = system.actorOf(Props[HelloActor], name = "helloactor")
      helloActor ! "hello"
      helloActor ! "buenos dias"
    }

    % qbin/scalac -Ystatistics -classpath ~/.ivy2/cache/com.typesafe.akka/akka-actor_2.10/jars/akka-actor_2.10-2.1.1.jar:/Users/jason/.ivy2/cache/com.typesafe/config/bundles/config-1.0.0.jar sandbox/test.scala 2>&1 | grep File

Before
----------------------------------
File.isFile calls           : 7620
File.isDirectory calls      : 8348
File.exists calls           : 5770

After
----------------------------------
File.isFile calls           : 7620
File.isDirectory calls      : 2319
File.exists calls           : 5770
Optimization: avoid call to exists in PlainFile#iterator

If we just established that the given path is a File or a Directory,
we can assume it continues to exist.

Before
----------------------------------
File.isFile calls           : 7620
File.isDirectory calls      : 2319
File.exists calls           : 5770

After
----------------------------------
File.isFile calls           : 7620
File.isDirectory calls      : 2319
File.exists calls           : 345
SI-7312 @deprecatedInheritance now ignores same-file subclasses

This allows us to deprecate external inheritances as a prelude
to sealing a class, without enduring the warnings ourselved in
interlude.
SI-7315 Test @deprecatedInheritance / @specialized interplay

Don't warn about the specialized subclass.

Fixed in the previous commit for a similar issue SI-7312.
SI-7147 Diagnostic for unexplained assertion in presentation compiler.

We don't have a reproducible test for this, so the best we can
do is beef up the assertion to shine a little light on the problem.
Merge pull request #2303 from starblood/gyuhang/libdoc

Correct sorting example for Ordering in scaladoc
Backport #2289's TermNames.unexpandedName as TermNames.originalName

Because this implementation is more clear than 2.10.x's and it will
simplify a further commit to fix SI-6715.
SI-6715 Shouldn't return "" from TermNames.originalName
Merge pull request #2281 from kzys/jira-6715

SI-6715 Scaladoc: Use an encoded name if a decoded name is ""
Merge pull request #2319 from retronym/ticket/6793

SI-6793 Don't use super param accessors if inaccessible.
Add a cautionary comment to TreeSymSubstitutor.
Refactor existential related code out of types.

For imminent reuse in the subsequent commit.

The binary compatibility whitelist is updated to
ignore these, as they live in reflect.internal.
Simplify interplay between Uncurry Info- and Tree-Transformers

Now, the InfoTransformer is responsible for erasing the
path dependent types of formal parameters, at the same
place where it flattens nested method types.

This is preferable to having the tree transformer overwrite
the result of the info transformer, as used to be the case
after my previous work on SI-6135 / 493197fc.
SI-6900 Fix tailrec for dependent method types

Uncurry's info transformer could generate a MethodType
with cloned parameter symbols. This type was used
for the LabelDef generated in the TailCalls phase.
But, the RHS of the method still contains types that
refer to the original parmameter symbol. Spurious
type errors ensued.

I've spent a good chunk of time pursuing a more
principled fix, in which we keep the symbols in the
tree in sync with those in the MethodType. You can
relive the procession of false dawns:

 https://github.com/scala/scala/pull/2248

Ultimately that scheme was derailed by a mismatch
between the type parameter `T` and the skolem `T&`
in the example below.

    trait Endo[A] { def apply(a: => A): A }
    class Test {
      def foo[T] =
        new Endo[(T, Unit)] {
          def apply(v1: => (T, Unit)) = v1 // no bridge created
        }
    }

Interestingly, by removing the caching in SingleType,
I got past that problem. But I didn't characterize it
further.

This commit sets asides the noble goal of operating in
the world of types, and sledgehammers past the crash by
casting the arguments to and the result of the label jump
generated in TailCalls.
Merge pull request #2344 from retronym/ticket/7147

SI-7147 Diagnostic for unexplained assertion in presentation compiler.
Take the N^2 out of the compiler's TreeSet.

The code responsible for this performance bug lives on somewhere
in the combination of Iterator.single and Iterator.++ and is
tracked by SI-7316. What this commit does is bypass the creation
and composition of iterators entirely in favor of applying foreach
to walking the tree.

The important lesson of a bug like this: the occurrence depends on
the existence of multiple implementations of basic structures like
Trees. For each redundant implementation, scrutiny and testing
are divided and "bug diversity" is increased. We should labor
hard to structure collections in such a way that people have no
good reason not to take advantage of the basic and hopefully
battle-tested logic - especially when those people are us.

I hope to remove util.TreeSet entirely. Until then, here is the
impact of this commit on the time to compile a piece of generated
test code.

  % time scalac3 ./target/generated/src.scala
  Mar 28 13:20:31 [running phase parser on src.scala]
  ...
  Mar 28 13:21:28 [running phase lazyvals on src.scala]
  Mar 28 13:21:28 [running phase lambdalift on src.scala]  <-- WHOA
  Mar 28 13:25:05 [running phase constructors on src.scala]
  ...
  Mar 28 13:25:19 [running phase jvm on icode]
  316.387 real, 438.182 user, 8.163 sys

To this:

  97.927 real, 211.015 user, 8.043 sys

  % time pscalac ./target/generated/src.scala
  Mar 28 13:18:47 [running phase parser on src.scala]
  ...
  Mar 28 13:19:44 [running phase lazyvals on src.scala]
  Mar 28 13:19:44 [running phase lambdalift on src.scala]
  Mar 28 13:19:46 [running phase constructors on src.scala]
  ...
  Mar 28 13:19:57 [running phase jvm on icode]
  99.909 real, 223.605 user, 7.847 sys

That's lambdalift dropping from 217 seconds to 2 seconds.