more precise isMacroApplication check

Replaces the `symbol.isMacro` check with `symbol.isTermMacro`.
Doesn’t make any difference to trunk but helps a lot with macro annotations.
correctly fails implicit search for invalid implicit macros

There was a rare corner case when implicit search wouldn’t discard
an invalid implicit macro (e.g. the one with mismatching macro impl or
the one with macro impl defined in the same compilation run) during
typechecking the corresponding candidate in typedImplicit1. This is now fixed.
SI-7969 REPL -C columnar output

Let `ConsoleReaderHelper.printColumns` print in a vertical
orientation (similar to `ls -C`) instead of horizontally (`ls -x`).

To support the old behavior, add a property `-Dscala.repl.format=across`
where "across" is the presumptive mnemonic for `-x`.

The format property also takes value `paged` to turn on pagination,
which currently forces single-column output (as does `ls | more`)
for simplicity.
SI-7969 Refactor to trait with test

Make REPL classes testable in junit. Test the Tabulator.
refactor out fresh name prefix extraction logic

1. refactor out FreshNameExtractor out of Quasiquotes cake into
   SymbolTable (can’t put it outside due to the fact that names are
   path-dependent)

2. add optional parameter to the fresh name creator to cover additional
   qq$ prefix needed for quasiquotes

3. add unit tests
Tidy up the Uncurry component of delambdafy

 - Use tree factories that accept symbols and encapsulate ValDef
   creation
 - Use `gen.mkForwarder` to handle the conditional addition of
   `: _*` for varargs functions. We don't need to predicate this
   on `etaExpandKeepsStar`; the only place that need to do that
   is EtaExpansion.
Remove deprecated constructor from the migration annotation

The migration annotation had a deprecated 2 arg constructor that was
deprecated in 2.10.0. This commit removes that constructor. Because
migration is private to the scala package this change shouldn’t affect
the rest of the community.
Removing deprecated code.

Code which has been deprecated since 2.10.0 and which allowed
for straightforward removal.
SI-7969 REPL variable columnar output

Extend column formatting to make columns only as wide as
their widest element.  This is similar to what `ls` does.

Given the longest and shortest string, which bound the
min and max column count, compute the layout for those
possible column counts, and choose the minimal row count
and minimal column count.

The junit test is under pending because it uses expecty.
(Edit: updated without expectytations.)

Example that really benefits, witness the skinny columns:

```
scala> math.

BigDecimal                     PartiallyOrdered             cosh      rint
BigInt                         Pi                           exp       round
E                              ScalaNumber                  expm1     signum
Equiv                          ScalaNumericAnyConversions   floor     sin
Fractional                     ScalaNumericConversions      hypot     sinh
IEEEremainder                  abs                          log       sqrt
Integral                       acos                         log10     tan
LowPriorityEquiv               asin                         log1p     tanh
LowPriorityOrderingImplicits   atan                         max       toDegrees
Numeric                        atan2                        min       toRadians
Ordered                        cbrt                         package   ulp
Ordering                       ceil                         pow
PartialOrdering                cos                          random

```

more
SI-7915 Corrected range positions created during default args expansion

The tree created during expansion of default arguments contained trees with the
wrong type of positions. Let's discuss this with an example. Below is the tree
generated for the `foo` method in the test class included in this commit.

Before this commit:

```
[54:94]def foo(): [58]Unit = <70:90>{
  [70:79]<artifact> val qual$1: [70]Bar = [70:79][70:79][70:79]new [74:77]Bar();
  [80]<artifact> val x$1: [80]Int = [80]qual$1.bar$default$1;
  <70:90><70:83>qual$1.bar([80]x$1)
}
```

Now:

```
[54:99]def foo(): [58]Unit = <70:95>{
  <70:84><artifact> val qual$1: [70]Bar = [70:84][70:84][70:84]new [74:77]Bar();
  [85]<artifact> val x$1: [85]Int = [85]qual$1.bar$default$1;
  <70:95>[84:88]qual$1.bar([85]x$1)
}
```

Here are the list of changes:

