/// Adds property accessor for field.
  /// By default adds only getter.
  /// You can specify the following flags:
  /// WantSetter, Setter, Internal, Protected, Override, Virtual.
  /// Also you can specify the property name manualy (by default the name
  /// is generated from the field name).
  [Nemerle.MacroUsage (Nemerle.MacroPhase.BeforeInheritance,
                       Nemerle.MacroTargets.Field,
                       Inherited = false, AllowMultiple = true)]
  macro Accessor (current_type : TypeBuilder, storage_field : ParsedField, params args : list [PExpr])
  {
    def usage =
        "usage: Accessor (name, flags = MODIFIERS, get (MODIFIERS), set (MODIFIERS), "
        "attributes (LIST OF ATTRIBUTES)), where all sections are optional";

    mutable setterMods = NemerleAttributes.None;
    mutable getterMods = NemerleAttributes.Public;
    mutable want_setter = false;
    mutable attributes = [];
    mutable oname = None ();

    def parse_opts (expr, allow_deprec)
    {
      match (expr)
      {
        | <[ $("WantSetter" : dyn) ]>
        | <[ $("Setter"     : dyn) ]> =>
          unless (allow_deprec)
            Message.Error("WantSetter / Setter is not allowed outside 'flags' section");

          want_setter = true;
          NemerleAttributes.None

        | <[ $("Internal"  : dyn) ]>  => NemerleAttributes.Internal
        | <[ $("Protected" : dyn) ]>  => NemerleAttributes.Protected
        | <[ $("Override"  : dyn) ]>  => NemerleAttributes.Override
        | <[ $("Virtual"   : dyn) ]>  => NemerleAttributes.Virtual
        | <[ None ]>                  => NemerleAttributes.Extern // will be removed
        | <[ $e1 | $e2 ]> => (parse_opts(e1, allow_deprec) | parse_opts(e2, allow_deprec))
        | e => Message.FatalError($"bad accessor option, $e")
      }
    }

    foreach (a in args)
    {
      | <[ flags = $opts ]> =>
        def opts = parse_opts (opts, true);
        getterMods |= opts;

        when (want_setter)
          setterMods |= getterMods;

      | <[ $(n : dyn) ]>            => oname = Some(n)
      | <[ set ($opts) ]>           => setterMods |= parse_opts (opts, false)
      | <[ get ($opts) ]>           => getterMods |= parse_opts (opts, false)
      | <[ attributes (..$attrs) ]> => attributes += attrs
      | _ => Message.FatalError (usage);
    }

    // __some_foo__bar ==> SomeFooBar
    def transformed_name =
      {
        def sb = StringBuilder ();
        mutable next_upper = true;

        foreach (ch in storage_field.Name)
        {
          if (ch == '_')
            next_upper = true;
          else if (next_upper)
          {
            _ = sb.Append (char.ToUpperInvariant (ch));
            next_upper = false;
          }
          else
            _ = sb.Append (ch);
        }

        sb.ToString()
      };
    def name = oname.WithDefault(transformed_name);

    when (getterMods %&& NemerleAttributes.Extern)
      getterMods = NemerleAttributes.None;

    def take_minimum_access(mods)
    {
      if (mods %&& NemerleAttributes.Protected && !(mods %&& NemerleAttributes.Internal))
        NemerleAttributes.Protected
      else if (mods %&& NemerleAttributes.Internal && !(mods %&& NemerleAttributes.Protected))
        NemerleAttributes.Internal
      else if (mods %&& NemerleAttributes.Protected && mods %&& NemerleAttributes.Internal)
        NemerleAttributes.Internal | NemerleAttributes.Protected
      else if (mods %&& NemerleAttributes.Public)
        NemerleAttributes.Public
      else
        NemerleAttributes.None
    }

    getterMods = (getterMods & ~NemerleAttributes.AccessModifiers) | take_minimum_access(getterMods);
    setterMods = (setterMods & ~NemerleAttributes.AccessModifiers) | take_minimum_access(setterMods);

    def fieldref    = <[ $(storage_field.PName : name) ]>;
    def setterAttrs = Modifiers(setterMods, [<[ System.Diagnostics.DebuggerStepThroughAttribute ]>,<[System.Runtime.CompilerServices.CompilerGenerated]>]);
    def getterAttrs = Modifiers(getterMods, [<[ System.Diagnostics.DebuggerStepThroughAttribute ]>,<[System.Runtime.CompilerServices.CompilerGenerated]>]);
    def propAttrs   = Modifiers(NemerleAttributes.None, attributes);

    def prop =
      if (setterMods != NemerleAttributes.None && getterMods != NemerleAttributes.None)
        <[ decl:
          ..$propAttrs
          $(name : dyn) : $(storage_field.ty)
          {
            ..$setterAttrs set { $fieldref = value; }
            ..$getterAttrs get { $fieldref }
          }
        ]>
      else if (getterMods != NemerleAttributes.None)
        <[ decl:
          ..$propAttrs

          $(name : dyn) : $(storage_field.ty)
          {
            ..$getterAttrs get { $fieldref }
          }
        ]>;
      else if (setterMods != NemerleAttributes.None)
        <[ decl:
          ..$propAttrs

          $(name : dyn) : $(storage_field.ty)
          {
            ..$setterAttrs set { $fieldref = value }
          }
        ]>;
      else Message.FatalError ("no accessor will be visible with specified modifiers");

    prop.SetEnv(storage_field.Env);

    def totalMods = getterMods | setterMods;

    if (totalMods %&& NemerleAttributes.Public)
      prop.Attributes = (totalMods & ~NemerleAttributes.AccessModifiers) | NemerleAttributes.Public;
    else if (totalMods %&& NemerleAttributes.Internal && totalMods %&& NemerleAttributes.Protected)
      prop.Attributes = (totalMods & ~NemerleAttributes.AccessModifiers) | NemerleAttributes.Internal | NemerleAttributes.Protected;
    else if (totalMods %&& NemerleAttributes.Internal)
      prop.Attributes = (totalMods & ~NemerleAttributes.AccessModifiers) | NemerleAttributes.Internal;
    else if (totalMods %&& NemerleAttributes.Protected)
      prop.Attributes = (totalMods & ~NemerleAttributes.AccessModifiers) | NemerleAttributes.Protected;
    else
      prop.Attributes = (totalMods & ~NemerleAttributes.AccessModifiers) | NemerleAttributes.Private;

    when (storage_field.Attributes %&& NemerleAttributes.Static)
      prop.Attributes |= NemerleAttributes.Static;

    current_type.Define(prop);
  }

  macro @if (cond, e1, e2)
  syntax ("if", "(", cond, ")", e1, Optional (";"), "else", e2)
  {
    <[
      match ($cond : bool)
      {
        | true => $e1
        | _ => $e2
      }
    ]>
  }

macro property:

    # этот код генерирует исключение содержащее описание синтаксиса, если 
    # переданный макросу AST некорректный. PropertyMacroParser.IsValidProperty() проверяет корректность синтаксиса.
    raise "property <name> [as type] [= initialValue]" unless PropertyMacroParser.IsValidProperty(property)

    # Этот код извлекает значение параметра макроса (AST) и помещает его в переменную "argument".
    # В немерле это делать не надо, так как параметры указываются явно.
    argument = property.Arguments[0]
    # Этот код пытается привести ветку AST к типу BinaryExpression (бинарное выражение)
    initializationForm = argument as BinaryExpression
    if initializationForm is not null:
        # в случае успеха левую часть бинарного выражения пихает в переменную declaration
        declaration = initializationForm.Left
        # а правую в initializer
        initializer = initializationForm.Right
    else:
        # в случае если в argument находится не BinaryExpression...
        declaration = argument
        initializer = null
    # Код извлечения имени свойства из выражения вынесен в отдельный метод, так как это 
    # не элементарная операция.
    name = PropertyMacroParser.PropertyNameFrom(declaration)
    # Тоже самое с именем типа.
    type = PropertyMacroParser.PropertyTypeFrom(declaration)
    # Далее формируется уникальное имя для поля (которое создается макросом).
    # Так как гигиены у макросов (по всей видимости) нет, для генерации уникального имени
    # используется специальный API-вызов Context.GetUniqueName()
    backingField = ReferenceExpression(Name: Context.GetUniqueName(name.ToString()))

    # Далее с помощью квази-цитирования формируется код поля хранящего значение свойства
    # и код непосредственно свойства чьи эксесоры просто читают и пишут в/из поле.
    # По всей видимости синтаксиса квази-цитат ля нет, или это хитрый код с целью сэкономить 
    # место, по этому объявляется fake-класс "_" в котором и объявляются оба члена (поле и свойство).
    prototype = [|

        class _:

            private $backingField as $type = $initializer

            $name:
                get: return $backingField
                set: $backingField = value
    |]

    # В качестве возвращаемого значения макроса, возвращаются все члены этого класса.
    yieldAll prototype.Members 

