GenBCode version of "Updating Position call sites" commit

7d62df035cd4393c73e7530e1cad1130e79d90c6 modifies GenASM, we follow suite here.
GenBCode version of "not eliminate loadmodule on static methods."

f27f2d80d759130597b652d6cc9d789f8c472e5a modifies GenASM, we follow suite here,
making test/files/run/static-module-method.scala pass under GenBCode.
there's a reason for this code in GenBCode

aced32d05c97651534f468bc9a475ea5f6ae75b8 removed unused code,
along with code that populates a cache with entries needed
in some program runs. I'm re-adding the latter.
removing dead code in BCodeSyncAndTry
overzealous assert in GenBCode

The assert in question was aimed at ruling out
gotos (ie "jumping-applys") in actual argument position
of a jumping-apply.

But the assert in question went overboard
to also rule out a LabelDef in actual argument position.

This commit removes the assert in question altogether.

The unwanted behaviors, and only those, are rule out by
the test added in this commit and the existing tests for SI-6089.

See also https://issues.scala-lang.org/browse/SI-7749
removing defensive code made obsolete by existing fix to SI-5604

SI-5604 was fixed in commit e6f10b07d44f0ddde26246b4a41527a84eede81c
overzealous assert in BCodeBodyBuilder rejected throw null
Dotless type application for infix operators.

When you have an aesthetic expresion like

  def f(xs: Iterator[Int]) = (
    xs takeWhile (_ < 1000)
             map (_ * -1)
          filter (_ % 2 == 0)
         flatMap (x => List(x, x))
    reduceOption (_ + _)
           maxBy (_.toString)
  )

And then for whatever reason you have to perform explicit
type application in the midst of that expression, it's
aggravating in the extreme that it has (had) to be rewritten
in its entirety to accommodate that change.

So now you can perform type application in the middle of it.

For reasons not entirely clear to me postfix operators are
excluded. The discussion as well as the approval for the infix
variation of it can be found at:
  https://groups.google.com/forum/#!msg/scala-language/eJl1wnkEz9M/hR984-lqC5EJ
SI-4370 Range bug: Wrong result for Long.MinValue to Long.MaxValue by Int.MaxValue

Fixed by rewriting the entire logic for the count method.  This is necessary because the old code was making all kinds of assumptions about what numbers were, but the interface is completely generic.

Those assumptions still made have been explicitly specified.  Note that you have to make some or you end up doing a binary search, which is not exactly fast.

The existing routine is 10-20% slower than the old (broken) one in the worst cases.  This seems close enough to me to not bother special-casing Long and BigInt, though I note that this could be done for improved performance.

Note that ranges that end up in Int ranges defer to Range for count.  We can't assume that one is the smallest increment, so both endpoints and the step need to be Int.

A new JUnit test has been added to verify that the test works.  It secretly contains an alternate BigInt implementation, but that is a lot slower (>5x) than Long.
SI-8148 fix anonymous functions with placeholders

Quasiquotes used to fail to generate proper fresh identifiers for
anonymous functions like:

  q"_ + _"

Due to improper initialization of FreshNameCreator in quasiquote
parser which was erroneously not preserved throughout parsing of
the code snippet but re-created on every invocation.
Remove redundant asInstanceOf for liftable

Previous encoding of Liftables which had universe passed in
as a parameter required a cast to solve path-dependant
madness problems:

  trait OldLiftable[T] { def apply(u: Universe, v: T): u.Tree }

In this case compiler wasn't smart enough to find out that

  liftFoo(universe, foo)

returns the same type of tree we were working with (universe.Tree)
and we had to cast to make it work:

  liftFoo(universe, foo).asInstanceOf[universe.Tree]

Now this cast is redundant as universe is not a parameter of
Liftable's apply.
Lift Some, None, Nil, Left, Right not just supertypes

Previously leaf concrete types were not lifted which
could have caused weird problems when types is too
precise:

  val s1 = Some(2)
  q"$s1" // used to fail
Give better names to UnliftHelper1 and UnliftHelper2

Previous ones were inscrutable but thankfully @xeno_by
helped me out to find better alternatives.;
Test edge cases of literal lifting

Previously in some corner situation proper Liftable instance
might not have been resolved.

In particular q"${true}" and q"${""}" used to fail.
SI-8126 Add a '-Xsource' flag allowing compilation in e.g. 2.10 mode

This is aimed at letting the 2.11+ compiler operate, at least until
phase:typer, on a 2.10 codebase.
SI-8126 Puts SI-6899 fix under a source level flag
SI-8126 Puts SI-7335 fix behind a source level flag
deprecates c.enclosingTree-style APIs

Existing enclosing tree macro APIs face both technical and philosophical problems.

On the one hand, it’s close to impossible to provide their robust
implementation within the current typer infrastructure. From the very
beginning, these APIs have been very experimental, and I was very much
hoping to tackle the underlying technical problems, but after a year and
a half I can say that it’s still outside our reach.

On the other hand, we’re gravitating towards increasingly more local macro
expansion, which is in direct contradiction with the existence of
c.enclosingTree APIs. Therefore, in order to be able to further evolve
macros, we need need additional freedom to reshape the enclosing tree APIs.

Therefore I suggest we deprecate the aforementioned APIs and start
preparing ourselves to removing them for good in 2.12.0.

I hope that existing macros that use these APIs can be reformulated in
terms of completely local expansion or be built on top of orthogonal
language features (existing ones or new ones, e.g. something like
https://groups.google.com/forum/#!topic/scala-debate/f4CLmYShX6Q).
Please share your use cases, and I will be glad to help!

We have at least the entire 2.12 development cycle ahead of us, so I’m
sure we’ll figure this out. Let’s shape robust and scalable reflection
API together!
Merge pull request #3372 from densh/si/8148

 fix anonymous functions with placeholders in quasiquotes
Merge pull request #3319 from Ichoran/issue/4370

 Range bug: Wrong result for Long.MinValue to Long.MaxValue by In...