an ICode InvokeStyle can now answer whether it isSuper
new bytecode emitter, GenBCode, for now under a flag

GenBCode is a drop-in replacement for GenASM with several advantages:

  - faster: ICode isn't necessary anymore.
    Instead, the ASTs delivered by CleanUp (an expression language)
    are translated directly into a stack-language (ASM Tree nodes)

  - future-proofing for Java 8 (MethodHandles, invokedynamic).

  - documentation included, shared mutable state kept to a minimum,
    all contributing to making GenBCode more maintainable
    than its counterpart (its counterpart being GenICode + GenASM).

A few tests are modified in this commit, for reasons given below.

(1) files/neg/case-collision

    Just like GenASM, GenBCode also detects output classfiles
    differing only in case. However the error message differs
    from that of GenASM (collisions may be show in different order).
    Thus the original test now has a flags file containing -neo:GenASM
    and a new test (files/neg/case-collision2) has been added
    for GenBCode. The .check files in each case show expected output.

(2) files/pos/t5031_3

    Currently the test above doesn't work with GenBCode
    (try with -neo:GenBCode in the flags file)
    The root cause lies in the fix to
    https://issues.scala-lang.org/browse/SI-5031
    which weakened an assertion in GenASM
    (GenBCode keeps the original assertion).
    Actually that ticket mentions the fix is a "workaround"

(3) files/run/t7008-scala-defined

    This test also passes only under GenASM and not GenBCode,
    thus the flags file. GenASM turns a bling eye to:

      An AbstractTypeSymbol (SI-7122) has reached the bytecode emitter,
      for which no JVM-level internal name can be found:
      ScalaClassWithCheckedExceptions_1.E1

    The error message above (shown by GenBCode) highlights
    there's no ScalaClassWithCheckedExceptions_1.E1 class,
    thus shouldn't show up in the emitted bytecode
    (GenASM emits bytecode that mentions the inexistent class).
two bytecode tests atune with bytecode by GenASM
SI-5031 fixed in GenBCode

The GenASM-based fix for SI-5031 is 0527b2549bcada2fda2201daa630369b377d0877
SI-6221 inference with Function1 subtypes.

There appears to be no upper bound on the number of places
we have to remove calls to typeSymbol and introduce calls to
baseType. This one was type inference for function parameter
types: worked when expected type was A => B, but not if there
was an implicit conversion from A => B to the expected type.
SI-7582 ClassfileParser: populate privateWithin of Java module class

The `privateWithin` attribute of Java companion module classes was
correctly set under joint compilation (ie, when using JavaParser),
but not under separate compilation.

This commit remedies this. The test covers variety of Java symbols.
SI-7582 Only inline accessible calls to package-private Java code

Two problems here.

The inliner was using `isPrivate` / `isProtected` to determine access.
The fallthrough considered things to be (bytecode) public. This is okay
in practice for Scala code, which never emits package private code.

Secondly, we must check accessibility of the called symbol *and* its
owner. This case is tested in `run/t7582b`.

This commit tightens the check for Java defined symbols: a) check the owner,
and b) don't assume that `! isPrivate` is accessible.
SI-7592 Replace s.t.n.u.TreeSet with s.c.m.TreeSet

This means
- migrating usages from the compiler-specific implementation to the
  one in the standard library
- removing the now unused compiler-specific implementation
Fix typo in Scaladoc
SI-7511 Remove indirection of numeric methods

Methods on `Rich<AnyVal>`s like `abs`, `doubleValue`, `floatValue`,
`longValue`, `intValue`, `byteValue`, `shortValue`, `min`, `max`,
`signum` are slow because they go through multiple indirections
including typeclasses and boxing.

For instance, take `1L.abs`:

Instead of just computing and returning the result (like it is done in
`RichInt`), this is what happens:

- `RichLong` inherits `abs` by extending `ScalaNumberProxy[T]`
- `ScalaNumberProxy[T]` has an abstract
  `protected implicit def num: Numeric[T]`
- This method is implemented in `RichLong` and points to
  `scala.math.Numeric.LongIsIntegral`
- The actual method `abs` now calls `num.abs(self)`
SI-7590 TreeSet should fail fast if Ordering is null

While migrating scala.tools.nsc.util.TreeSet to
scala.collection.mutable.TreeSet, I messed up initialization order
and realized that TreeSet accepts null as an Ordering and only fails
much later.

This change makes mutable.TreeSet and immutable.TreeSet fail
immediately.
additional documentation for GenBCode
Updates .gitignore files.
Unseal a uselessly sealed case class.
Seals some case class hierarchies.
Adds a hashCode method to the Settings class for Ant.
Adds equals and hashCode to three classes that implement Ordered.
Move some code from s.t.n.io to s.t.n.interactive

The only usages of scala.tools.nsc.io.{Lexer,Pickler,PrettyWriter,
Replayer} can be found in scala.tools.nsc.interactive.

Let's move those files closer to their dependencies.
catching up with a fix in master after this PR was submitted

SI-7151 Emit final in bytecode for final inner classes
was fixed in https://github.com/scala/scala/commit/b49b6cf7f0f42d74da854d96eeb0f863357c04cd
more informative name for backend-selection via command-line