SI-8143 Regressions with override checks, private members

These regressed in e609f1f20b, which excluded all private methods from
overriding checks. We should only exclude private[this] members on the
low end of a pair, as was done before that commit, and, we must also
exclude private members on the high side.

Why? Warning: reverse engineered intuition follows.

We need to report an error when if a private method in a subclass
has matches a less-private method in the super class and report an
error, lest the user be fooled into thinking it might be invoked
virtually. On the other hand, adding a private method to a super
class shouldn't invalidate the choice names of public members in
its superclasses.

I've removed the test case added by that commit and will lodge a
reworked version of it that Paul provided as a new issue. That shows
a bug with qualified private + inheritance.

In addition, the expectation of `neg/accesses.check` is reverted
to its 2.10.3 version, which I believe is correct. When it was
changed in e609f1f20b it sprouted a variation, `neg/accesses-2`,
which has now changed behaviour. The intent of that test will
be captured in the aforementioned issue covering qualified private
inheritance.
SI-6844 restrict splicing in parameter position

Previously were a bit too permissive on how splicing in function
parameter position worked. This made confusing things like
possible:

   val x = TermName(“x”)
   q”def foo($x)”

Now you can either splice trees in that position (ValDefs) or
you have to provide type if you splice a name.
SI-8076 improve support for implicit argument list

This adds support for construction and deconstruction
of implicit argument list which was originally suggested
by @cvogt.

1. Splicing vale into implicit argument list automatically
   adds implicit flag to them:

     val x = q"val x: Int"
     q"def foo(implicit $x)"
     // <=> q"def foo(implicit x: Int)"

2. One might extract implicit argument list separately from
   other argument lists:

     val q”def foo(...$argss)(implicit ..$impl)" =
       q"def foo(implicit x: Int)
     // argss is Nil, impl contains valdef for x

   But this doesn't require you to always extract it separatly:

     val q”def foo(...$argss)" =
       q"def foo(implicit x: Int)
     // argss contains valdef for x
Improve naming of ReadStdin

We don't need to say everything twice, methods are already prefixed
with “read”.
SI-7445 ListMap.tail is returning wrong result

Reverted the commit that introduced the bug, and modified HashMap to no
longer assume that tail is O(1).

Review by @Ichoran, @soc
moves analyzer.ImportType into scala.reflect.internal

This cute little type is necessary for importers to work correctly.
I wonder how we could overlook its existence for almost 2 years.
deprecates resetAllAttrs and resetLocalAttrs in favor of the new API

We now have c.untypecheck, which is supposed to be a counterpart of c.typecheck
in the sense that it goes back from typed trees to untyped ones:
http://stackoverflow.com/questions/20936509/scala-macros-what-is-the-difference-between-typed-aka-typechecked-an-untyped.

Let’s hope that c.untypecheck will soon be able to solve our problems
with partially/incorrectly attributed trees emitted by macros:
https://groups.google.com/forum/#!topic/scala-internals/TtCTPlj_qcQ.
Add support for Java 8 in our build.

We explicitly check for supported Java versions in our build.
Add Java 8 to the list of supported versions.
Merge pull request #3392 from xeno-by/topic/untypecheck

deprecates resetAllAttrs and resetLocalAttrs in favor of the new API
Merge pull request #3382 from soc/topic/std-in

Improve naming of ReadStdin
Work-around for partest failure due to JDK bug.

JDK7 and JDK8 have a bug that causes JVM to print some warning about
applets that is unrelated to whatever we are testing in Scala. Let's
work it around using test/files/filters mechanism that allows us to filter
out output lines based on regexp.
Make abstract-report2 test less dependent on std library.

Replace the use of `Ordering` by custom, dummy trait Xyz defined in test's
source.

By not inheriting from Ordering in abstract-report2 we make the test
less dependent on both Scala and Java library. The reason we are less
dependent on Java is because Ordering extends Java's comparator.

This change is motivated by the fact that Java 8 introduced default
method `reversed` to Comparator interface and we get a failure due to
conflicting inheritance:

-abstract-report2.scala:9: error: trait Bippy inherits conflicting members:
-  method reversed in trait TraversableOnce of type => List[(T2, String)]  and
-  method reversed in trait Comparator of type ()java.util.Comparator[T3]
-(Note: this can be resolved by declaring an override in trait Bippy.)
-trait Bippy[T1, T2, T3] extends Collection[T1] with TraversableOnce[(T2, String)] with Ordering[T3]
-      ^
Add cross suffix customizability for modules

For each module whose version can be specified using
the property "xxx.version.number", it is now possible
to specify its cross version suffix by using an
optional property "xxx.cross.suffix".

If such a property is not defined, then continue to
use the string "_${scala.binary.version}", as before.
fix to partest.cross
Expose seq field for variable arity definitions

In 2.11 we've changed TupleClass, ProductClass and FunctionClass
endpoints to be exposed as (Int => Symbol) functions that never throw
exceptions but rather return NoSymbol instead of previous error-prone
indexed access on array that could explode.

While simplifying one use case (indexed access) it complicated
ability to check if symbol at hand is in fact a tuple, product or
function:

  (1 to 22).map(TupleClass).toList.contains(symbol)

To cover this extra use case we add a seq method to the variable arity
class definitions that exposes a corresponding sequence of class symbols:

  TupleClass.seq.contains(symbol)
Merge pull request #3398 from densh/topic/var-arity-class-seq

Expose seq field for variable arity definitions
an optimization for c.eval

People are very frequently using c.eval in order to obtain underlying
values of literals. Spinning up a new compiler for that modest purpose
is a gross waste of fossil fuels.
Merge pull request #3399 from xeno-by/topic/eval

an optimization for c.eval
SI-6879 improves Context.freshName

Instead of per-compilation unit unique counters, the freshName API now
uses a per-Global counter. Fresh names now also contain dollars to exclude
clashes with supported user-defined names (the ones without dollar signs).

This doesn’t fix the bug, because per-Global counters get created anew
every time a new Global is instantiated, and that provides some potential
for name clashes even for def macros, but at least it completely excludes
clashes in typical situations.
addresses pull request feedback