Upgrade pax-url-aether to 1.6.0.

Since our jenkins uses mirrors with passwords,
we needed a fix for https://ops4j1.jira.com/browse/PAXURL-217
in order to run osgi.test on jenkins, now that we use maven more.
We didn't hit this bug before because we were using a standard
location for the maven local repository, but that causes problems
with concurrent jenkins jobs accessing it.

Also, upgrade STARR because Jenkins is using `skip.locker` now.

See https://groups.google.com/d/msg/scala-internals/7R-Y5txP8NI/DX_JWFO2fu4J
for a discussion of the problem this should fix.
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.
Revived tests that once depended on xml

I was a bit overzealous in moving stuff over to scala-xml in 9c50dd5274
These were all compiler tests that accidentally touched on xml.
I've tried to delicately decouple them so they can roam the
scalac pastures as intended.
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-7961 Fix false positive procedure warnings

Two issues are fixed in this commit:
 - `def foo: Unit` was detected as missing a return type
 - The warning was emitted for constructors, but
   `def this(...): Unit = ...` is not valid Scala syntax
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.
fix IntMap#foreachValue and LongMap#foreachValue scaladoc
Added information on how to launch and debug scalac inside Eclipse
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.
Test infrastructure for scope completion

Adds a new marker /*_*/ to trigger scope completion test.
Original type completion test oracles update for the tweaked output
Adds test cases for scope completion
SI-7280 Scope completion not returning members provided by imports

Updates localeContext() to return the best context possible when there are none directly
associated with the given position. It happens when an expression cannot be
successfully typed, as no precise ContextTree covers the expression location, or if the
position is not inside any expression.
Adds corresponding tests
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
Merge pull request #3145 from dotta/issue/update-eclipse-readme

Added information on how to launch and debug scalac inside Eclipse
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.
fix typo
Merge pull request #3141 from soc/SI-7961

SI-7961 Fix false positive procedure warnings
Merge pull request #3151 from xuwei-k/future-typo

fix typo
New mutable hash map with Long keys: partially solves SI-5263 and is relevant
to SI-6825.

The hash map is based on an open addressing scheme that provides
dramatically faster (mostly due to specialization) get and contains
operations than either the standard Java HashMap or any of the existing
Scala hash maps.  It doesn't work well above 500,000,000 elements as
the arrays cannot scale past 2^30 elements.  Maps are not faster in
general due to the lack of specialization of Function1[Long, V].

Revisions made sure that all return types in the public API are specified.
Also switched to a leading-zeros method of calculating the initial mask (to
save a few ns), and used an occasionally-more-efficient version of
seekEntryOrOpen.  Also edited out specific performance numbers and moved
constants to companion.