Color REPL under -Dscala.color

We already use -Dscala.color when using -Ytyper-debug

This tries to reuse the colors chosen from the debug flag:

* Bold blue for vals (e.g. "res0")
* Bold green for types (e.g. "Int")
* Magenta for the shell prompt (e.g. "scala>")
SI-6502 Remove cp command as unworkable

People expect to change the class path midstream.

Let's disabuse them by removing the broken command.

The internals are deprecated.
SI-6502 Repl reset/replay take settings args

The reset and replay commands take arbitrary command line args.
When settings args are supplied, the compiler is recreated.

For uniformity, the settings command performs only the usual
arg parsing: use -flag:true instead of +flag, and clearing a
setting is promoted to the command line, so that -Xlint: is not
an error but clears the flags.

```
scala> maqicode.Test main null
<console>:8: error: not found: value maqicode
              maqicode.Test main null
              ^

scala> :reset -classpath/a target/scala-2.11/sample_2.11-1.0.jar
Resetting interpreter state.
Forgetting all expression results and named terms: $intp

scala> maqicode.Test main null
Hello, world.

scala> val i = 42
i: Int = 42

scala> s"$i is the loneliest numbah."
res1: String = 42 is the loneliest numbah.

scala> :replay -classpath ""
Replaying: maqicode.Test main null
Hello, world.

Replaying: val i = 42
i: Int = 42

Replaying: s"$i is the loneliest numbah."
res1: String = 42 is the loneliest numbah.

scala> :replay -classpath/a ""
Replaying: maqicode.Test main null
<console>:8: error: not found: value maqicode
              maqicode.Test main null
              ^

Replaying: val i = 42
i: Int = 42

Replaying: s"$i is the loneliest numbah."
res1: String = 42 is the loneliest numbah.
```

Clearing a clearable setting:
```
scala> :reset -Xlint:missing-interpolator
Resetting interpreter state.

scala> { val i = 42 ; "$i is the loneliest numbah." }
<console>:8: warning: possible missing interpolator: detected interpolated identifier `$i`
              { val i = 42 ; "$i is the loneliest numbah." }
                             ^
res0: String = $i is the loneliest numbah.

scala> :reset -Xlint:
Resetting interpreter state.
Forgetting this session history:

{ val i = 42 ; "$i is the loneliest numbah." }

scala> { val i = 42 ; "$i is the loneliest numbah." }
res0: String = $i is the loneliest numbah.

```
Add color to severity in REPL reporter

* Errors are red
* Warnings are yellow
Better ant / junit interaction

Currently junit test sources are always rebuilt, that's wasteful. The
second dependency on the junit task is there so that the first can be
skipped if sources haven't changed.

Also normalize package names versus location in the `test/junit` folder:
ant isn't very clever when it comes to selectively recompiling tests, so
now editing a test will only cause that one to be recompiled (instead of
~13 files every time).

This makes TDD with junit even faster.
SI-8087 keep annotations on mixed-in private[this] fields

Related to SI-2511 / eea7956, which fixed the same issue for non
`private[this]` fields.

If you have

    trait T { private[this] val f = 0 }
    class C extends T

Mixin geneartes an accessor method `T.f` with owner `T`. When
generating the field in `C`, the Mixin.mixinTraitMembers calls
`fAccessor.accessed`. The implementation of `accessed` does a lookup
for a member named `"f "` (note the space). The bug is that
`private[this]` fields are not renamed to have space
(`LOCAL_SUFFIX_STRING`) in their name, so the accessed was not found,
and no annotations were copied from it.
Don't remove elements from a map during iteration.

Doing so relies on implementation details which might change.

See #3911 / SI-8774.
Merge pull request #4018 from retronym/ticket/8774-concurrent-modification

Don't remove elements from a map during iteration.
SI-6192  Range: to, until and end are confusing

Added some documentation explaining what the role of `end` is.
SI-8624 PriorityQueue documentation is not clear enough

Added a paragraph explaining that dequeue is the only way to get your elements in priority order.
SI-8869 Prevent ill-kindedness in type lambdas

When type checking an type application, the arguments are allowed
to be of kinds other than *. This leniency is controlled by the
`ContextMode` bit `TypeConstructorAllowed`.

(More fine grained checking of matching arity a bounds of type
constructors is deferred until the refchecks phase to avoid
cycles during typechecking.)

