updating resolveDups() to use MethodTFA.mutatingInterpret()
Basing Futures on Try instead of Either
SI-6185 - add "prepare" hook to ExecutionContext

Enables important abstractions to be built on top of futures,
such as Twitter's "Local" for handling data local to a callback chain.
Temporarily skips failing test due to optimizer bug SI-6188

Also swaps the arguments to method transform on Try, so as to mirror transform on scala.concurrent.Future.
Merge branch 'try-based-futures' of https://github.com/heathermiller/scala into try-based-futures
SBT compiler interface now compiled in ant build.  Ensures those still using ant don't break the interface.
SI-5788 Tailcalls LabelDefs correctly duplicated

... in specialization.

This is a quick hack to get SI-5788 fixed in 2.10.x. The full patch,
which fixes the tailcalls LabelDefs will be merged into trunk, as it's
too late for big changes.

For reference, the complete fix is: e86afe65c8
SI-6102 avoid emitting illegal exception table range
test case for SI-6102
Fix for SI-6063, broken static forwarders.

Have to rule out access boundaries as well as private/protected.
SI-6178 reflective invocation of magic symbols

In Scala there are some methods that only exist in symbol tables,
but don't have corresponding method entries in Java class files.

To the best of my knowledge, these methods can be subdivided into five groups:
1) stuff weaved onto Any, AnyVal and AnyRef (aka Object),
2) magic methods that Scala exposes to fix Java arrays,
3) magic methods declared on Scala primitive value classes,
4) compile-time methods (such as classOf and all kinds of macros),
5) miscellaneous stuff (currently only String_+).

To support these magic symbols, I've modified the `checkMemberOf` validator
to special case Any/AnyVal/AnyRef methods and adjusted MethodMirror and
ConstructorMirror classes to use special invokers for those instead of
relying on Java reflection.

Support for value classes will arrive in the subsequent commit, because
it requires some unrelated changes to the mirror API (currently mirrors
only support AnyRefs as their targets).
SI-6179 mirrors now work with value classes

mirrors now carry a class tag of the receiver, so that they can detect
value classes being reflected upon and adjust accordingly (e.g. allow
Int_+ for ints, but disallow it for Integers).

Surprisingly enough derived value classes (SIP-15 guys that inherit from AnyVal)
have been working all along, so no modification were required to fix them.
SI-6181 method mirrors now support by-name args

Arguments provided in by-name positions are now automatically wrapped
in Function0 instances by method mirrors.
sanity check for reflectConstructor

In 911bbc4 I've completely overlooked the fact that
reflectConstructor exists and that is also needs sanity checks.

Now reflectConstructor checks that the incoming symbol is actually a ctor,
and that it is actually a ctor of the class reflected by the current mirror.
mirrors now support overriden fields and methods

Previously `checkMemberOf` was blocking base fields and methods
that are overriden in receiver.getClass. Now this is fixed.

The fix also uncovered an issue with field mirrors. Currently
their `get` and `set` methods don't respect overriding and always
return field values from a base class.

After discussing this on a reflection meeting, we decided that this
behavior is desirable and that for overriding people should use
reflectMethod and then apply on getters/setters. See the discussion at:
https://github.com/scala/scala/pull/1054.
Fix for SI-4945, repl hang on -i input.

Other breakage had accumulated among Settings. I determined
that once upon a time, "MultiStringSetting" accepted arguments
like this:

  scala -foo bip bop bar

Somewhere this was changed to force a : argument, like

  scala -foo:bip,bop,bar

This incurs breakage.  The repl has always advertised its -i
option without a colon and it has always been a MultiStringSetting.
Forcing everything into the : seemed like the wrong thing,
especially because it will stomp on any whitespace containing
arguments, whereas in the original form

  scala -foo bip "bop bar" baz

will yield its arguments as given.

So lacking any good ideas and knowing something probably depends
on each way already, I made it work both ways.
SI-6199 unit-returning methods now return unit

Since Scala reflection relies on Java reflection to perform member invocations,
it inherits some of the quirks of the underlying platform.

One of such quirks is returning null when invoking a void-returning method.
This is now fixed by introducing a check after calling invoke.
Restored :warnings to working order.

As seen here.

scala> class A { @deprecated("foo") def a = 1 }
warning: there were 1 deprecation warnings; re-run with -deprecation for details
defined class A

scala> :warnings
<console>:7: warning: @deprecated now takes two arguments; see the scaladoc.
       class A { @deprecated("foo") def a = 1 }
                  ^

scala> val x = 5 toString
warning: there were 1 feature warnings; re-run with -feature for details
x: String = 5

scala> :warnings
<console>:7: warning: postfix operator toString should be enabled
by making the implicit value language.postfixOps visible.
This can be achieved by adding the import clause 'import language.postfixOps'
or by setting the compiler option -language:postfixOps.
See the Scala docs for value scala.language.postfixOps for a discussion
why the feature should be explicitly enabled.
       val x = 5 toString
                 ^
SI-6145 lax typing of args to synthetic case-labels

Use wildcard for the expected type of the arguments of a jump to a label
synthesized by the pattern matcher... except during erasure: we must take the
expected type into account as it drives the insertion of casts!

It's ok since we're typing the translation of well-typed code. The only "type
errors" we catch are skolem mismatches. (after erasure the existential types that
before caused problems have disappeared.)

It's necessary to balance GADT magic, SI-6145, CPS type-driven transforms and
other existential trickiness. I've exhausted all other semi-clean approaches I
could think of:
  - the right thing to do -- packing existential types -- runs into limitations
    in subtyping existential types,
  - casting breaks SI-6145 (and it's an unnecessary cast at run time),
  - not casting breaks GADT typing as it requires sneaking ill-typed trees
    past typer
SI-6183 don't crash on type error in outer test

unfortunately without test case since the report was hard to minimize
since it was a crash on erroneous code, I figured a backstop against a crash should suffice