void MySomeHack(int i)
{
  i++;
    [msil]
    {
      ldloc.0
      ldloc.0
      add
      ...
    }
    ...
        [Atomic] // == transaction 
        {
          //some code
        }
        
        [If(conditionExpression)]
        {
        }
        [Else]
        {
        }
}

// Подглючаем модуль оптимизации
[assembly : RSDN.Compiler.Use("MyOptimizationsPac")]
// Подглючаем модуль метапрограммирования
[file     : RSDN.Compiler.Use("RSDN.MetaLangPac")]

void MySomeHack(int i)
{
  i++;
    __msil
    {
      ldloc.0
      ldloc.0
      add
      ...
    }
    ...
}

// Генерирует типизированные списки для всех интерфейсов, наследников IList
metatemplate TypedList<project/interface[BaseInterfaces[Name == "System.Collections.IList"]]>
{
    public class <./Name>Implementation : CollectionBase, <./Name>
    {
        <./Name> this[int index]
        {
            get { return (<./Name>)List[index]; }
        }
    
        public void Add(<./Name> item)
        {
            List.Add(item);
        }
        
        ...
    }
}

// Генерирует immutable класс для интерфейсов, помеченных атрибутом Immutable
metatemplate ImmutableClass<project/interface[Attribute[Name == "ImmutableAttribute"]]>
{
    public class <./Name>Implementation : <./Name>
    {
        <foreach (./Property)>
        private <./Type> _<./Name>;
        
        public <./Type> <./Name>
        {
            get { return _<./Name>; }
        }
        <endforeach>
        
        public <./Name>Implementation(
            <foreach (./Property, ", ")>
            <./Type> param<./Name>
            <endforeach>
        )
        {
            <foreach (./Property)>
            _<./Name> = param<./Name>;
            <endforeach>
        }
    }
}

TOKEN :
{
  < LPAREN: "(" >
| < RPAREN: ")" >
| < LBRACE: "{" >
| < RBRACE: "}" >
| < LBRACKET: "[" >
| < RBRACKET: "]" >
| < SEMICOLON: ";" >
| < COMMA: "," >
| < DOT: "." >
}


void ArrayDimsAndInits() :
{}
{
  LOOKAHEAD(2)
  ( LOOKAHEAD(2) "[" Expression(new Vector()) "]" )+ ( LOOKAHEAD(2) "[" "]" )*
|
  ( "[" "]" )+ ArrayInitializer()
}

void ArrayInitializer() :
{}
{
  "{" [ VariableInitializer() ( LOOKAHEAD(2) "," VariableInitializer() )* ] [ "," ] "}"
}

void Expression(Vector vector) :
{
    Token token1 = getToken(1);
}
{
  ConditionalExpression() [ AssignmentOperator() Expression(new Vector()) ]
    {
        Token token2 = getToken(0);
        Token token3 = token1;
        do
        {
            vector.addElement(token3);
            if(token3 != token2)
                token3 = token3.next;
            else
                return;
        } while(true);
    }
}

        int __arglist;

// Генерирует типизированные списки для всех интерфейсов, наследников IList
[RSDN.Meta.MetaClass(Name = "ItemType + Collection")]
[RSDN.Meta.TypeParam(typeName = "ItemType")]
[RSDN.Meta.ApplayTo(Assmbly = "This", ImplementInterface = "System.Collections.IList")]
class ItemTypeCollection : CollectionBase
{
      ItemType this[int index]
      {
          get { return (ItemType)List[index]; }
      }
    
        public void Add(ItemType item)
        {
            List.Add(item);
        }
        
        ...
    }
}

VD>// Генерирует типизированные списки для всех интерфейсов, наследников IList
VD>[RSDN.Meta.MetaClass(Name = "ItemType + Collection")]
VD>[RSDN.Meta.TypeParam(typeName = "ItemType")]
VD>[RSDN.Meta.ApplayTo(Assmbly = "This", ImplementInterface = "System.Collections.IList")]
VD>class ItemTypeCollection : CollectionBase
VD>{
VD>      ItemType this[int index]
VD>      {
VD>          get { return (ItemType)List[index]; }
VD>      }
    
VD>        public void Add(ItemType item)
VD>        {
VD>            List.Add(item);
VD>        }
        
VD>        ...
VD>    }
VD>}
VD>

<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:helper="urn:codegen-helper">

    <xsl:output method="text"/>
    
    <xsl:include href="InterfaceNames.xslt"/>
    <xsl:include href="MethodSignature.xslt"/>
    
    <xsl:template match="/Workspace">
using System;

using Parus.OBJ;

namespace <xsl:value-of select="@root-namespace"/>
{
    <xsl:apply-templates select="Classes/Class"/>
}
    </xsl:template>
    
    <xsl:template match="Class"></xsl:template>
    
    <xsl:template match="Class[IsPersistent/text() = 'True']">
        <xsl:variable name="class-name">
            <xsl:value-of select="helper:GetName(@name)"/>
        </xsl:variable>
        <xsl:variable name="ns-name">
            <xsl:value-of select="helper:GetNamespace(@name)"/>
        </xsl:variable>
        <xsl:if test="string-length($ns-name) > 0">
