Roslyn is an effort to create a new generation of compilers
written in managed code. In addition to the standard batch
compiler, it contains a compiler API that can be used by all
kinds of tools that want to understand and manipulate C#
source code.

Roslyn is the foundation that powers the new smarts in
Visual Studio and can also be used for static analysis, code
refactoring or even to smartly navigate your source
code. It is a great foundation that tool developers will
be able to build on.

I had the honor of sharing the stage with Anders Hejlsberg
when he published the source code, and showed both Roslyn
working on a Mac with Mono, as well as showing the very same
patch that he demoed on stage running on Mono.

Roslyn on Mono

The source code as released contains some C# 6.0 features
so the patches add a bootstrapping phase, allowing Roslyn to
be built with a C# 5.0 compiler from sources. There are also
a couple of patches to deal with paths (Windows vs Unix paths)
as well as a Unix Makefile to build the result.

Sadly, Roslyn's build script depends on a number of
features of MSBuild that neither Mono or
MonoDevelop/XamarinStudio support currently [3], but we hope
we can address in the future. For now, we will have to
maintain a Makefile-based system to use Roslyn.

Our patches no longer apply to the tip of Roslyn master, as
Roslyn is under very active development. We will be updating the
patches and track Roslyn master on our fork moving
forward.

Currently Roslyn generates debug information using a Visual
Studio native library. So the /debug switch does not work.
We will be providing an alternative implementation that uses
Mono's symbol writer.

Adopting Roslyn: Mono SDK

Our goal is to keep track of Roslyn as it is being
developed, and when it is officially released, to bundle
Roslyn's compilers with Mono [6].

But in addition, this will provide an up-to-date and
compliant Visual Basic.NET compiler to Unix platforms.

Our plans currently are to keep both compilers around, and
we will implement the various C# 6.0 features into Mono's C#
compiler.

There are a couple of reasons for this. Our batch compiler
has been fine tuned over the years, and for day-to-day
compilation it is currently faster than the Roslyn compiler.

The second one is that our compiler powers our Interactive
C# Shell and we are about to launch something very
interesting with it. This functionality is not currently
available on the open sourced Roslyn stack.

In addition, we plan on distributing the various Roslyn
assemblies to Mono users, so they can build their own tools on
top of Roslyn out of the box.

Adopting Roslyn: MonoDevelop/Xamarin Studio

Roslyn really shines for use in IDEs.

We have started an effort to adopt Roslyn in
MonoDevelop/Xamarin Studio. This means that the underlying
NRefactory engine will also adopt Roslyn.

This is going to be a gradual process, and during the
migration the goal is to keep using both Mono's C# compiler as
a service engine and bit by bit, replace with the Roslyn
components.

We are evaluating various areas where Roslyn will have a
positive impact. The plan is to start with code completion
[4] and later on, support the full spectrum of features that
NRefactory provides (from refactoring to code generation).

C# Standard

While not related to Roslyn, I figured it was time to share
this.

For the last couple of months, the ECMA C# committee has been
working on updating the spec to reflect C# 5. And this time
around, the spec benefits from having two independent compiler
implementations.

Mono Project and Roslyn

Our goal is to contribute fixes to the Roslyn team to make
sure that Roslyn works great on Unix systems, and hopefully to
provide bug reports and bug fixes as time goes by.

We are very excited about the release of Roslyn, it is an
amazing piece of technology and one of the most sophisticated
compiler designs available. A great place to learn great C#
idioms and best practices [5], and a great foundation for
great tooling for C# and VB.

Thanks to everyone at Microsoft that made this possible,
and thanks to everyone on the Roslyn team for starting,
contributing and delivering such an ambitious project.

Notes

[1] Roslyn uses a few tracing APIs that were not available
on Mono, so you must use a newer version of Mono to build
Roslyn.

[2] We even include the patch to add french quotes that
Anders demoed. Make sure to skip that patch if you don't
want it :-)

[3] From Michael Hutchinson:

There are references of the form: <Reference Include="Microsoft.Build, Version=$(VisualStudioReferenceAssemblyVersion), Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
This is a problem because our project system tries to load project
references verbatim from the project file, instead of evaluating them
from the MSBuild engine. This would be fixed by one of the MSBuild
integration improvements I've proposed.

There's an InvalidProjectFileException error from the xbuild engine
when loading one of the targets files that's imported by several of
the code analysis projects, VSL.Settings.targets. I'm pretty sure this
is because it uses MSBuild property functions, an MSBuild 4.0 feature
that xbuild does not support.

They use the AllowNonModulatedReference metadata on some references
and it's completely undocumented, so I have no idea what it does and
what problems might be caused by not handling it in xbuild.

One project can't be opened because it's a VS Extension project.
I've added the GUID and name to our list of known project types so we
show a more useful error message.

A few of the projects depend on
Microsoft.Build.dll, and Mono does not have a working
implementation of it yet. They also reference other
MSBuild assemblies which I know we have not
finished.

[4] Since Roslyn is much better at error recovery and has a
much more comprehensive support for code completion than
Mono's C# compiler does. It also has much better support for
dealing with incremental changes than we do.

[5] Modulo private. They use
private everywhere, and that is just plain ugly.

[6] We will find out a way of selecting which compiler to use,
either mcs (Mono's C# Compiler) or Roslyn.