Rank based take/drop/slice.

Tree navigation based on node rank is faster than using compare
method. rank is simply count(tree.left) + 1.
Fixes SI-6337 by disallowing nested value classes.

It seems for the moment too hard to allow this, and the functionality to have value classes wrap other value classes does not seem essential.
Fixed comment.
Removed many @inline annotations and final modifiers.

It is my belief that these @inlines and finals landed between
unhelpful and harmful. I am sure this will be disputed in some
cases. It's too much and too difficult to measure except in the
aggregate unless we have specific @inline sites to discuss.
I don't know upon whom the burden of proof lies.  I think we
should err on the side given here, since there is no evidence
of any consistent rationale being applied and it is easy to
verify the negative impact scala compiler inlining can have on
hotspot's far more sophisticated inlining.
enable integer multiplication/divison on FiniteDuration, see SI-6389

- without this "2.seconds * 2" will not return FiniteDuration but
  Duration
- added test case verifying this behavior
- matches normal arithmetics: integers throw on div-by-zero while
  doubles yield infinity; extended here to include overflow protection
  on integer multiplication
existentially typed expansions now work fine

If one tries to compile the following code with the parent of this commit:

  ru.reify(new Object().getClass)

then the following error will occur:

  Test.scala:2: error: type mismatch;
    found   : $u.Expr[Class[_ <: Object]]
    required: reflect.runtime.universe.Expr[Class[?0(in value <local Test>)]]
              where type ?0(in value <local Test>) <: Object
    ru.reify(new Object().getClass)
            ^

This happens because macro expansions are always typechecked against the
return type of their macro definitions instantiated in the context of expandee.

In this case the expected type contains skolems which are incompatible
with wildcards in the type of the expansion.

I tried all the incantations I could think of - without any success.
Luckily I met Martin who pointed me at the same problem solved in adapt
(see the diff w.r.t Typers.scala).
test case closes SI-5418

Now, when the existential reification bug is fixed, I've been able
to take a look at SI-5418, and, apparently, the problem with importers
has fixed itself during these 9 months of the bug being active.
SI-6336 Now also catches return types

As Mark's comments on SI-6336 shows, we also need to disallow value classes
as return types of structural types.
Retain Ordering in drop/take/slice signatures.

Addresses code review feedback by @axel22.
Add RedBlackTree tests for take/drop/slice.

Addresses review feedback by axel22.
Fixes SI-6305 scala.tools.nsc.io split between jars.

* migrates scala.tools.nsc.io portions into scala.reflect.io
* marks all classes in scala.reflect.io experimental/internal
* rewires src/reflect to use new io locations
* creates forwarders in scala.tools.nsci.io package object.
Adds OSGi support / tests to Scala.  Fixes SI-5822.

* Adds BND manifest generation to the build.
* Adds OSGi pax-exam testing infrastructure
* Adds simple OSGi verification test for bundle resolution.
* Modifies distribution to use bundles.
Adds very simplistic reflection in OSGi test.   Provides the framework
to discover important reflection bugs in OSGi containers.
improve performance of integer multiplication overflow check on Duration

- also rename divisor arguments to “divisor”
- and add a scalacheck for multiplication overflow detection
SI-6390 removes Trees#ArrayValue from the API

Introduced by uncurry - therefore it can be seen
neither by macros, nor by runtime reflection.

Despite never being pickled, ArrayValue is supported by unpickler
so I couldn't move it exclusively to scala-compiler.jar.

Figuring out the mysterious reason for pickling ArrayValue is left
to future work.
Additional OSGi tests.

* Ensure scala-library can be resolved on its own, and with sun.misc.Unsafe usage.
* Ensure reflection works without scala-compiler.jar
* Ensure ToolBox's can see all classes necessary when evaluating expressions.
* Cleanup test helper for filtering in/out bundles.
move Duration (incl. DSL) into scala.concurrent.duration package

so that the full package can be imported naturally:

import scala.concurrent.duration._

will give you all the types (Duration, FiniteDuration, Deadline) and the
DSL for constructing these.
Fix problem with names encoding in scalap.

The refactoring performed in 020053c321 made use of naming encoding
more consisted but introduced a regression in scalap. The problem
is that the old encoder that scalap had didn't escape any characters
that were not included in its opcode list.

`NameTransformer` performs full encoding so it also encodes dots
that are being used as separators for packages. Therefore, in order
to retain the old behaviour we need to split the name by dots before
feeding each fragment to `NameTransformer`.

Review by @paulp.
fixes NameTypes in base names

NameType is introduced in base.StandardNames#NamesBase to abstract away the
difference between term names and type names in order to encode common names
such as EMPTY or WILDCARD.

Flavor-specific name repositories, such as TermNames and TypeNames are supposed
to override NameType fixing it to correspondingly TermName or TypeName.

Unfortunately I completely overlooked this and as a result some standard names
were typed with insufficient precision, e.g. This(tpnme.EMPTY) didn't work.
prepping for the refactoring

Reification (both tree-based and type-based) should be avoided
before we release 2.10.0-final, since it impairs reflection refactorings
like the upcoming one.

Also the upcoming refactoring moves tag materialization anchors, and we
have to add them to fast track in advance, so that they are treated as
macros later.