namespace <xsl:value-of select="$ns-name"/>
{</xsl:if>
    /// &lt;summary&gt;
    /// Клиентский интерфейс класса <xsl:value-of select="@name"/>.
    /// &lt;/summary&gt;
    public interface I<xsl:value-of select="$class-name"/>Client<xsl:if test="BaseClass/@ref-id"> : <e/>
        <xsl:call-template name="client-interface-name">
            <xsl:with-param name="name" select="BaseClass/@ref-name"/>
        </xsl:call-template>
    </xsl:if>
    {
        <xsl:apply-templates select="ClassPhysicalAttributes/ClassPhysicalAttribute"/>
        <xsl:apply-templates select="ClassRefAttributes/ClassRefAttribute"/>
        
        <xsl:apply-templates select="ClassMethods/ClassMethod"/>
    }
        <xsl:if test="string-length($ns-name) > 0">
}
</xsl:if>
    </xsl:template>
    
    <xsl:template match="ClassPhysicalAttribute">
        /// &lt;summary&gt;
        /// Атрибут <xsl:value-of select="@name"/>.
        /// &lt;/summary&gt;
        [Transactional]
        <xsl:value-of select="Domain/@ref-name"/> <xsl:value-of select="@name"/>
        {get; set;}
    </xsl:template>
    
    <xsl:template match="ClassRefAttribute">
        /// &lt;summary&gt;
        /// Ссылочный атрибут <xsl:value-of select="@name"/>.
        /// &lt;/summary&gt;
        [Transactional]
        <xsl:call-template name="client-interface-name">
            <xsl:with-param name="name">
                <xsl:value-of select="RefClass/@ref-name"/>
            </xsl:with-param>
        </xsl:call-template>
        <xsl:value-of select="' '"/>
        <xsl:value-of select="@name"/>
        {get; set;}
    </xsl:template>
    
    <xsl:template match="ClassMethod">
        /// &lt;summary&gt;
        /// Метод <xsl:value-of select="@name"/>.
        /// &lt;/summary&gt;
        <xsl:if test="BeginTransaction/text() = 'True'">[Transactional]</xsl:if>
        <xsl:call-template name="method-signature"/>;
    </xsl:template>
    
</xsl:stylesheet>

[Metaclass]
class Metaclass
{
  static void MakeProperty(ClassBuilder cb, Enum aEnum)
    {
        string[] names = MetaUtils.GetEnumNames(aEnum);

      foreach (string name in names)
        {
          string varName = MetaUtils.MakeVarName(name);
          string propName = MetaUtils.MakePropName(name);
            cb.AddLacalVar(varName);
            cb.AddProperty(propName, PropertyFlag.Get | PropertyFlag.Set,
                varName);
        }
    }
}

// Применерие

enum Some
{
  Some1,
  Some2,
  Some3,
}

[MetaCall, MakeProperty(this, Some)]
class MyTemplate
{
    ...
}

S>        [If(conditionExpression)]
S>        {
S>        }
S>        [Else]
S>        {
S>        }
S>}
S>

[MetaVar]
bool isCondition = MetaConditionCall();
...
if (isCondition)
{
  // Если isCondition == true - этот блок скомпилируется...
}
else
{
    // Если isCondition == true - этот блок будет выброшен перед компиляцией...
}

...
msil();
{
 ...
}

лучше бы сам подумал, зачем, например, есть просто делегаты, а есть мультикастделегаты... и т.д. и т.п.

Compiler Generator , generates a Recursvie Decent Predictive Parser for LL(1) grammar , Semantic Rules are supported through Translation Schemes, Also include A Lexical Analyzer Generator which generates a lexical table for given token defintion , give it a try

// Генерирует immutable класс для интерфейсов, помеченных атрибутом Immutable
<% foreach(Type type in xxx.FindMarkedByImmutable()) { %>

    public class <%=type.Name%>Immutable : <%=type.FullName%>
    {
        <% foreach(PropertyInfo info in xxx.FindProperties(type)) { %>
        private <%=info.MemberType%> _<%=info.Name%>;
        
        public <%=info.MemberType%> <%=info.Name%>
        {
            get { return _<%=info.Name%>; }
        }
        <% } %>
        
        public <%=type.Name%>Immutable(
            <% int pos=0; foreach(PropertyInfo info in xxx.FindProperties(type)) { %>
            <%=info.MemberType%> param<%=info.Name%><%= ++pos<xxx.FindProperties(type).Length ? ", " : "" %>
            <% } %>
        )
        {
            <% foreach(PropertyInfo info in xxx.FindProperties(type)) { %>
            _<%=info.Name%> = param<%=info.Name%>;
            <% } %>
        }
    }
<% } %>