However, this bit is propagated to child contexts, which means
that we fail to report this error in the lexical context marked
here:

    T[({type x = Option}#x)]
        `-------------'

This commit resets this bit to false in any child context
relates to a different tree from its parent.
SI-8870 Fix markup errors in the Types section of the spec

Bad: `T'_n`
Good: `T_n'`
Increase REPL startup timeout to avoid test failures

Under load on Jenkins, we've been seeing:

```
% diff /localhome/jenkins/a/workspace/scala-nightly-auxjvm-2.12.x/jdk/jdk7/label/auxjvm/test/files/run/t4542-run.log /localhome/jenkins/a/workspace/scala-nightly-auxjvm-2.12.x/jdk/jdk7/label/auxjvm/test/files/run/t4542.check
@@ -2,75 +2,14 @@ Type in expressions to have them evaluated.
 Type :help for more information.

 scala> @deprecated("foooo", "ReplTest version 1.0-FINAL") class Foo() {
 java.util.concurrent.TimeoutException: Futures timed out after [60 seconds]
 	at scala.concurrent.impl.Promise$DefaultPromise.ready(Promise.scala:219)
 	at scala.concurrent.impl.Promise$DefaultPromise.ready(Promise.scala:153)
 	at scala.concurrent.Await$$anonfun$ready$1.apply(package.scala:95)
 	at scala.concurrent.Await$$anonfun$ready$1.apply(package.scala:95)
 	at scala.concurrent.BlockContext$DefaultBlockContext$.blockOn(BlockContext.scala:53)
 	at scala.concurrent.Await$.ready(package.scala:95)
 	at scala.tools.nsc.interpreter.ILoop.processLine(ILoop.scala:431)
 	at scala.tools.nsc.interpreter.ILoop.loop(ILoop.scala:457)
 	at scala.tools.nsc.interpreter.ILoop$$anonfun$process$1.apply$mcZ$sp(ILoop.scala:875)
```

This commit bumps the timeout up be a factor of ten to try to
restore that comforting green glow to https://scala-webapps.epfl.ch/jenkins/view/2.N.x
Merge pull request #4010 from lrytz/t8087

SI-8087 keep annotations on mixed-in private[this] fields
Merge pull request #4008 from gourlaysama/wip/junit-2

Better ant / junit interaction
SI-8845 Control flow pot-pourri crashes GenASM, but not -BCode

Given that we'll switch to GenBCode in 2.12, the test case
showing the bug is fixed under that option is all I plan to
offer for this bug.

The flags file contains `-Ynooptimize` to stay locked into
`GenBCode`.
Merge pull request #4020 from Ichoran/issue/8624

SI-8624 PriorityQueue documentation is not clear enough
SI-8217 allow abstract type members in objects

Previously, abstract type members were allowed in objects only when inherited,
but not when declared directly. This inconsistency was not intended. In dotty,
abstract type members are allowed in values and represent existentials; so upon
discussion, it was decided to fix things to conform to dotty and allow such type
members. Adriaan also asked to keep rejecting abstract type members in methods
even though they would conceivably make sense.

Discussions happened on #3407, scala/scala-dist#127.
This code is improved from #3442, keeps closer to the current logic, and passes tests.

Existing tests that have been converted to `pos` tests show that
this works, and a new test has been added to show that local
aliases (ie term-owned) without a RHS are still rejected.
Merge pull request #4022 from retronym/ticket/8870

SI-8870 Fix markup errors in the Types section of the spec
SI-8267 Avoid existentials after polymorphic overload resolution

... which can be introduced by `memberType` for methods
with parameter types dependent on class type parameters.

Here's an example of such a type:

```
scala> class Bippy { trait Foo[A] }
defined class Bippy

scala> final class RichBippy[C <: Bippy with Singleton](val c1: C) {
     |   def g[A](x: A)(ev: c1.Foo[A]): Int = 2
     | }
defined class RichBippy

scala> :power
** Power User mode enabled - BEEP WHIR GYVE **
** :phase has been set to 'typer'.          **
** scala.tools.nsc._ has been imported      **
** global._, definitions._ also imported    **
** Try  :help, :vals, power.<tab>           **

scala> val g = typeOf[RichBippy[_]].member(TermName("g"))
g: $r.intp.global.Symbol = method g

scala> val c = new Bippy
c: Bippy = Bippy@92e2c93

scala> val memberType = typeOf[RichBippy[c.type]].memberType(g)
memberType: $r.intp.global.Type = ([A](x: A)(ev: _7.c1.Foo[A])Int) forSome { val _7: RichBippy[c.type] }

```

In this example, if we were to typecheck the selection
`new RichBippy[c.type].g` that existential type would be short lived.

Consider this approximation of `Typer#typedInternal`:

```scala
val tree1: Tree = typed1(tree, mode, ptWild)
val result = adapt(tree1, mode, ptPlugins, tree)
```

Given that `tree1.tpe` is not an overloaded, adapt will find its
way to:

```
  case tp if mode.typingExprNotLhs && isExistentialType(tp) =>
    adapt(tree setType tp.dealias.skolemizeExistential(context.owner, tree), mode, pt, original)
```

Which would open the existential as per:

```
scala> memberType.skolemizeExistential
res2: $r.intp.global.Type = [A](x: A)(ev: _7.c1.Foo[A])Int
```

However, if do have overloaded alternatives, as in the test case,
we have to remember to call `adapt` again *after* we have picked
the winning alternative.

We actually don't have a centralised place where overload resolution
occurs, as the process differs depending on the context of the
selection. (Are there explicit type arguments? Inferred type
arguments? Do we need to use the expected type to pick a winner?)

This commit finds the existing places that call adapt after
overloade resolution and routes those calls through a marker
method. It then adds one more call to this in `inferPolyAlternatives`,
which fixes the bug.