[Nemerle.MacroUsage(Nemerle.MacroPhase.BeforeInheritance,
                        Nemerle.MacroTargets.Class)]
    macro TestMacro(tb : TypeBuilder)
    {
        def c = tb.SystemType;
        System.Console.WriteLine(c.ToString()); // выпадаем с NullReference
    }

    def attributes = tb.GetModifiers().GetCustomAttributes();
    foreach (attr in attributes)
        Console.WriteLine(attr.ToString());

using System;
using Nemerle.Macros;
using Nemerle.Compiler;

macro DissectAttributes(typeName)
{
    def typer = ImplicitCTX();

    def lookupType(tn)
    {
        match(Macros.GetIfIsType(typer.Env, tn))
        {
            | Some(typeInfo) => typeInfo
            | None => null
        }        
    }

    def getAttrType(attrName)
    {
        def attrType = lookupType(<[ $(attrName : name) ]>);
        if (attrType == null)
        {
            def altName = attrName.NewName(attrName.ToString() + "Attribute");
            lookupType(<[ $(altName : name) ]>)
        }
        else
            attrType
    }

    def attributes = lookupType(typeName).GetModifiers().GetCustomAttributes();
    def serializable = lookupType(<[ System.SerializableAttribute ]>);
    foreach (attr in attributes)
    {
        | <[ $(attrName : name) ]> =>
            def attrType = getAttrType(attrName);
            Console.WriteLine("expr: {0}, type: {1}",
                              attr, attrType.ToString());

            when (serializable.Equals(attrType))
                Console.WriteLine("yay! it's serializable");

        | <[ $(attrName : name)(.. $attrParams) ]> =>
            def attrType = getAttrType(attrName);
            Console.WriteLine("expr: {0}, type: {1}, params: {2}", 
                              attr, attrType.ToString(), attrParams);
        | _ => Console.WriteLine("should not happen, attr was {0}", attr);
    }
    <[ ]>
}

using System;

[AttributeUsage(AttributeTargets.Class, Inherited=true, AllowMultiple=true)]
public class FooAttribute : Attribute
{
    public this(_name : string)  {}
}


[AttributeUsage(AttributeTargets.Class, Inherited=true, AllowMultiple=true)]
public class Bar : Attribute
{
    public this(_foo : string, _bar : int)  {}
}

[Foo("foobar"), Bar("hellothere!", 2), Serializable]
public class Test
{
    static Main() : void
    {
        DissectAttributes(Test);
    }
}

expr: Serializable, type: System.SerializableAttribute
yay! it's serializable
expr: Bar ("hellothere!", 2), type: Bar, params: ["hellothere!", 2]
expr: Foo ("foobar"), type: FooAttribute, params: ["foobar"]

VK>    def attributes = tb.GetModifiers().GetCustomAttributes();
VK>    foreach (attr in attributes)
VK>        Console.WriteLine(attr.ToString());
VK>

    [Record]
    public class MyAttrAttribute : Attribute
    {
        [Accessor]
        mutable _name : string = "(Default)";
        public this(){}
    }
    [Record]
    public class MyAttr2Attribute : Attribute
    {
        [Accessor]
        mutable _name : string;
        [Accessor]
        mutable _number : int;
        [Accessor]
        mutable _char : char;
        [Accessor]
        mutable _money : decimal;
        public this(){}
    }

    internal module AttributeHelper
    {
        public GetAttributes(tb : TypeBuilder) : array[Attribute]
        {
            def env = tb.GlobalEnv;

            def lookupType(tn)
            {
                match(Macros.GetIfIsType(env, tn))
                {
                    | Some(typeInfo) => typeInfo
                    | None => null
                }
            }
            def getAttrType(attrName)
            {
                def attrType = lookupType(<[ $(attrName : name) ]>);
                if (attrType == null)
                {
                    def altName = attrName.NewName(attrName.ToString() + "Attribute");
                    lookupType(<[ $(altName : name) ]>)
                }
                else
                    attrType
            }
            def getParamValue(param)
            {
                def resolveLiteralInteger(lit : Literal.Integer)
                {
                    def val = lit.val;
                    def is_negative = lit.is_negative;
                    def treat_as = lit.treat_as;


                    def mul = if (is_negative) -1 else 1;
                    
                    // смотриться убого, надо понять как это все переписать на match
                    if (treat_as.Equals(InternalType.Byte))
                        (val :> Byte) : object;
                    else if (treat_as.Equals(InternalType.UInt16))
                        (val :> UInt16) : object
                    else if (treat_as.Equals(InternalType.UInt32))
                        (val :> UInt32) : object
                    else if (treat_as.Equals(InternalType.UInt64))
                        val : object
                    else if (treat_as.Equals(InternalType.SByte))
                        ((val :> SByte)*mul) : object
                    else if (treat_as.Equals(InternalType.Int16))
                        ((val :> Int16)*mul) : object
                    else if (treat_as.Equals(InternalType.Int32))
                        ((val :> Int32)*mul) : object
                    else if (treat_as.Equals(InternalType.Int64))
                        ((val :> Int64)*mul) : object
                    else
                        throw Exception("Should never be throwed...")
                }
                def resolveLiteral(param)
                {
                    match (param)
                    {
                        | lit is PExpr.Literal =>
                            match (lit.val)
                            {
                                | Literal.Void => null : object
                                | Literal.Null => null : object
                                | Literal.String (val) => val : object
                                | Literal.Float (val) => val : object
                                | Literal.Double (val) => val : object
                                | Literal.Decimal (val) => val : object
                                
                                | Literal.Integer (_, _, _) => 
                                    resolveLiteralInteger(lit.val :> Literal.Integer)
                                
                                | Literal.Bool (val) => val : object
                                | Literal.Char (val) => val : object
                                | Literal.Enum (val, _) => val : object

                                | _ => throw Exception("This literal is not supported yet...")
                            }
                        | _ => throw Exception("Should never be throwed...")
                    }
                }

                resolveLiteral(param);
            }

            def attributes = tb.GetModifiers().GetCustomAttributes();
            mutable resolvedAttributes = [];

            foreach (attr in attributes)
            {
                | <[ $(attrName : name) ]> =>
                    def attrTypeName = getAttrType(attrName).ToString();
                    def attrObj = 
                        Activator.CreateInstance(null, attrTypeName)
                            .Unwrap() :> Attribute;
                    resolvedAttributes = attrObj :: resolvedAttributes;

                | <[ $(attrName : name)(.. $attrParams) ]> =>
                    def attrTypeName = getAttrType(attrName).ToString();
                    def cctorParams = attrParams.Map(getParamValue).ToArray();
                    def attrObj =
                        Activator
                            .CreateInstance(null, attrTypeName, false, 
                                            BindingFlags.CreateInstance, null,
                                            cctorParams, null, null, null)
                            .Unwrap() :> Attribute;
                    resolvedAttributes = attrObj :: resolvedAttributes;

                | _ => throw Exception("Should not happen");
            }

            resolvedAttributes.ToArray();
        }

    }

    [Nemerle.MacroUsage(Nemerle.MacroPhase.BeforeInheritance,
                        Nemerle.MacroTargets.Class,
                        Inherited = true)]
    macro TestMacro(tb : TypeBuilder)
    {
        def attrs = AttributeHelper.GetAttributes(tb);
        foreach (attr in attrs)
        {
            | a is MyAttrAttribute => 
                Console.WriteLine("MyAttrAttribute(\"{0}\")", a.Name);
            | a is MyAttr2Attribute => 
                Console.WriteLine("MyAttr2Attribute(\"{0}\", {1}, '{2}', {3})",
                                  a.Name, a.Number, a.Char, a.Money);
            | _ => 
                Console.WriteLine("This attribute isn't supported...");
        }
    }

    [TestMacro]
    [MyAttr("TestName")]
    [MyAttr2("TestName2", 23, 't', 34.3434m)]
    class TestMacroTest
    {}

