using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;
using Nemerle.Collections;
using Nemerle.Macros;
using Nemerle.Utility;

namespace Oyster
{
    macro metaclass(className, body)
    syntax ("metaclass", className, body)
    {
        def ctx = ImplicitCTX();
        mutable code = [];
        match (body)
        {
            | <[ { .. $props } ]> =>
                foreach(<[ $(n : name) : $(t : name) ]> in props)
                {
                    code ::= <[ decl:
                        [Accessor]
                        mutable $(n.NewName("_" + n.Id) : name) : $(t : name) ;
                    ]>;
                }
            | _ => Message.FatalError($"Invalid metaclass syntax, expected properties definition, got $body");
        }
        
        // Вот тут начался настоящий изврат - делаем новый TypeDeclaration.
        // Может, можно как-то иначе?
        // Правда, этот код можно написать один раз и реюзать...
        def typedecl = <[ decl: [Record] public class $(className.ToString() : usesite) {} ]>;
        def newTopdecl = TopDeclaration.Class(
            typedecl.Location,
            typedecl.name,
            typedecl.modifiers,
            typedecl.td.typarms,
            (typedecl.td :> TopDeclaration.Class).t_extends,
            code.Reverse());
        def builder = ctx.Env.Define(ClassMember.TypeDeclaration(
            typedecl.Location,
            typedecl.name,
            typedecl.modifiers,
            newTopdecl));
        builder.Compile();
        <[ () ]>
    }
}

VK>using Nemerle.Compiler;
VK>using Nemerle.Collections;
VK>using Nemerle.Macros;

VK>namespace Oyster
VK>{
VK>    macro metaclass(className, body)
VK>    syntax ("metaclass", className, body)
VK>    {
VK>        def ctx = ImplicitCTX();
VK>        def builder = ctx.Env.Define(<[ decl: public class $(className.ToString() : usesite) {} ]>);
VK>        mutable constrParams = [];
VK>        mutable constrCode = [];
VK>        match (body)
VK>        {
VK>            | <[ { .. $props } ]> =>
VK>                foreach(<[ $(n : name) : $(t : name) ]> in props)
VK>                {
VK>                    builder.Define(<[ decl:
VK>                                        [Nemerle.Utility.Accessor]
VK>                                        mutable $(n : name) : $(t : name) ;
VK>                                   ]>);
VK>                    def paramType = ctx.BindType(<[ $(t : name) ]>);
VK>                    constrParams = <[ parameter: $(n : name) : $(paramType : typed) ]> :: constrParams;
VK>                    constrCode = <[ this.$(n.NewName("_" + n.Id) : name) = $(n : name); ]> :: constrCode;
VK>                }
VK>            | _ => Message.FatalError($"Invalid metaclass syntax, expected properties definition, got $body");
VK>        }                
VK>        builder.Define(<[ decl: public this(.. $(constrParams.Reverse())) { .. $constrCode } ]>);
VK>        builder.Compile();
VK>        <[ () ]>
VK>    }
VK>}
VK>

def propInfos = Impl.GetPropInfoList(body);
...
DefineCtor(propInfos);

def propInfos = Impl.GetPropInfoList(body);
def ctx = ImplicitCTX();
def builder = ctx.Env.Define(<[ decl: public class $(className.ToString() : usesite) { } ]>);

MacroLib.DefineCtor(builder, propInfos);
MacroLib.DefineProps(builder, propInfos);

match (body)
{
        | <[ { .. $props } ]> =>
                foreach(prop in props)
                {    | <[ $(n : name) : $(t : name) ]> =>
                        builder.Define(<[ decl:
                            [Nemerle.Utility.Accessor] mutable $(n : name) : $(t : name););
                        def paramType = ctx.BindType(<[ $(t : name) ]>);
                        constrParams ::= <[ parameter: $(n : name) : $(paramType : typed) ]>;
                        constrCode   ::= <[ this.$(MacroLib.ToFieldName(n)) : name) = $(n : name); ]>;
                    | PExpr => Message.FatalError(prop.Location, $"Invalid metaclass syntax: '$prop'";
                }
        | _ => Message.FatalError($"Invalid metaclass syntax, expected properties definition, got $body");
}

O>Блин... я наконец-то понял Вот как у меня получилось:

O>def builder = ctx.Env.Define(<[ decl: [Record] public class $(className : name) { [Nemerle.Utility.Accessor] mutable test : int; } ]>);
O>

O>Т.е. надо просто собрать AST заранее

def builder = ctx.Env.Define(<[ decl: [Record] public class $(className : name) { ..$members } ]>);