add -Xsource:version to scalac man page

The flag was added in d43618a (PR #3340) by @huitseeker.
SI-8202 bug compatibility with SI-8211 for quasiquotes
Move placeholder construction logic into Placeholders

Previously construction logic used to be in Parsers and deconstruction in
Placeholders making it easy to forget one if you change the other.
Move null check case higher to avoid NPE

Also use sym.isErrorneous instead of manual name check.
Improve support for patterns in vals

This commits adds construction-only support for splicing patterns into
vals (a.k.a. PatDef). Due to non-locality of the desugaring it would
have been quite expensive to support deconstruction as the only way to
do it with current trees is to perform implodePatDefs transformation on
every single tree.
SI-3452 Correct Java generic signatures for mixins, static forwarders

[Parts of this patch and some of the commentary are from @paulp]

This took me so long to figure out I can't even tell you. Partly because
there were two different bugs, one which only arose for trait forwarders
and one for mirror class forwarders, and every time I'd make one set
of tests work another set would start failing. The runtime failures
associated with these bugs were fairly well hidden because you usually
have to go through java to encounter them: scala doesn't pay that much
attention to generic signatures, so they can be wrong and scala might still
generate correct code. But java is not so lucky.

Bug #1)

During mixin composition, classes which extend traits receive forwarders
to the implementations. An attempt was made to give these the correct
info (in method "cloneBeforeErasure") but it was prone to giving
the wrong answer, because: the key attribute which the forwarder
must capture is what the underlying method will erase to *where the
implementation is*, not how it appears to the class which contains it.
That means the signature of the forwarder must be no more precise than
the signature of the inherited implementation unless additional measures
will be taken.

This subtle difference will put on an unsubtle show for you in test
run/t3452.scala.

    trait C[T]
    trait Search[M] { def search(input: M): C[Int] = null }
    object StringSearch extends Search[String] { }
    StringSearch.search("test");  // java
    // java.lang.NoSuchMethodError: StringSearch.search(Ljava/lang/String;)LC;

The principled thing to do here would be to create a pair of
methods in the host class: a mixin forwarder with the erased
signature `(String)C[Int]`, and a bridge method with the same
erased signature as the trait interface facet.

But, this turns out to be pretty hard to retrofit onto the
current setup of Mixin and Erasure, mostly due to the fact
that mixin happens after erasure which has already taken
care of bridging.

For a future, release, we should try to move all bridging
after mixin, and pursue this approach. But for now, what can
we do about `LinkageError`s for Java clients?

This commit simply checks if the pre-erasure method signature
that we generate for the trait forward erases identically to
that of the interface method. If so, we can be precise. If not,
we emit the erased signature as the generic signature.

Bug #2) The same principle is at work, at a different location.
During genjvm, objects without declared companion classes
are given static forwarders in the corresponding class, e.g.

    object Foo { def bar = 5 }

which creates these classes (taking minor liberties):

    class Foo$ { static val MODULE$ = new Foo$ ; def bar = 5 }
    class Foo  { static def bar = Foo$.MODULE$.bar }

In generating these, genjvm circumvented the usual process whereby one
creates a symbol and gives it an info, preferring to target the bytecode
directly. However generic signatures are calculated from symbol info
(in this case reusing the info from the module class.) Lacking even the
attempt which was being made in mixin to "clone before erasure", we
would have runtime failures of this kind:

    abstract class Foo {
      type T
      def f(x: T): List[T] = List()
    }
    object Bar extends Foo { type T = String }
    Bar.f("");    // java
    // java.lang.NoSuchMethodError: Bar.f(Ljava/lang/String;)Lscala/collection/immutable/List;

Before/after this commit:

    <   signature                                     f  (Ljava/lang/String;)Lscala/collection/immutable/List<Ljava/lang/String;>;
    ---
    >   signature                                     f  (Ljava/lang/Object;)Lscala/collection/immutable/List<Ljava/lang/Object;>;

This takes the warning count for compiling collections under
`-Ycheck:jvm` from 1521 to 26.
SI-7374 Test cases for fixed Java interop problem

Our generic signatures now match the erasure, so no
more nasty linkage errors.
SI-8266 Deprecate octal escapes in f-interpolator

Also turns the f-interpolator into a migration
assistant by suggesting alternatives for the
standard escapes.
typecheck(q"class C") no longer crashes

MemberDefs alone can't be typechecked as is, because namer only names
contents of PackageDefs, Templates and Blocks. And, if not named, a tree
can't be typed.

This commit solves this problem by wrapping typecheckees in a trivial block
and then unwrapping the result when it returns back from the typechecker.
SI-6908 FlatHashTable and things that depend on it can't store nulls

Fixed ParFlatHashTable to use entryToElem which correctly converts sentinels to nulls.
SI-7711 Do not emit extra argv in script body

Take away `argv` and make `args` the standard parameter name.

This is a quick fix to avoid "unused local" lint error.  All
the examples use `args`; in particular, "Step 4. Write some
Scala scripts" in "Programming in Scala" uses `args`.

I see the footnote there is also where Odersky concatenation is
specified, `"Hello, "+ args(0) +"!"` with no space next to the
literals.

Also removes `argv` from `StdNames`. Was torn whether just to
add `argc`. Maybe start a new project to house Names, emeritus.
SI-7711 Test for args in script

Compiles with -Xlint to ensure there are no lurkers.

Updates `ScriptTest` to pass args to the script.

It's called `argv` partly as homage, partly because
`args` is an `Array`.
Add an extremely well-commented test

This commit includes a test for some simple existential subtyping
checks. It is exceptionally well-commented and may be helpful to
someone trying to figure out what the rules are (supposed to be)
in the future.
SI-8264 scala.collection.immutable.HashSet#- returns broken Set

Was an error in HashSet's handling of removal of an element when a HashTrieSet should turn into a HashSet1.

Also slightly modified HashMap's filter0 to more closely match HashSet (by adding the same comment).
Made ParFlatHashTableIterator private vars private[this].
SI-3452 A better fix for static forwarder generic sigs

The previous commit fixed this in the wrong way. The addition
to the test case (testing an inherited method from a base class
in addition to the test with a mxin method) still failed.

Like mixin, static forwarder generation uses the exact erased
siganture of the forwardee for the forwarder. It really ought
to use the as-seen-from signature (adding requisite boxing/
unboxing), but until we do that we have to avoid emitting
generic signatures that are incoherent.
SI-3452 Refactoring code in GenASM

For a non copypasta for of reuse in GenBCode.
SI-3452 Reduce low-hanging duplication bewteen GenASM and GenBCode
SI-3452 GenBCode version of the static-forwarder signature fix

Shares the code with the GenASM version of the fix.
Merge pull request #3534 from clhodapp/test/literate_existentials

Add an extremely well-commented test