Added a Swing PopupMenu wrapper
Added a Swing ColorChooser wrapper
SI-6422: add missing Fractional and Integral alias in scala package
fixes a bug in a weak cache in runtime reflection

Entries in SynchronizedTypes.uniques could previously be garbage collected
in-between a successful call to contains and an actual cache lookup.

The patch could be a one-liner, but I don't want to use HOFs
in this function, whose prototype is a hotspot in the compiler.

Also the fix doesn't touch scalac in any way. It only applies to
reflective universes that provide runtime reflection functionality.
SI-6215 Fix compiler crash on private method in value class

Fixes the problem with private defs in value classes by moving the $extension after the name proper rather than before. The previous scheme did not commute with makeNonPrivate:

I.e. if -ext-> is "generate extension name" and -mnp-> is "make not private" we did get for
method foo in value class Foo:

  foo -ext-> extension$foo -mnp-> Foo$$extension$foo

but

  foo -mnp-> Foo$$foo -ext-> extension$Foo$$foo

With the change both variations give the same name:

  foo -ext-> foo$extension -mnp-> Foo$$foo$extension

but

  foo -mnp-> Foo$$foo -ext-> Foo$$foo$extension
Removed obsolete migration test.

Arrays are not Seqs: a fact known by all and sundry.
Defanged dummy type arguments.

Spending a few hours on yet another tpe vs. tpeHK bug drove me
to finally go after the dragon in his cave. I created a separate
method for when you want to receive an invalid type which will
cause mysterious crashes later if it is out of your sight for five
seconds.

  def tpeHK : Type // unapplied type params stay unapplied
  def tpe_* : Type // unapplied type params applied as dummy args
  def tpe   : Type // if there are unapplied type params, ABORT

Actually it doesn't really abort, but I had it print a stack trace
during development so I could track down every site which blindly
calls tpe and see why they were doing it. Now it only admonishes
you under -Ydebug.

This way is a big step forward: you have to make a choice, which
is good, because if you choose not to decide you still have made a
choice, only mostly what you have chosen is bugs.
Cleanup in old Typers code.

Using established facilities for doing established things.
Hardening in appliedType and Subst*Map.

All driven by the knowledge gained from logging all the
calls to tpe and appliedType and seeing what was coming
through there.  Some needless type creation is avoided in
the maps, and appliedType will squawk to those who listen
when it sees something out of order.
All the actual changes of tpe to tpe_* or tpeHK.

These are the call sites which formerly could be seen to
call .tpe on a symbol with unapplied type parameters.  Now
each such call site makes an explicit choice about what is
intended for the result type.
Overhauled documentation and structure of tpe/tpeHK/etc.

Trying to make the code structure as hotspot friendly as
I can, which is no mean feat.
Merge pull request #1439 from scalamacros/topic/reflective-uniques

fixes a bug in a weak cache in runtime reflection
SI-6436 Handle ambiguous string processors

Before, we got in an inifinite loop by chasing
the error typed result of adaptToMemberWithArgs.

One point of befuddlement remains: why did t6436 and t6436b
behave differently before this change?
Revised restrictions for value classes and unversal traits

and brought compiler in line with them. One thing we can accept IMO are nested
classes (nested objects are still a problem). In fact, it makes no sense to
exclude nested classes from value classes but not from universal traits. A class
nested in universal trait will becomes a class nested in a value class by
inheritance. Note that the reflection library already contains a universal trait
with a nested class (IndexedSeqLike), so we should accept them if we can.
Fixed problem in SI-6408

Fixed problem reported in comment, where inner classes of value classe caused a compiler crash.
Put more implementation restrictions on value classes.

Nested objects, classes and lazy vals are disallowed at any
nesting level in value classes; e.g. lazy vals local to a
method defined in a value class. There are still allowed in
universal traits.

This is a temporary, implementation restriction that is planned
to be addressed in future releases of Scala. Error messages has
been updated to communicate that intent.

Moved tests for SI-5582 and SI-6408 to pending folder. They have
to stay there until implementation restrictions are addressed.

Closes SI-6408 and SI-6432.

Review by @odersky, @harrah and @adriaanm.
SI-6451: Rename classes in `unchecked-abstract.scala` test.

As reported Miguel, `Con` is problematic name of a class on Windows
and makes this test to fail. Renamed classes to something else which
hopefully make Windows build happy again.

Closes SI-6451.

Review by @magarciaEPFL or @paulp.
Merge pull request #1446 from retronym/ticket/6436-2

SI-6436 Handle ambiguous string processors
Merge pull request #1443 from gkossakowski/anyval-restrictions

AnyVal/value classes restrictions
undeprecates manifests for 2.10.0

Since scala-reflect.jar is going to be declared experimental for 2.10.0,
it doesn't make sense to deprecate manifests in favor of type tags.

Class manifests, however, ARE deprecated for class tags, because class tags
don't require scala-reflect.jar and are generated independently of type tags.