TypeTree printing modified (SI-8447)
SI-8185 Correct grammar for single-warning compilation run
SI-8609 Fix flattening of definitions and imports in quasiquotes

Quasiquotes allow to unquote trees with ..$ with block flattening
semantics to simplify composition:

  val onetwo = q"1; 2"
  val onetwothree = q"..$onetwo; 3" // same as q"1; 2; 3"

If there is no block it will be equivalent to $ unquoting:

  val one = q"1"
  val onetwo = q"..$one; 2" // same as q"1; 2"

But the inconsistency here is that currently only terms support
this single-element semantics. This commit extends this functionality
to also support definitions and imports. So that following code works:

  val q1 = q"val x = 1"
  val q2 = q"..$q1; val y = 2" // same as q"val x = 1; val y = 2"
SI-5905 Clarify test case

The language feature options are discovered reflectively, but it
is nice to enforce that expected options are supplied.

Short of that, the code string includes a rowdy postfix operator.

It still does enforce that at least one option was discovered.
adds MacroPlugin.pluginsIsBlackbox

This is an important omission in the current macro plugin API, which was
designed before the blackbox vs whitebox separation was implemented.

Even if one overrides pluginsTypedMacroBody and pluginsMacroExpand,
that would still be not enough to write a custom macro expander, because
typedImplicit1 uses isBlackbox, which is tightly coupled with the standard
way of reading/writing macro signatures.
macro args now correctly preserve range positions

Somewhen in the 2.11.0 development cycle we started duplicating macro arguments
for increased robustness. What wasn't taken into account though is that
Tree.duplicate destroys range positions. This commit fixes the problem.

2.10.x is unaffected by this bug, because it doesn't duplicate the args yet.
SI-8494 Restore filtering javap output

Regressed in support for new delayedEndPoint, where it must
pick what to filter for.

`s/claas/klass/` and similar.
SI-8494 Javap filter includes specialized

When filtering javap output, include specialized versions
of methods. For anonfuns, in particular, the apply$sp is
the method of interest.
SI-6409  Stream flatMap leaks memory if mapper returns many empties

Added Scaladoc explaining that this is necessary behavior, but closed ticket as wontfix.
SI-7372 fix wrong insertion point for binary & linear search.

It should return the position the value would have if it was a part of
the sequence. Somehow even the test was wrong.
SI-8631 Treat `A with Sealed` as enumerable for pattern matching

Enumerate the subtypes of sealed parent types of refinement
types, and filter those that conform to the refinement type.

Such types can crop up easily when LUB-bing case classes which
add `Product with Serializable` to the mix.
Merge pull request #3777 from som-snytt/issue/5905-test

SI-5905 Clarify test case
Refactor `enumerateSubtypes`

  - reorder to make "unenumerable" the last case
  - reunite an orphaned comment with its loved ones.
SI-8611 Avoid accidental patmat unification with refinement types

In the enclosed test, t8611a.scala, the patterns `O.{A, B}` were
incorrect treated as equivelent by the combination of
`uniqueTpForTree` and `Const.uniqueTpForTree`.

`uniqueTpForTree` used `Type#narrow` to try to create a distinct
type for each new pattern tree it encountered. However, narrowing a
`RefinedType` does not create a distinct type as we are used to
when narrowing, e.g. a class type.

    // Type
    def narrow: Type =
      if (phase.erasedTypes) this
      else {
        val cowner = commonOwner(this)
        refinedType(this :: Nil, cowner, EmptyScope, cowner.pos).narrow
      }

    // CompoundType
    override def narrow: Type = typeSymbol.thisType

This commit creates a fresh existential type symbol rather than
trying to use `narrow`.

I've included a unit test to show the sublteties of narrowing
refinment types.
Remove now-redundant condition in sealedness checking

It arrived in c1f8dbc, but is no longer needed after user-defined
value classes were introduced in 2.10.0.
SI-6967 Fix ClassTag unapply for primitives

This commit fixes the behavior of ClassTag's Any-accepting unapply
overload. Previously, ClassTag had overloads of unapply that accepted
all of the Java primitive aliases (language-supported magic classes
extending AnyVal), as well as an implementation that accepted an Any.
All of the AnyVal-accepting (more specific) versions of the methods
worked correctly. However, the Any-accepting version incorrectly handled
these types. For example, ClassTag.Int.unapply(3) would return Some(3)
(through the Int-accepting overload), while ClassTag.Int.unapply(3: Any)
would return None (through the Any-accepting overload). This commit
unifies these behaviors, making ClassTag.Int.unapply(3: Any) return
Some(3). It accomplishes this by adding a pattern match on the type of
that method's argument, which will delegate to one of the
more-specifically-typed overloads if possible. It also improves the
formatting of the code a bit.

One thing to note (though I doubt anyone will ever do this based on this
message) is that the AnyVal-subtype-accepting overloads should be
removed in Scala 2.12, as they are unneeded. I placed a  note to this
effect into the code.
Merge pull request #3781 from retronym/topic/8611

SI-8611 Avoid accidental patmat unification with refinement types
Merge pull request #3797 from retronym/topic/exhaust-compound

SI-8631 Treat `A with Sealed` as enumerable for pattern matching
SI-7372 make binarySearch methods use the same parameters for the same things.

The public facing binarySearch method used an inclusive 'from'
parameter, while the internal @tailrec one used an *exclusive*
'from' parameter. No wonder there was an off-by-one error somewhere.

This makes both methods use the same exclusive 'from' parameter.
Update PartialFunction documentation to include the fact that the caller is responsible for checking 'isDefinedAt'