no longer docs scala.reflect.io

The only place we use something from scala.reflect.io in the public API
is Symbol.associatedFile, so I've excluded scala.reflect.io from scaladoc
and added a "warning: experimental" comment to associatedFile instead.

I'd argue that this greatly simplifies the surface of reflection API
(typing scala.reflect in the search bar now yields 3 packages instead of 4).
docs.pre-lib now checks for mods in reflect
MirrorOf => Mirror

The name looks weird in the scaladoc overview panel,
so I decided to do a last-minute rename.
hides BuildUtils from Scaladoc

This is an internal implementation class, only necessary for reification
(exposes some really internal stuff required to recreate the trees,
the stuff for which the public API is insufficient or too verbose).

Therefore we don't need it in Scaladoc.
PositionApi => Position

Continues the series of Scaladoc-driven optimizations to scala-reflect.jar.
removes front ends from scala-reflect.jar

It was an interesting idea to give macro developers control over front ends,
but it hasn't given any visible results.

To the contrast, front ends have proven useful for toolboxes to easily control
what errors get printed where.

Therefore I'm moving front ends to scala-compiler.jar to clean up the API.
Yay for scaladoc-driven development!
merges macros.Exprs and macros.TypeTags into Context

The former is a one-method trait, the latter is a two-method trait.
In a scaladoc these guys don't look like the pull their weight.
merges macros.CapturedVariables into macros.Universe

Back then we didn't have a notion of a macro-specific universe,
so I had to expose these methods in Context.

Now we have our very own macros.Universe, so capturing methods
have landed there.
removes extraneous stuff from macros.Infrastructure

libraryClassLoader can be derived from currentClassPath

currentMacro can be trivially derived from macroApplication

Backend-detection methods forXXX (as in forJVM or forScaladoc)
might be useful, but current design of this API is not future-proof.
I'm not able to come up with a better design on the spot, so
let's remove this functionality for the moment.
exposes Position.source as SourceFile

It was useful to pretend that SourceFile isn't a part of the API,
when it's physical location was in scala-compiler.jar.

Afterwards Position and SourceFile have been moved to scala-reflect.jar,
and (what's more important) scala-reflect.jar gained experimental status,
meaning that we're not bound by backward compatibility in 2.10.0.

Therefore I'd say we should expose a full-fledged SourceFile in Position.source
(just as we do for Symbol.associatedFile) and later find out how to strip down
its interface to something suitable for public consumption.
simplifies Context.Run and Context.CompilationUnit

By turning them from abstract types into full-fledged traits
implemented by our internal Run and CompilationUnit.
gets rid of macros.Infrastructure

currentRun goes to Enclosures and becomes enclosingRun

currentClassPath gets integrated into Run
a more precise type for Context.mirror

scala.reflect.api.Mirror is the most basic contract for mirrors.

Currently scala.reflect.api.Universe.Mirror is simply an abstract type
type Mirror >: Null <: scala.reflect.api.Mirror[self.type], and
scala.reflect.macros.Universe doesn't override that type, so from the user
standpoint at the moment scala.reflect.api.Mirror == c.mirror, however,
in the future this might be a source of errors.
moves Context.runtimeUniverse to TreeBuild.mkRuntimeUniverseRef

Scaladoc-driven cleanup for the win
revives macros.Infrastructure

Takes macros.Settings, throws away its mutable parts, moves classPath from Run
back to the top level - and unites all that in the Infrastructure trait.
moves Context.ParseError outside the cake

I did this for ReificationError a long time ago. Must've probably forgot
to do the same for ParseError.
Finish docs for string interpolation.
Merge pull request #1409 from jsuereth/fix/string-interpolation-doc

Finish docs for string interpolation.
Nailed down the "impossible match" logic.

I will again defer to a comment.

/** Given classes A and B, can it be shown that nothing which is
 *  an A will ever be a subclass of something which is a B? This
 *  entails not only showing that !(A isSubClass B) but that the
 *  same is true of all their subclasses.  Restated for symmetry:
 *  the same value cannot be a member of both A and B.
 *
 *   1) A must not be a subclass of B, nor B of A (the trivial check)
 *   2) One of A or B must be completely knowable (see isKnowable)
 *   3) Assuming A is knowable, the proposition is true if
 *      !(A' isSubClass B) for all A', where A' is a subclass of A.
 *
 *  Due to symmetry, the last condition applies as well in reverse.
 */
Moved two tests to less breaky locations.

When there is a test called pos/t1107.scala and also a test
called pos/t1107, it is bad.