A little less indirection.

We don't have to call length on that there List.
Added make not private logic for @inline accesses back to ExplicitOuter.

As discussed in https://mail.google.com/mail/u/0/?hl=en&tab=Tm#search/inlining+changes+needed/1390c955960d7cb5, we need to move access widenings back to ExplicitOuter, so that outer fields are correctly widened. The previous logiv in SuperAccessors can go once the inliner is adapted to the new scheme. I leave SuperAccessors for the moment as is, in order not to slide back even further with inlining.
Merge pull request #1116 from scalamacros/topic/flags-again

a follow up on e01ec05a1e
Merge pull request #1120 from paulp/ticket-6184-revised

Ticket 6184 revised
More resilience to missing classes.

The situation (I don't know how to make partest test this) is

  package s
  class A ; class S { def f(): A = ??? }

If one compiles this and removes A.class, should references to
class S cause the compiler to explode eagerly and fail to load S,
or explode lazily if and when it needs to know something about A?
This patch takes us from the former strategy to the latter.

Review by @xeno-by.
Simplify the adaptation of types of return expressions

Add `adaptTypeOfReturn` hook to `AnnotationCheckers`.
Move adaptation of types of return expressions from `addAnnotations`
to `typedReturn` via `adaptTypeOfReturn` hook.

This resolves an inconsistency where previously types could have
a plus marker without additional CPS annotations. This also adds
additional test cases.
Fixes SI-6214.

addSynthetics was calling typedStat that caused flushing error buffer. Typically that would result in errors being re-added but addSynthetics was the last thing to run in typedStats.
Instead of adding yet another check I used this as an opportunity to cleanup the once necessary workaround for typing stats. Since we are now chaining buffers of contexts manual handling is no longer necessary.

Review by @odersky (I recall that you were planning to cleanup that part at some point).
.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
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
Merge pull request #1123 from paulp/topic/unpickle-resilience-2

Topic/unpickle resilience 2
Merge pull request #1125 from hubertp/2.10.x-issue/6214

Fixes SI-6214.
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.
Move side-effecting call out of debuglog(). Fixes SI-6223.

This change fixes a situation in which method calls aren't being properly
specialized. All the existing tests pass; in addition, it likely fixes other
specialization bugs (and improves performance of specialized code).

Also includes a small regression test.
Merge pull request #1121 from odersky/topic/inline2

Added make not private logic for @inline accesses back to ExplicitOuter.
Fix for view isEmpty.

Views have been inheriting the very inefficient isEmpty
from Traversable, and since isEmpty is not specifically
forwarded to the underlying collections, views miss out on all
the important optimizations in those collections which tend to
be implemented via method override.  Not to mention, they miss
out on correctness, because calling foreach has a habit of
forcing the first element of the view.
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
Merge pull request #1102 from phaller/partest-local-flags

Support per-group flags files in partest
Merge pull request #1100 from adriaanm/ticket-6022b

SI-6022 cleaner model of variable equality modulo <: