.ensime template for compiler development

Provides a template of an .ensime file to be used for compiler hacking
together with an ENSIME-enabled text editor.

Also includes a readme that outlines what editors support ENSIME.
To the best of my knowledge these are Emacs, TextMate, jEdit and Sublime Text 2
Rewrite of transformTypeTagEvidenceParams.

This fixes what a bug where the prefix seems to be checked but
is ignored; however I rewrote this method purely out of a desire
for tighter code.  I would consider it a great personal
favor if you would study the before/after and endeavor to
internalize the mechanisms I applied.

Points of particular note:

 - Before you write Option[Symbol], remember we already have
   an Option[Symbol], and it's Symbol.  None == NoSymbol.
 - flatMap can be to an Option, you don't have to create a
   one element List for flatMap's enjoyment
 - lastOption and headOption are rarely the way to go
   ... especially if you start with if (xs.isEmpty) return
 - The method which checks for emptiness is ".isEmpty",
   it is NOT ".length == 0"

I should add a pattern matcher warning for when you have a lower
case name in scope (like "contextParam") and then use a lower case
pattern variable of the same name, which of course ignores the
one outside the pattern and matches everything.

Review by @xeno-by.
SI-5940 impls are no longer in macro def pickles

The first officially released version of macros persisted
macro def -> impl bindings across compilation runs using a neat trick.

The right-hand side of macro definition (which contains a reference to an impl)
was typechecked and then put verbatim into an annotation on macro definition.

This solution is very simple, but unfortunately it's also lacking. If we use it
then signatures of macro defs become transitively dependent on scala-reflect.jar
(because they refer to macro impls, and macro impls refer to
scala.reflect.macros.Context defined in scala-reflect.jar).
More details can be found in https://issues.scala-lang.org/browse/SI-5940.

Therefore we have to avoid putting macro impls into binding pickles and
come up with our own serialization format. Situation is further complicated
by the fact that it's not enough to just pickle impl's class and method names,
because macro expansion needs knowledge about the shape of impl's signature
(which we can't pickle). Hence we precompute necessary stuff (e.g. the layout
of type parameters) when compiling macro defs.
macro implementations must be public

The immediate motivator for this change was the desire to keep things simple
during macro expansion.

Here's the story. When you expand a macro, you need to reflectively load
a macro implementation method and invoke it. However private methods in Scala
can sometime have their names mangled, so the reflector has to check multiple
variants of the same name (the normal one and the mangled one).

The problem is that since the previous commit we don't have an access to a
symbol of the macro impl, hence we cannot just use `impl.expandedName` like
we did before. Sure I could duplicate the logic of expandedName, but I have
a better suggestion.

Let's prohibit non-public macro implementations. This doesn't seem to hurt,
and it lets us avoid extra bit of complexity in Macros.scala.

If this measure turns out to be a hassle during the trial period of macros,
non-public macros can always be allowed. In fact, we can even have this feature
back for free when we migrate from Java reflection to Scala reflection for
invoking macro implementations (because Scala reflection knows how to account
for mangled private names). But that's the 2.10.x business.
HIDDEN => ARTIFACT

This test is necessary in the API to tell apart useful synthetic symbols
(such as accessors) and low-level compilation artifacts (such as $outer).

However `isHidden` (as it's currently named in the compiler) is too generic.
Hence I renamed it along with the corresponding flag. Now the test says
`isArtifact` and the flag is named ARTIFACT.

Despite being an improvement over the first version, `isArtifact` is
still a bit unlucky. The name I like is `isImplementationArtifact`, but that's
a mouthful to be used in compiler hacking. Moreover, IMPLEMENTATION_ARTIFACT
looks weird.

For a discussion about related stuff see:
http://groups.google.com/group/scala-internals/browse_thread/thread/d04e762127737968
https://github.com/scala/scala/pull/1114
accommodated the feedback for the pull request

For the discussion see: https://github.com/scala/scala/pull/1101
don't crash on unsupported pattern -- diagnose
Merge pull request #1101 from scalamacros/ticket/5940

SI-5940 impls are no longer in macro def pickles
don't catch StackOverFlowError: kills performance

instead, use a recursion counter in negationNormalForm as in conjunctiveNormalForm
(except we only limit recursion depth, not formula-size
 reuse the same config variable in hopes it'll do for both)
Add Scaladoc flag to specify hidden implicit conversions
Merge pull request #1134 from adriaanm/patmat-misc

patmat tweaks: compiler performance, better error on unsupported pattern
Merge pull request #1136 from ingoem/scaladoc/implicits2.10

Add Scaladoc flag to specify hidden implicit conversions
Merge pull request #1137 from scalamacros/topic/ensime

.ensime template for compiler development
SI-6167 Override SeqLike#isEmpty for better performance

This results in a faster Vector#isEmpty (and head, tail, last, init)
because it avoids building a VectorIterator just to check if
iterator.hasNext is false.
Other classes which have not overridden the implementation of SeqLike
also benefit from it.
Merge pull request #1114 from scalamacros/topic/is-artifact

Introduces the `isArtifact` test for symbols
Merge pull request #1140 from soc/SI-6167

SI-6167 Override SeqLike#isEmpty for better performance
Merge remote-tracking branch 'upstream/2.10.x' into merge-210

Required a few changes of `HIDDEN` -> `ARTIFACT` and `isHidden` -> `isArtifact`

Conflicts:
	src/reflect/scala/reflect/internal/Flags.scala
Merge pull request #1148 from lrytz/merge-210

Merge 210