SI-7242 Fix crash when inner object mixes in its companion

Given:

    class C {
      trait T { C.this }            // C$T$$$outer$ : C
      object T extends T { C.this } // C$T$$$outer$ : C.this.type
    }

object T ended up with a definitions for both of the accessors.
These cannot co-exist, as they have the same erased type. A crash
ensued almost immediately in explitouter.

Fortunately, the solution is straightforward: we can just omit
the mixin outer accessor altogether, the objects own outer accessor
is compatible with it.

    scala> :javap C.T
    Compiled from "<console>"
    public interface C$T{
        public abstract C C$T$$$outer();
    }

    scala> :javap C.T$
    Compiled from "<console>"
    public class C$T$ extends java.lang.Object implements C$T{
        public C C$T$$$outer();
        public C$T$(C);
    }

I also added an assertion to give a better error message in
case we find ourselves here again.

Also includes tests from SI-3994, which I'll mark as a duplicate.
Read version 51 (JDK 7) class files.

This commit makes the ClassFileReader/ICodeReader parse class files
from JDK 7 (class file version 51). It does that by skipping over
the method handle related entries in the constant pool and by doing
some dummy processing on invoke dynamic instructions. The inliner
is updated to not try to inline a method with an invoke dynamic
instruction. A place holder INVOKE_DYNAMIC instruction is added to ICode
but it is designed to create an error if there's ever any attempt to
analyze it. Because the inliner is the only phase that ever tries
to analyze ICode instructions not generated from Scala source and
because Scala source will never emit an INVOKE_DYNAMIC, the place
holder INVOKE_DYNAMIC should never cause any errors.

A test is included that generates a class file with INVOKE_DYNAMIC
and then compiles Scala code that depends on it.
[backport] SI-7237 Always choose ForkJoinTaskSupport

... on Java 6 and above.

ForkJoinTaskSupport works on Hotspot, Avian and J9,
while ThreadPoolTaskSupport causes the test
test/files/scalacheck/parallel-collections
to reliably hang on all three.

We keep ThreadPoolTaskSupport around to keep the hope
alive that we still have a glimpse of 1.5 support.
SI-7253: respect binary compatibility constraints

From the JLS one can prove that moving a method to a superclass is a binary
compatible change, both forward and backward. That's because when compiling a
method call `c.foo()`, where c: C, the output descriptor *must* refer to `C` and
not to the class where `foo()` is actually defined.

This patch just ensures that, and adds a test comparing generated descriptors
against the Javac output.

The sample code is from Paul Philipps, the fix and the bytecode comparison code
from me.