* The synthetic `qual$1` has a transparent position, instead of a range position.
* The new Select tree (i.e., `qual$1.bar`) should always have a range position,
  because `selected` (i.e., the called method) is always visible in the source
  (in fact, this is the whole point of the fix, we need a range position or
  hyperlinking request from the Scala IDE won't work).
* The Block that contains the expanded default arguments is forced to have a
  transparent position, as it never exist in the original source.

The tricky part of the fix is the position assigned to the new Select tree,
which needs to respect the range position's invariants. In the specific case,
we ought to make sure that range positions don't overlap. Therefore, the position
assigned to the new Select tree is computed by intersecting the original Select
position (i.e., `baseFun`'s position) and the original qualifier's position
(i.e., `qual`'s position).

If you take a closer look at the range positions assigned in the tree after this
commit, you'll notice that the range position of the `qual$1`'s rhs (i.e.,
[70:84]), and `qual$1.bar` (i.e., [84:88]) might seem to overlap, because the
former ends where the latter begins. However, this not the case because of the
range position's invariant 2, which states:

> Invariant 2: in a range position,  start <= point <  end

Hence, the above two positions aren't overlapping as far as the compiler is
concerned.

One additional aspect (that may look like a detail) is that we make sure to
never generate a position such that its start is after its end. This is why we
take the position with the smallest end point.

Furthermore, calling `withStart` would turn any position in a range position,
which isn't desiderable in general (and, even worse, this can lead to
generation of invalid positions - bad offsets - if the computation is performed
on offset positions). Hence, the position's computation is only performed when
both `baseFun` and `qual` positions are range positions. Indeed, I expect this to
be always the case if the compiler is started with -Yrangepos.

(cherry picked from commit 3009a525b58a4c7865ff524899b85518884ee5f7)
SI-7983 Fix regression in implicit divergence checking

As seen in Slick. Regressed in 039b1cb1a5b8.

In that commit, a call to `normalize` was replaced with `dealiasWiden`
as part of a broad sweeping change. However, while the latter does
less than the former with regards to eta expansion ofhigher kinded
type refs (the motivation of that commit), it also does more when it
comes to singleton types: they are widened to the underlying type.

This was widening away `SingleType(<<package a.b>>, <<package c>>)`
before the special case assiging that type component a complexity of
zero could kick in.

In the test case, extracted from Slick, this meant that the
divergence check would consider that the second type below to
outrank the first in the complexity measure, and abort the implicit
search.

    Shape[?,                        ?  (Coffees, Coffees), ?]
    Shape[DivergenceTest.this.Flat, ?, Coffees,            ?]

After this change, the number of packages enclosing `DivergenceTest`
no longer has a bearing on the complexity score of the type.

Here's how the race was run before hand:

	complexity(<noprefix>): 0
	complexity(<root>): 1
	complexity(foo.type): 2
	complexity(foo.bar.type): 3
	complexity(foo.bar.baz.type): 4
	complexity(DivergenceTest.this.type): 5
	complexity(<noprefix>): 0
	complexity(<root>): 1
	complexity(foo.type): 2
	complexity(foo.bar.type): 3
	complexity(foo.bar.baz.type): 4
	complexity(DivergenceTest.this.type): 5
	complexity(DivergenceTest.this.Flat): 6
	complexity(<noprefix>): 0
	complexity(<root>): 1
	complexity(scala.type): 2
	complexity(Int): 3
	complexity(?): 1
	complexity(DivergenceTest.this.Shape2[DivergenceTest.this.Flat,Int,?]): 16

	complexity(<noprefix>): 0
	complexity(<root>): 1
	complexity(foo.type): 2
	complexity(foo.bar.type): 3
	complexity(foo.bar.baz.type): 4
	complexity(DivergenceTest.this.type): 5
	complexity(?): 1
	complexity(<noprefix>): 0
	complexity(<root>): 1
	complexity(scala.type): 2
	complexity(<noprefix>): 0
	complexity(Coffees): 1
	complexity(<noprefix>): 0
	complexity(<root>): 1
	complexity(scala.type): 2
	complexity(Int): 3
	complexity((Coffees, Int)): 7
	complexity(?): 1
	complexity(DivergenceTest.this.Shape2[?,(Coffees, Int),?]): 15

	dominates(DivergenceTest.this.Shape2[_ <: DivergenceTest.this.Flat, Int, U2], DivergenceTest.this.Shape2[_ <: Level, (Coffees, Int), U1]): true

And afterwards:

	complexity(DivergenceTest.this.type): 1
	complexity(DivergenceTest.this.type): 1
	complexity(DivergenceTest.this.Flat): 2
	complexity(scala.type): 1
	complexity(Int): 2
	complexity(?): 1
	complexity(DivergenceTest.this.Shape2[DivergenceTest.this.Flat,Int,?]): 7

	complexity(DivergenceTest.this.type): 1
	complexity(?): 1
	complexity(scala.type): 1
	complexity(<noprefix>): 0
	complexity(Coffees): 1
	complexity(scala.type): 1
	complexity(Int): 2
	complexity((Coffees, Int)): 5
	complexity(?): 1
	complexity(DivergenceTest.this.Shape2[?,(Coffees, Int),?]): 9

	dominates(DivergenceTest.this.Shape2[_ <: DivergenceTest.this.Flat, Int, U2], DivergenceTest.this.Shape2[_ <: Level, (Coffees, Int), U1]): false

Notice that even in the after shot, `scala.Int` has a complexity of 2.
It should be 1; this will be fixed in a separate commit.
Code reformatting in Implicits

And use List#sum, rather than a fold.

No functional change.
Account for a variation of package types in Implicit Divergence.

While debugging pos/t7983.scala, I noticed that:

    complexity(scala.type): 1
  complexity(Int): 2

The intent of the code is that top level classes should have
a complexity of one. This commit restores that for cases when
we see the prefix type as a ThisType, rather than a SingleType.

I can't construct a test case in which this small difference
is observable in the divergence checks.
SI-7985 Allow qualified type argument in patterns

We were considering the lower case `s` in `case _: Array[scala.Int]`
as a sign that we were dealing with a type variable pattern.

Now, we only do this if a lookahead confirms the absence of a the `.`
SI-7985 Allow projection of lower-cased prefix as pattern type arg

As per the last commit, tighten up the interpretation of a lower
cased identifier meaning that we're looking at a type variable.
SI-7985 Refactor parsing of pattern type args

Just parse as though it is a type, and post process to
add the Bind if it turns out to be a type variable.
use more specific cake dependencies
SI-7221 rewrites pollForWork non-recursively

Fixes #1001407
deprecate Pair and Triple
2.11.0-M7 starr, 1.11.1 scalacheck, bump modules.

Also consult `extra-repo` more liberally to make it easier
to test e.g., a staged scalacheck while releasing modules.