Fix raw string interpolator: string parts which were after the first argument were still escaped
Improve efficiency of updated

Added utility method to create a HashTrieSet with two leaf HashSets with different hash
Used said utility method instead of creating a temorary HashTrieSet with an empty elems array
Added assertions to HashTrieSet to validate tree
Added test that should cover all code paths of the changes done in SI-6220

This test will pass even with an older version of the scala library, since as mentioned this is just a performance improvement.
JavaConversions: Restore source compatibility with 2.9

Readd an implicit conversion which was available in 2.9, the one from
`java.util.concurrent.ConcurrentMap` (`juc.ConcurrentMap`) to the (now
deprecated) type `scala.collection.mutable.ConcurrentMap`.

This implicit conversion can also be used to convert from
`juc.ConcurrentMap`
to `collection.Map` and creates an ambiguity error in
test/files/run/map_java_conversions.scala. To fix this, I have given
lower priority to the new conversion.

Moreover, update the documentation in `JavaConversions`: mark this
conversion as deprecated and mention the new conversion which replaces
it, converting to `scala.collection.concurrent.Map`.

I discussed this issue previously with Paul Phillips on scala-language:

https://groups.google.com/d/topic/scala-language/uXKRiGXb-44/discussion
Make Stream.withFilter.{map,flatMap} run in constant stack space

The included test currently fails because `map` and `flatMap` do not
run in constant stack space on a stream returned by `Stream.withFilter`,
as I reported here:
https://groups.google.com/d/msg/scala-language/WqJR38REXnk/saaSiDdmyqoJ

Fix the problem and add a simple testcase.

Note that the stack space consumed when producing an element of this stream is
proportional to the number of elements failing the test before the next
success. The stack space consumed to produce the stream itself is the
space needed to produce the first element, that is, is proportional to
the number of failures before the first success.
Remove commented out code
Prevent creation of a HashMapCollision1 with one element
Prevent creation of a HashTrieMap with one child unless the child is a HashTrieMap itself
Remove unnecessary check for merger eq null

While we still have to check for merger eq null in updated0 because updated0 gets called with a nu
Cleanup testcase

No need to check the output - checking programmatically that the
produced streams are empty is enough.
Move code to create two-element HashTrieMap into utility method and make use of it from HashMapCollision1.updated0 as well
Check if subNew is the only child and if it is a leaf.

If this is the case we must return subNew because a HashTrieMap with one leaf element is not allowed by the assertions
Rewrote makeHashTrieMap so that objects are created in a consistent state

The old approach first created a broken HashTrieSet (with elems(0) == null) and then fixed it afterwards by assigning elems(0) from the outside. But that won't work with the assertion.

The new method is recursive, but the maximum recursion depth is 7, and on average the method won't recurse at all.
Added assertions for tree consistency
Added test that tests that correct classes are being created when removing elements
Extended test to also check proper handling of collisions
Fix for SI-6264, crash in checkCheckable.

The classic fail of assuming you will only receive a
specific subclass of Type.
fixes non-determinism in reflection-sorted-decls

ordering of synthetic members on java7 with a lot of cores is non-deterministic
that's not a problem, because the doc doesn't promise anything about synthetics
hence I've adjusted the test, so that it no longer includes accessors

discussion: http://groups.google.com/group/scala-internals/msg/087a7d4805313561
Merge pull request #1174 from paulp/issue/6264

Fix for SI-6264, crash in checkCheckable.
Merge pull request #1176 from scalamacros/topic/nondeterministic

fixes non-determinism in reflection-sorted-decls