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.

```
SI-6192  Range: to, until and end are confusing

Added some documentation explaining what the role of `end` is.
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
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`.
Revert "Disable flaky presentation compiler test."

This reverts commit 8986ee4fd56c53d563165d992185c6c532f35790.

Scaladoc seems to work reliably for 2.11.x. We are using it in the IDE builds and haven't noticed any
flakiness, so we'd like to get reinstate this test.
SI-8291 Fix implicitNotFound message with type aliases

This pattern of code is typically a bug:

    if (f(tp.typeSymbol)) {
       g(tp.typeArgs)
    }

Intead, one needs to take the base type of `tp` wrt `tp.typeSymbol`.

This commit does exactly that when formatting the `@implicitNotFound`
custom error message.

Patch found on the back of an envelope in the handwriting of @adriaanm
SI-7746 patmat: fix non-determinism, infeasible counter examples
Fixes non-determinism within the DPLL algorithm and disallows
infeasible counter examples directly in the formula.

The function to compute all solutions was flawed and thus only
returned a subset of the solutions. The algorithm would stop too soon
and thus depending on the ordering of the symbols return more or less
solutions. I also added printing a warning when the search was stopped
because the max recursion depth was reached. This is very useful as an
explanation of spuriously failing regression tests, since less counter
examples might be reported. In such a case the recursion depth should
be set to infinite by adding `-Ypatmat-exhaust-depth off`.

The mapping of the solutions of the DPLL algorithm to counter examples
has been adapted to take the additional solutions from the
solver into account:

Consider for example `t8430.scala`:

```Scala
sealed trait CL3Literal
case object IntLit extends CL3Literal
case object CharLit extends CL3Literal
case object BooleanLit extends CL3Literal
case object UnitLit extends CL3Literal

sealed trait Tree
case class LetL(value: CL3Literal) extends Tree
case object LetP extends Tree
case object LetC extends Tree
case object LetF extends Tree

object Test {
  (tree: Tree) => tree match {case LetL(CharLit) => ??? }
}
```

This test contains 2 domains,  `IntLit, CharLit, ...` and `LetL, LetP, ...`,
the corresponding formula to check exhaustivity looks like:

```
    V1=LetC.type#13    \/ V1=LetF.type#14 \/    V1=LetL#11     \/  V1=LetP.type#15    /\
 V2=BooleanLit.type#16 \/  V2=CharLit#12  \/ V2=IntLit.type#17 \/ V2=UnitLit.type#18  /\
      -V1=LetL#11      \/ -V2=CharLit#12  \/                   \/
```

The first two lines assign a value of the domain to the scrutinee (and
the correponding member in case of `LetL`) and prohibit the counter
example `LetL(CharLit)` since it's covered by the pattern match. The
used Boolean encoding allows that scrutinee `V1` can be equal to
`LetC` and `LetF` at the same time and thus, during enumeration of all
possible solutions of the formula, such a solution will be found,
since only one literal needs to be set to true, to  satisfy that
clause. That means, if at least one of the literals of such a clause
was in the `unassigned` list of the DPLL procedure, we will get
solutions where the scrutinee is equal to more than one element of the
domain.

A remedy would be to add constraints that forbid both literals
to be true at the same time. His is infeasible for big domains (see
`pos/t8531.scala`), since we would have to add a quadratic number of
clauses (one clause for each pair in the domain). A much simpler
solution is to just filter the invalid results. Since both values for
`unassigned` literals are explored, we will eventually find a valid
counter example.
Cleanup `LinkedHashSet` fixes and replace them with `Set` (i.e., back
to initial implementation).

Assuming that the DPLL procedure does not run into max recursion
depth, that workaround is not needed anymore, since the non-
determinism has been fixed.
Merge pull request #3982 from retronym/ticket/8845

SI-8845 Control flow pot-pourri crashes GenASM, but not -BCode
Merge pull request #4029 from retronym/ticket/8291

SI-8291 Fix implicitNotFound message with type aliases
Merge pull request #4027 from dragos/doc/reinstate-test

Revert "Disable flaky presentation compiler test."
Merge pull request #4019 from Ichoran/issue/6192

SI-6192  Range: to, until and end are confusing
Merge pull request #4023 from retronym/topic/time-me-out

Increase REPL startup timeout to avoid test failures
SI-8843 AbsFileCL acts like a CL

Let the AbstractFileClassLoader override just the usual suspects.

Normal delegation behavior should ensue.

That's instead of overriding `getResourceAsStream`, which was intended
that "The repl classloader now works more like you'd expect a classloader to."
(Workaround for "Don't know how to construct an URL for something which exists
only in memory.")

Also override `findResources` so that `getResources` does the obvious thing,
namely, return one iff `getResource` does.

The translating class loader for REPL only special-cases `foo.class`: as
a fallback, take `foo` as `$line42.$read$something$foo` and try that class file.
That's the use case for "works like you'd expect it to."

There was a previous fix to ensure `getResource` doesn't take a class name.
The convenience behavior, that `classBytes` takes either a class name or a resource
path ending in ".class", has been promoted to `ScalaClassLoader`.
Merge pull request #3954 from gbasler/ticket/7746-2.11

SI-7746 fix unspecifc non-exhaustiveness warnings and non-determinism in pattern matcher (2.11)
SI-8731 warning if @switch is ignored

For matches with two or fewer cases, @switch is ignored. This should
not happen silently.
SI-8888 Avoid ClassFormatError under -Ydelambdafy:method

The pattern matcher phase (conceivably, among others) can generate
code that binds local `Ident`s symbolically, rather than according
to the lexical scope. This means that a lambda can capture more than
one local of the same name.

In the enclosed test case, this ends up creating the following
tree after delambdafy

    [[syntax trees at end of                delambdafy]] // delambday-patmat-path-dep.scala
    matchEnd4({
      case <synthetic> val x1: Object = (x2: Object);
      case5(){
        if (x1.$isInstanceOf[C]())
          {
            <synthetic> val x2#19598: C = (x1.$asInstanceOf[C](): C);
            matchEnd4({
              {
                (new resume$1(x2#19598, x2#19639): runtime.AbstractFunction0)
              };
              scala.runtime.BoxedUnit.UNIT
            })
          }
        else
          case6()
      };
      ...
    })
    ...
    <synthetic> class resume$1 extends AbstractFunction0 {
      <synthetic> var x2: C = null;
      <synthetic> var x2: C = null;
      ...
    }

After this commit, the var members of `resume$1` are given fresh
names, rather than directly using the name of the captured var:

    <synthetic> var x2$3: C = null;
    <synthetic> var x2$4: C = null;
Merge pull request #4033 from retronym/ticket/8888

SI-8888 Avoid ClassFormatError under -Ydelambdafy:method
Update stripPrefix/StringLike docs to talk about no op case

Incorporate review comments by Som Snytt.