What reflection capabilities can we expect from Scala 2.10?

update 2012-07-04:

Daniel SOBRAL (also on SO) details in his blog post “JSON serialization with reflection in Scala! Part 1 – So you want to do reflection?” some of the features coming with reflection:

To recapitulate, Scala 2.10 will come with a Scala reflection library.
That library is used by the compiler itself, but divided into layers through the cake pattern, so different users see different levels of detail, keeping jar sizes adequate to each one’s use, and hopefully hiding unwanted detail.

The reflection library also integrates with the upcoming macro facilities, enabling enterprising coders to manipulate code at compile time.

update 2012-06-14. (from Eugene Burmako):
In Scala 2.10.0-M4, we have released the new reflection API that will most likely make it into 2.10.0-final without significant changes.
More details about the API can be found:

• SO answer Get companion object instance with new Scala reflection API
• Scala Reflection SIP, June 2012 by Martin Odersky (SIP, actually “Scala Improvement Process”)
• summary and migration route from M3

Extracts:

Universes and mirrors are now separate entities:

• universes host reflection artifacts (trees, symbols, types, etc),
• mirrors abstract loading of those artifacts (e.g. JavaMirror loads stuff
  using a classloader and annotation unpickler, while GlobalMirror uses internal compiler classreader to achieve the same goal).

Public reflection API is split into scala.reflect.base and scala.reflect.api.

• The former represents a minimalistic snapshot that is exactly enough to
  build reified trees and types.
• To build, but not to analyze – everything smart (for example, getting a type signature) is implemented in scala.reflect.api.

Both reflection domains have their own universe: scala.reflect.basis and
scala.reflect.runtime.universe.

• The former is super lightweight and doesn’t involve any classloaders,
• while the latter represents a stripped down compiler.

Initial answer, Sept. 2011:

You can see evolutions of the reflect package in the Scala GitHub repo, with this two very recent commits:

• Changes to Liftcode to use new reflection semantics, where a compiler uses type checking.
• Started work on compiler toolbox that can compile reflect trees at runtime.

(Liftcode being, according to this thread, aims at simplifying “writing code that writes code”)

The class scala/reflect/internal/Importers.scala (created yesterday!) is a good example of using those latest reflection feature.