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
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.
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!
Problem with EOL in tests for Printers is fixed
Fix typo

In `for inner classes `val mm2 = im.reflectClass(<module symbol>)``, `<module symbol>` should read `<class symbol>`.
Merge pull request #3354 from xeno-by/topic/enclosing-xxx

deprecates c.enclosingTree-style APIs
SI-8157 Make overloading, defaults restriction PolyType aware

Named/Default args levies an implementation restriction that
only one overloaded alternative may declare defaults.

But, this restriction failed to consider polymorphic methods.

Rather than matching on MethodType, this commit uses `Type#paramms`,
which handles PolyTypes and curried MethodTypes in one fell swoop.
Avoid cycles in Symbol toString under -Ydebug

This is the first of two commits to restore workingness
to the compiler under `-Ydebug`.

`ResetAttrs` is now called during case class unapply synthesis,
after the UnTyper was recently banished.

But, this class has some low-level tracing that is triggered
under `-Ydebug` (irrespective of any `-Ylog` settings.)

This tracing code calls `Symbol#toString`, which, in an attempt
to discriminate primary from secondary constructors, accesses
the info of its owner. This is sufficient to hit a dreaded
`CyclicReferenceError`.

The enclosed test compiles a case class under this option
to show that things now compile. It still spews out unwanted
output; this will be removed in the next commit.
Don't trace the low-level details of ResetAttrs under -Ydebug

This need for this output is highly situational and since we've
starting using this resettter in case classes and names/defaults,
it is polluting our consoles.
Merge pull request #3283 from paulp/pr/dotless-targs

Dotless type application for infix operators.
Merge pull request #3380 from retronym/ticket/8157

 Make overloading, defaults restriction PolyType aware
Merge pull request #3373 from densh/topic/std-liftable-refinement

A few minor changes to standard liftable instances and liftable support
Merge pull request #3378 from Blaisorblade/patch-1

Fix typo
Merge pull request #3377 from VladimirNik/sprinter-eol-fix

Fix EOL-printing in Printers test suite
Merge pull request #3381 from retronym/topic/debug-friendliness

Fix compilation under -Ydebug