# Класс-помощник. В него вынесен код проверок и т.п. чтобы сделать основной код более читабельным.
internal static class PropertyMacroParser:

    # Извлечение имени (ссылки на имя).
    def PropertyNameFrom(e as Expression) as ReferenceExpression:
        # Если выражение это TryCastExpression...
        declaration = e as TryCastExpression (т.е. "x as y")
        if declaration is not null:
            # то возвращаем Target (т.е. "x")
            return declaration.Target
        return e # иначе возвращаем все выражение

    # Извлекает имя типа. Код почти аналогичен PropertyNameFrom. Можно сказать копипэст.
    def PropertyTypeFrom(e as Expression):
        declaration = e as TryCastExpression
        if declaration is not null:
            return declaration.Type
        return null

    # Код проверки корректности AST. 
    def IsValidProperty(property as MacroStatement):
        if len(property.Arguments) != 1: # проверяем, что параметр ровно один (шиза)
            return false
        if not property.Body.IsEmpty: # проверяем, что Body не пусто (не знаю уж что в этом Body)
            return false
        argument = property.Arguments[0] # копируем AST из первого аргумента в переменную argument
        # Если в argument бинарное выражение...
        initializationForm = argument as BinaryExpression
        if initializationForm is not null:
            # ... то убеждаемся, что это оператор присвоения "="
            if initializationForm.Operator != BinaryOperatorType.Assign:
                return false
            # проверяем левую часть выражения...
            return IsValidPropertyDeclaration(initializationForm.Left)
        # если это не оператор присвоения, проверяем аргумент...
        return IsValidPropertyDeclaration(argument)

    def IsValidPropertyDeclaration(e as Expression):
        # если выражение "e" - это ссылка на имя...
        if e.NodeType == NodeType.ReferenceExpression:
            return true # проверка успешна.
        # иначе, "e" - это операция приведения типа?
        declaration = e as TryCastExpression 
        if declaration is null: return false # если нет, то неудача.
        # если да, то убеждаемся что у правая часть (т.е. у "x" в "x as y") 
        # имеет тип ссылка на имя. Тогда успех.
        return declaration.Target.NodeType == NodeType.ReferenceExpression

// параметры передаются в явном виде. Нам не надо их вынимать с помощью Property.Arguments[0].
// В argument уже нужный нам AST. Количество параметров так же проверять не нужно.
macro Property(typeBuilder : TypeBuilder, argument)
{
  // Для декомпозиции выражения используем паттерн-матчинг:
  match (argument)
  {
    // Паттерн ниже разбирает ситуацию "x = y", т.е. когда тип не задан. 
    // При этом propertyType помещается плэйсхолдер "_" означающий - "любой тип".
    | <[ $(propName : name) = $initializer ]> with propertyType = <[ _ ]>
    // Следующий паттерн разбирает ситуацию когда тип задан (т.е. "x : t = y").
    | <[ $(propName : name) : $propertyType = $initializer ]> 
    // аналогично, два паттерна для случаев когда не задано инициализирующее выражение и тип
    | <[ $(propName : name) : $propertyType ]> with initializer = null 
    | <[ $(propName : name) ]> with (initializer = null, propertyType = <[ _ ]>) =>
      def field    = 
        if (initializer == null)
          // мы можем использовать любые имена, так как макро-система немерла поддерживает 
          // гигиеничность. Это значит что имена из квази-цитат ни с чем не пересекутся 
          // и нам на надо их генерировать в ручную (как в Буу).
          <[ decl: backField : $propertyType; ]>
        else
          <[ decl: backField : $propertyType = $initializer; ]>;

      def property = <[ decl:
                        public $(propName : name) : $propertyType 
                        {
                          get { $backField }
                          set { $backField = value }
                        }
                     ]>;
      // Мы использували квази-цитаты для объявления отдельных членов, а не целого класса,
      // так что остается только добавить их в текущий класс.
      typeBuilder.Add(field);
      typeBuilder.Add(property);

    | _ => Message.FatalError("property <name> [: type] [= initialValue]")
  }
}

//@nbuild:project.nbp

using System.Text