MyAttrAttribute("TestName")
MyAttr2Attribute("TestName2", 23, 't', 34.3434)

error : internal compiler error: got ArgumentException (An invalid type was used as a custom attribute constructor argument, field or property.)
at System.Reflection.Emit.CustomAttributeBuilder.InitCustomAttributeBuilder(ConstructorInfo con, Object[] constructorArgs, PropertyInfo[] namedProperties, Object[] propertyValues, FieldInfo[] namedFields, Object[] fieldValues)
at Nemerle.Compiler.AttributeCompiler.do_compile(GlobalEnv env, TypeBuilder ti, TypeInfo attr, list`1 parms)
at Nemerle.Compiler.AttributeCompiler.CompileAttribute(GlobalEnv env, TypeBuilder ti, PExpr expr)
at Nemerle.Compiler.Modifiers.SaveCustomAttributes(TypeBuilder ti, Function`3 adder)
at Nemerle.Compiler.TypeBuilder.EmitImplementation()
at Nemerle.Compiler.TypesManager._N_emit_impl_23651.apply_void(TypeBuilder _N_23650)
at Nemerle.Compiler.TypesManager._N_maybe_f_24088.apply_void(TypeBuilder _N_24087)
at Nemerle.Collections.List.Iter['a](list`1 l, FunctionVoid`1 f)
at Nemerle.Core.list`1.Iter(FunctionVoid`1 f)
at Nemerle.Compiler.TypesManager.Iter(list`1 builders, FunctionVoid`1 f)
at Nemerle.Compiler.TypesManager.compile_all_tyinfos(Boolean aux_phase)
at Nemerle.Compiler.TypesManager._N__N_l23232_23319.apply_void()
at Nemerle.Compiler.Solver.Enqueue(FunctionVoid action)
at Nemerle.Compiler.Passes.Run()
at Nemerle.CommandlineCompiler.MainClass.main_with_catching()

VK>Сама концепция макросов и квази-цитирования очень хороша, но вот api компилятора весьма убогое на мой взгляд. В любом случае если язык приобретет популярность, то api поменяется(или наооборот ). И переписывать код макросов будет гораздо проще, если он будет более читабелен.

match(lit) // где lit это один из подтипов PExpr, т.е. выражение
{
  // void
  <[ () ]> => // ...
  <[ null ]> => // ...
  <[ $(n : int) ]> => // ...
  <[ $(str : string) ]> => // ...
}

foreach(attr in attributes)
{
  | <[ Serializable ]> => //...
  | <[ MyAttr($(money : decimal), $(name : string)) ]> => Console.WriteLine($"$money $name");
}

using System;
using Nemerle.Macros;
using Nemerle.Compiler;
using Nemerle.Collections;

namespace PlainWeird
{
    internal variant WeirdAttribute
    {
        | Bad  { money : decimal }
        | Good { name : string   }
        | Ugly { name : string; number : int; money : decimal }
    }

    internal module WeirdCache
    {
        // можно и по TypeBuilder кэшировать, но:
        // 1) TypeInfo.FullName обязано обеспечивать уникальное имя типа
        // 2) я не уверен, что у нас всегда будет доступ 
        //    к TypeBuilder классов(в отличие от TypeInfo)
        private AttributeCache : Hashtable[string, list[WeirdAttribute]] = Hashtable();

        public AddAttribute(typeInfo : TypeInfo, attribute : WeirdAttribute) : void
        {
            def fullName = typeInfo.FullName;
            AttributeCache[fullName] = attribute :: AttributeCache[fullName];
        }

        public ContainsAttributes(typeInfo : TypeInfo) : bool
        {
            AttributeCache.Contains(typeInfo.FullName)
        }

        public GetAttributes(typeInfo : TypeInfo) : list[WeirdAttribute]
        {
            AttributeCache[typeInfo.FullName]
        }
    }
    
    [Nemerle.MacroUsage (Nemerle.MacroPhase.BeforeInheritance, 
                         Nemerle.MacroTargets.Class)]
    macro WeirdlyBad(tb : TypeBuilder, money : decimal)
    {
        WeirdCache.AddAttribute(tb, WeirdAttribute.Bad(money));
    }

    [Nemerle.MacroUsage (Nemerle.MacroPhase.BeforeInheritance, 
                         Nemerle.MacroTargets.Class)]
    macro WeirdlyGood(tb : TypeBuilder, name : string)
    {
        WeirdCache.AddAttribute(tb, WeirdAttribute.Good(name));    
    }

    [Nemerle.MacroUsage (Nemerle.MacroPhase.BeforeInheritance, 
                         Nemerle.MacroTargets.Class)]
    macro WeirdAndUgly(tb : TypeBuilder, name : string, number : int, money : decimal)
    {
        WeirdCache.AddAttribute(tb, WeirdAttribute.Ugly(name, number, money));    
    }

    // если я не ошибаюсь можно определять несколько макросов с одним названием,
    // если они отличаются фазами и/или целями применения
    [Nemerle.MacroUsage (Nemerle.MacroPhase.BeforeTypedMembers, 
                         Nemerle.MacroTargets.Class)]
    macro WeirdlyBad(_tb : TypeBuilder, _money : decimal)
    {
        // сделать что-нибудь нехорошее на другой стадии
    }

    macro IsItWeird(typeName)
    {
        def typer = ImplicitCTX();
        def lookupType(tn)
        {
            match(Macros.GetIfIsType(typer.Env, tn))
            {
                | Some(typeInfo) => typeInfo
                | None => null
            }        
        }
        def t = lookupType(typeName);
        when (t == null)
            Message.FatalError($"Expected user-defined type name, got '$typeName'");
        when (WeirdCache.ContainsAttributes(t))
        {
            Console.WriteLine($"$(t.FullName):");
            foreach(attr in WeirdCache.GetAttributes(t))
            {
                | Bad(money) => Console.WriteLine($"    WeirdlyBad($money)")
                | Good(name) => Console.WriteLine($"    WeirdlyGood($name)")
                | Ugly(name, number, money) =>
                    Console.WriteLine($"    WeirdAndUgly($name,$number,$money)")
            }
            Console.WriteLine();
        }
        <[ ]>
    }
}

using PlainWeird;

namespace Kansas
{
    [WeirdAndUgly("Billy The Kid", 1, 50000.0m), WeirdlyBad(20000.0m)]
    class BillyTheKid
    {
        public this()
        {
            IsItWeird(Sheriff);
            IsItWeird(Texas.Sheriff);
            IsItWeird(Texas.UnknownBandit);
        }
    }

    [WeirdlyGood("Tony Smith")]
    class Sheriff
    {
    }
}

namespace Texas
{
    [WeirdAndUgly("Joe Hulligan", 1, 35000.0m), WeirdlyBad(35000.0m)]
    class JoeHulligan
    {
    }

    [WeirdAndUgly("Billy The Kid #2", 2, 30000.0m)]
    class BillyTheKid
    {
    }

    [WeirdlyBad(3000.0m)]
    class UnknownBandit
    {
    }

    [WeirdlyGood("John Smith")]
    class Sheriff
    {
    }

}

IsItWeird(Kansas.BillyTheKid);
IsItWeird(Texas.BillyTheKid);
IsItWeird(Texas.JoeHulligan);
IsItWeird(IncomprehensibleIdiot);

Kansas.Sheriff:
    WeirdlyGood(Tony Smith)

Texas.Sheriff:
    WeirdlyGood(John Smith)

Texas.UnknownBandit:
    WeirdlyBad(3000.0)

Kansas.BillyTheKid:
    WeirdlyBad(20000.0)
    WeirdAndUgly(Billy The Kid,1,50000.0)

Texas.BillyTheKid:
    WeirdAndUgly(Billy The Kid #2,2,30000.0)

Texas.JoeHulligan:
    WeirdlyBad(35000.0)
    WeirdAndUgly(Joe Hulligan,1,35000.0)

attrtest.n:49:1:49:10: Expected user-defined type name, got 'IncomprehensibleIdiot'