SI-6989 privateWithin is now populated in reflect

Runtime reflection in JavaMirrors previously forgot to fill in
privateWithin when importing Java reflection artifacts. Now this is fixed.
[nomaster] doesn't touch NonemptyAttachments

NonemptyAttachments in macro API used to be Attachments$NonemptyAttachments.
However it's private, so noone outside scala.reflect.macros can access it,
making it ineligible for the incompatibility criterion.
[nomaster] removes Tree.canHaveAttrs

This forward compatibility fix is very easy. Have a new method in 2.10.1?
Don't expose it in the public API, and you won't have any problems.
[nomaster] revives BuildUtils.emptyValDef

That method was unnecessary in the first place, because we already had
emptyValDef in scala.reflect.api.Trees: https://github.com/scala/scala/blob/v2.10.0/src/reflect/scala/reflect/api/Trees.scala#L2367.
That's a rudiment from the times when we were unsure what to put into
scala.reflect.base and what goes into scala.reflect.api.

Unfortunately, it's not just a harmless extraneous method. Reifier v2.10.0
emits `u.build.emptyValDef` when it needs to reify `emptyValDef`. Therefore
we need to restore it to be forward compatible.

However we don't need to rollback the changes to the reifier v2.10.1,
which now simply calls `u.emptyValDef`, because, as mentioned above,
that `emptyValDef` was already there in v2.10.0.
[nomaster] Revert "s/SuperCallArgs/SuperArgs/"

This reverts commit 2621918870e531b7a9bcccdf14bddea9b89804b2.
[nomaster] Revert "more ListOfNil => Nil"

This reverts commit bb9adfbd76af0a0281912fcef4bcaca409a7c9a3.
[nomaster] Revert "DummyTree => CannotHaveAttrs"

This reverts commit 838cbe623c142b7005446793948097f679219fe3.

Conflicts:
	src/reflect/scala/reflect/api/Trees.scala
SI-6888 Loosen criteria for $outer search.

In order to cater for nested classes with names that end
with '$', which lead to ambiguity when unmangling expanded
names.

In:

    class X { object $ }

We end up with:

    orginalName(X$$$$$outer) = $$$outer

This change modifies `outerSource` to consider that to be
and outer accessor name. It is a piecemeal fix, and no doubt
there are other nasty surprises in store for those inclined to
flash their $$$ in identifier names, but the method changed is
not used widely and this solves the reported problem.

SI-2806 remains open to address the deeper problem.
[nomaster] Revert "introduces global.pendingSuperCall"

This reverts commit 0ebf72b9498108e67c2133c6522c436af50a18e8.

Conflicts:
	src/compiler/scala/tools/nsc/typechecker/Typers.scala
	src/reflect/scala/reflect/internal/Trees.scala
[nomaster] Revert "refactors handling of parent types"

This reverts commit 40063b0009d55ed527bf1625d99a168a8faa4124.

Conflicts:
	src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
	src/compiler/scala/tools/nsc/typechecker/Typers.scala
[nomaster] verifies compat with 2.10.0

Makes sure that the compiler understands the 2.10.0 format of super
constructor calls after the recent revert from the typemacro-compatible
format.
introduces an exhaustive java-to-scala test

Originally composed to accommodate pull request feedback, this test has
uncovered a handful of bugs in FromJavaClassCompleter, namely:
* SI-7071 non-public ctors get lost
* SI-7072 inner classes are read incorrectly

I'm leaving the incorrect results of FromJavaClassCompleters in the check
file, so that we get notified when something changes there.
Add a request to presentation compiler to fetch doc comment information.
Refactor scaladoc base functionality to allow it to be mixed in with Global in the IDE.
SI-7070 Turn restriction on companions in pkg objs into warning

The implementation restriction created from SI-5954 in
3ef487ecb6733bfe3c13d89780ebcfc81f9a5ea0 has two problems.

1) The problematic code works fine if compile with sbt. That means the
restriction is breaking some people needlessly.

2) It's not binary compatible.

To fix all that this commit changes the error into a warning and removes
the setting used to get around the restriction.
SI-7026: parseTree should never return a typed one

This commit fixes ticket SI-7026. This makes it safe to use
parseTree outside of the presentation compiler thread.

Solved it with an implementation that just parses the source every
time without trying to memorize anything. Added tests that checks
that

1. You get a new parse tree every time you ask for one.
2. You always get a parse tree, never a typed tree.
3. A parse tree should never contain any symbols or types [1].
4. If you ask for a parse tree and then ask for a typed tree it
   shouldn't change the parse tree you originally asked for, i.e.
   property 3 still holds.

Additionally the parser is now only interruptible when running
on the presentation compiler thread.

[1] There is an exception to this though. Some of the nodes that
the compiler generates will actually contain symbols. I've
chosen to just ignore these special cases for now.
SI-5824 Fix crashes in reify with _*

Reification crashes if "foo: _*" construct is used. This happens besause type tree is represented either with TypeTree, or with Ident (present case), and `toPreTyperTypedOrAnnotated' only matches of the former. The fix is to cover the latter too. A test is included.
SI-6113 typeOf now works for type lambdas

It's not a problem to have an abstract type symbol in a ground type tag
if that symbol is defined in the type being reified.

This mechanics was already built in for existentials, now we extend it to
include type params of poly types.

Credit goes to @katefree
SI-5082 Cycle avoidance between case companions

We can synthesize the case companion unapply without forcing
the info of the case class, by looking at the parameters in
the `ClassDef` tree, rather than at `sym.caseFieldAccessors`.

Access to non-public case class fields routed through the
already-renamed case accessor methods. The renamings are
conveyed via a back-channel (a per-run map, `renamedCaseAccessors`),
rather than via the types to give us enough slack to avoid
the cycle.

Some special treatment of private[this] parameters is needed
to avoid a misleading error message. Fortunately, we can
determine this without forcing the info of the case class,
by inspecting the parameter accessor trees.

This change may allow us to resurrect the case class ProductN
parentage, which was trialled but abandoned in the lead up
to 2.10.0.
SI-6146 More accurate prefixes for sealed subtypes.

When analysing exhaustivity/reachability of type tests
and equality tests, the pattern matcher must construct
a set of sealed subtypes based on the prefix of the
static type of and the set of sealed descendent symbols
of that type.

Previously, it was using `memberType` for this purpose.
In simple cases, this is sufficient:

    scala> class C { class I1; object O { class I2 } }; object D extends C
    defined class C
    defined module D

    scala> typeOf[D.type] memberType typeOf[C#I1].typeSymbol
    res0: u.Type = D.I1

But, as reported in this bug, it fails when there is an
additional level of nesting:

    scala> typeOf[D.type] memberType typeOf[c.O.I2 forSome { val c: C }].typeSymbol
    res5: u.Type = C.O.I2

This commit introduces `nestedMemberType`, which uses `memberType`
recursively up the prefix chain prefix chain.

    scala> nestedMemberType(typeOf[c.O.I2 forSome { val c: C }].typeSymbol, typeOf[D.type], typeOf[C].typeSymbol)
    res6: u.Type = D.O.Id
Merge pull request #2068 from scalamacros/ticket/7064

[nomaster] SI-7064 Reflection: forward compat for 2.10.1