using Nemerle.Compiler
using Nemerle.Compiler.Parsetree


namespace Ukma.Macros

        // этот атрибут необходим для Немерле 1, ведь у него есть несколько видов макросов, несколько стадий раскрытия и так далее
    [Nemerle.MacroUsage (Nemerle.MacroPhase.BeforeInheritance,
                       Nemerle.MacroTargets.Field,
                       Inherited = false, AllowMultiple = true)] \
    macro EventAccessor (current_type : TypeBuilder, storage_field : ParsedField, params args : list [PExpr])


        def (name, flags) =
            match (args) 
                | [ <[ $n ]>, <[ $("flags" : dyn) = $opts ]> ] => // матч, списки и квазицитаты требуют
                                                                                  // некого понимания, но очень удобны
                    (Some (n), Some (opts))
                | [ <[ $("flags" : dyn) = $opts ]> ] => 
                    (None (), Some (opts))
                | [ <[ $n ]> ] => 
                    (Some (n), None ())
                | [] => 
                    (None (), None ())
                | _ => 
                    Message.FatalError ("usage: EventAccessor (name, flags = SOMEFLAGS), "
                                      "where both name and flags are optional")
        

        // __some_foo__bar ==> SomeFooBar; заметьте, что я не создаю отдельный класс для вспомогательных методов
        def transformed_name = 
            def sb = StringBuilder ()
            mutable next_upper = true
            foreach (ch in storage_field.Name)
                if (ch == '_')
                    next_upper = true
                else if (next_upper)
                    _ = sb.Append (char.ToUpper (ch))
                    next_upper = false
                else
                    _ = sb.Append (ch)
            sb.ToString ()

        
        def name = name.WithDefault (transformed_name)
        def want_static = storage_field.Attributes %&& NemerleAttributes.Static

        
        def fieldref = <[ $(storage_field.PName : name) ]>

        def eventName = name + "Changed"
        def onEventName = "On" + eventName
        
        def evnt = // ха-ха, попробуйте так в Boo :-)
                <[ decl:
                  public event $(eventName : dyn) : System.EventHandler;
                ]>
        def sender = <[ this ]>
        def onEvent = 
                <[ decl:                
                  protected virtual $(onEventName : dyn)() : void
                  {
                    def x = $(eventName : dyn);
                    when (x != null) x($sender, System.EventArgs.Empty);
                  }
                ]>
        
        def prop = 
                <[ decl:
                  public $(name : dyn) : $(storage_field.ty)
                  {
                    set 
                        { 
                            when ($fieldref != value) 
                            {
                                $fieldref = value; 
                                $(onEventName : dyn)();
                            }
                        }
                    get { $fieldref }
                  }
                ]>
                  
                
        storage_field.Attributes |= NemerleAttributes.Mutable
                  
        // код установки других атрибутов удален
        
        current_type.Define (evnt)
        current_type.Define (onEvent)
        current_type.Define (prop)

C>>    macro EventAccessor (current_type : TypeBuilder, storage_field : ParsedField, params args : list [PExpr])
C>>        def (name, flags) =
C>>            match (args) 
C>>                | [ <[ $n ]>, <[ $("flags" : dyn) = $opts ]> ] => // матч, списки и квазицитаты требуют
C>>                                                                                  // некого понимания, но очень удобны
C>>                    (Some (n), Some (opts))
C>>                | [ <[ $("flags" : dyn) = $opts ]> ] => 
C>>                    (None (), Some (opts))
C>>                | [ <[ $n ]> ] => 
C>>                    (Some (n), None ())
C>>                | [] => 
C>>                    (None (), None ())
C>>                | _ => 
C>>                    Message.FatalError ("usage: EventAccessor (name, flags = SOMEFLAGS), "
C>>                                      "where both name and flags are optional")
C>>

А>Писать может быть и приятнее, но вот читать... например никак не могу сообразить при каких входных данных будет выдаваться FatalError

def (name, flags) = match (args) 
{
    | [ name, <[ $("flags" : dyn) = $opts ]> ] => (Some(name), Some(opts))
    | [       <[ $("flags" : dyn) = $opts ]> ] => (None (),    Some(opts))
    | [ name ]                                 => (Some(name), None())
    | []                                       => (None(),     None())
    | _ => Message.FatalError("usage: EventAccessor (name, flags = SOMEFLAGS), "
                          "where both name and flags are optional")
};