From 2006 (9954eafffd5e60676238369ab0ed5797c92b4a7b, a fix for bug 455 in the
old bug tracker
http://www.scala-lang.org/sites/default/files/aladdin/displayItem.do%3Fid=455.html)
until 2.9, Scalac has followed this rule "often" (that is, when C is *not* an
interface).

This behavior was wrong, but the bug was hard to trigger. AFAICS, this can
create problems only when moving a method to a super interface in a library and
expecting forward binary compatibility - that is, compiling some Scala client
code against the new version of the library, and trying to run this code against
the old version of the library. This change grows an interface, so it is valid
only if clients are supposed to *not* implement the library.  Apparently, this
is so rare that nobody noticed.

Since 2.10 (0bea2ab5f6b211a83bbf14ea46fe57b8163c6334), Scalac follows this rule
*only* when C is an interface (I assume by oversight, since the main change was
an accessibility check), so the bug was finally triggered.

The new code will have to emit INVOKEINTERFACE instead of INVOKEVIRTUAL a bit
more often, compared to 2.9 (but not to 2.10). I don't know whether
INVOKEINTERFACE is noticeably slower (it shouldn't be); but this is the safest
fix since this behavior is mandated by the JLS.
If somebody disagrees and believes the 2.9 is significantly faster, IMHO he
should send a separate pull request (although ProGuard is probably a better
place for the change).
Remove fragile code, made redundant by previous commit

The JLS requires, as an exception to generate calls referring to Object for all
methods defined in Object itself; hence, whenever the method owner is Object,
the call should refer to the method owner. The previous commit implemented this
directly in useMethodOwner, so the special case for Object in isInterfaceCall is
now redudant. Hence, remove it.
SI-7253: update comments and naming

Rename isInterfaceCall -> needsInterfaceCall, which is more accurate since a
receiver can't literally be an interface call.
SI-7251, compiler crash with $.

We don't need to assert our way out of tight spots, we can issue
an error. Or so I once thought.

It turns out lots of assertions have been disappearing before
being heard thanks to "case t: Throwable". Under such conditions,
a failed assertion is a no-op, but an error is an error.

The crash associated with SI-7251 is best avoided by removing the
assertion, which allows an error to be issued in the normal course
of events.

In the course of trying to figure out the above, I cleaned up
ClassfileParser somewhat.
removes duplication in FreeDef extractors
SI-5699 correct java parser for annotation defs.

Correct java source parser not to insert a constructor with the type
 of its value method.
SI-7013 Scaladoc: Fix StackOverflowError

No one see the result value of parse and if so, it's tail-recursive.
Merge pull request #2245 from retronym/ticket/7242

SI-7242 Fix crash when inner object mixes in its companion
Merge pull request #2268 from scalamacros/topic/shannon-entropy

removes duplication in FreeDef extractors
Merge pull request #2274 from vigdorchik/ticket/si-5699

SI-5699 correct java parser for annotation defs.
Merge pull request #2264 from Blaisorblade/issue/7253

SI-7253: respect binary compatibility constraints
SI-7290 Discard duplicates in switchable alternative patterns.

The pattern matcher must not allow duplicates to hit the
backend when generating switches. It already eliminates then
if they appear on different cases (with an unreachability warning.)

This commit does the same for duplicated literal patterns in an
alternative pattern: discard and warn.
Expand test for SI-6124 to demonstrate cause of SI-7285.
SI-7285 Fix match analysis with nested objects.

The fix for SI-6146 introduced `nestedMemberType` to
enumerate sealed subtypes based on the (prefixed) type
of the scrutinee and the symbols of its sealed subclasses.
That method needed to widen `ThisType(modSym)`s to
`ModuleTypeRef(modSym)` before calling `asSeenFrom`.

However, this could lead to confused in the match analysis,
which sees `ModuleTypeRef` as distinct from singleton types
on the same modules (after all, they aren't =:=). Spurious
warnings ensued.

This commit makes two changes:

 - conditionally re-narrow the result of `asSeenFrom` in `nestedMemberType`.
 - present `a.b.SomeModule.type` as `SomeModule` in warnings emitted
   by the pattern matcher.
SI-6210 Test case for already-fixed pattern matcher bug

The fix arrived in SI-6022 / #1100 / 2.10.0-M7.
SI-7246 Make $outer pointer elision Java aware

In e0853b3, a space-saving optimization elided the outer pointer
of inner classes if the the (protected) outer pointer of the
immediate parent class was guaranteed to point to the same instance.

But, this check failed to account for Java parent classes, which
don't follow the Scala scheme. This commit disables the optimization
in that case.

The original test case in e0853b3 was anemic, I've fleshed it out to:

  - test the presense or absense of $outer pointers with Java reflection
  - test the optimization works in the presense of aliased and annotated
    aliased types. (The former worked already, the latter required a
    change to the implementation.)
  - Test the negative case when the prefixes don't line up and the
    subclass in fact needs its own $outer.

This patch is based on work by Euguene Vigdorchik with some
additions by Jason Zaugg.
Sanity for build.xml: exscriptus&positus delendus est.

Reduced copy/pasting to the best of my antabilities.
The next person to duplicate anything without written
permission will be sentenced to a week in xmhell.

While I was at it, made sure that layering is respected.
The quick phase exclusively uses the locker compiler for building.

The jar task will fail when trying to create an empty jar.

Replaced the crazy if/unless/depends constructs by if/then/else.
Version suffix computation should now be comprehensible.
I threw in some validation to make sure the various suffixes are consistent.

Also, no more init/pre-foo tasks unless absolutely necessary.

Introduced a couple of macros to capture the essence of staged compilation.

Notes:
  - remove lib.extra, standardize on aux.libs
  - collapse *.javac.path and *.build.path
  - rename starr.classpath to starr.compiler.path
  - only repl needs jline, locker.compiler.path = locker.comp.build.path + forkjoin
  - more uniform build.paths (compiler = reflect + library)
    - uniformity means slightly bigger classpaths
      (e.g. forkjoin is only used in library,  but inherited by compiler)
    - pruned: some spurious dependencies removed
    - compilerpathref = compiler build path
  - silence test.osgi, by hook or by crook
  - centralized clean tasks
  - reduce duplication in property usage
  - fix pack.xml to pack scaladoc/partest instead of scaladoc/scala-partest
  - TODO: -XDignore.symbol.file necessary for library? only needed for forkjoin?
  - document usage from jenkins, fix typo: partest.scalac*_*opts

New targets:
 - quick-opt
 - strap-opt
 - test.bc
 - test.osgi
 - test.osgi.comp
 - test.osgi.init
 - test.stability-opt

Removed/replaced targets:
 - asm.clean asm.lib asm.start
 - bc.run
 - dist.latest dist.latest.unix dist.latest.win dist.start
 - docs.all docs.manmaker docs.pre-comp docs.pre-continuations-plugin
 - docs.pre-jline docs.pre-lib docs.pre-man docs.pre-partest docs.pre-scalap
 - forkjoin.clean forkjoin.lib forkjoin.pack forkjoin.start
 - graph.clean
 - init.build.nopatch.release init.build.patch.release init.build.release
 - init.build.snapshot init.build.suffix.done init.extra.tasks
 - init.fail.bad.jdk init.hasbuildnum init.hasmavensuffix init.jars
 - init.jars.check init.maven.jars init.maven.tasks init.osgi.suffix
 - init.osgi.suffix.final init.osgi.suffix.snapshot init.testjava6
 - init.version.done init.version.git init.version.release init.version.snapshot
 - init.warn.jdk7 locker.pre-comp locker.pre-lib locker.pre-reflect
 - locker.unlock.comp locker.unlock.lib locker.unlock.pre-comp
 - locker.unlock.pre-lib locker.unlock.pre-reflect locker.unlock.reflect
 - osgi.clean osgi.test osgi.test.comp osgi.test.init
 - pack.clean pack.pre-bin pack.pre-comp pack.pre-lib pack.pre-partest
 - pack.pre-plugins pack.pre-reflect pack.pre-scalap pack.start
 - palo.comp palo.lib palo.pre-bin palo.pre-comp palo.pre-lib palo.pre-reflect
 - palo.reflect palo.start quick.pre-bin
 - quick.pre-comp quick.pre-interactive quick.pre-lib quick.pre-partest
 - quick.pre-plugins quick.pre-reflect quick.pre-repl quick.pre-scalacheck
 - quick.pre-scaladoc quick.pre-scalap
 - sbt.clean sbt.compile sbt.done sbt.libs sbt.start
 - starr.clean
 - strap.clean strap.pre-comp strap.pre-lib strap.pre-reflect strap.start
 - test.debug test.pre-run