// Переименовал - ИМХО, нет  необходимости в сокращениях
  [DependencyProperty(Metadata = FrameworkPropertyMetadata("a", (d, e) => { }, (d, b) => b))]
  public DependencyProperty1 : string { get { } set { } }

  // ReadOnly задаётся отдельно через параметр, а не выводится, 
  // как я ранее предлагал из спецификаторов видимости,
  // ибо только путает. (1*)
  // Теперь так: Access Modifier на свойстве имеет право быть любым, хоть пропущенным,
  // модификаторы на акессорах не допускаются
  // В случае наличия параметра IsReadOnly: set-акессор будет private
  // Можно задавать так: просто IsReadOnly или IsReadOnly = true|false (2*)
  [DependencyProperty(IsReadOnly)]
  public DependencyProperty2 : string { get { } set { } }

  // Attached-свойства объявляются как Get- методы без тела,
  // имя должно начинаться с "Get" - это хоть и договорённость, 
  // но достаточно общепринятая, что бы быть захардкоженой :о)
  // Соответственно, параметр должен быть строго один (3*)
  // Макросом добавляется соответствующий set-метод, его видимость или такая же, 
  // как у Get или private, если макросу сказано IsReadOnly
  [DependencyProperty(IsReadOnly, ValidateCallback = value => value > 0)]
  internal static GetDependencyProperty3(_ : DependencyObject) : int;

  // Имя параметра можно или опустить, как показано в примере выше (4*), или указать явно
  [DependencyProperty]
  public static GetDependencyProperty4(item : DependencyObject) : int;

using Nemerle;
using Nemerle.Collections;
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;
using Nemerle.Compiler.Typedtree;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Windows;

namespace Nemerle.WPF
{
  [MacroUsage(MacroPhase.BeforeInheritance, MacroTargets.Property, Inherited = false, AllowMultiple = false)]
  public macro DependencyProperty(typeBuilder : TypeBuilder, property : ParsedProperty, params options : list[PExpr]) {
    DependencyPropertyImpl.Implement(typeBuilder, property, options);
  }

  [MacroUsage(MacroPhase.BeforeInheritance, MacroTargets.Method, Inherited = false, AllowMultiple = false)]
  public macro DependencyProperty(typeBuilder : TypeBuilder, method : ParsedMethod, params options : list[PExpr]) {
    DependencyPropertyImpl.Implement(typeBuilder, method, options);
  }

  internal module DependencyPropertyImpl
  {
    private PropertyFieldName(propertyName : string) : string {
      propertyName + "Property";
    }

    private PropertyKeyFieldName(propertyName : string) : string {
      propertyName + "PropertyKey";
    }

    private PropertyFieldName(propertyName : string, readOnly : bool) : string {
      if(readOnly) {
        PropertyKeyFieldName(propertyName)
      } else {
        PropertyFieldName(propertyName)
      }//if
    }

    private GetOptions(propertyType : PExpr, options : list[PExpr]) : PExpr * PExpr * bool {
      def check(item, value) { // Check, that option specified once
        match(value) {
          | null => item;
          | _ => Message.Error(item.Location, $"Duplicated option: \"$item\"."); null;
        }//match
      }

      mutable metadata, validate, isReadOnly;
      foreach(item in options) {
        | <[ Metadata = $value ]> => metadata = check(value, metadata)
        | <[ ValidateCallback = $value ]> => validate = check(<[ System.Windows.ValidateValueCallback(value => $value(value :> $propertyType)) ]>, validate)
        | <[ IsReadOnly = $value ]> => match(value) {
           | <[ true ]> | <[ false ]> => isReadOnly = check(value, isReadOnly)
           | _ => Message.Error(value.Location, $"Unsupported expression: \"$(value)\". Boolean expected.");
          }//match
        | <[ IsReadOnly ]> => isReadOnly = check(<[ true ]>, isReadOnly)
        | _ => Message.Error(item.Location, $"Invalid option: \"$item\".")
      }//for

      def readOnly = match(isReadOnly) {
        | <[ true ]> => true
        | _ => /* false, null */ false
      }//match

      (metadata ?? <[ System.Windows.PropertyMetadata() ]>, validate ?? <[ null ]>, readOnly)
    }

    private DeclareFields(typeBuilder : TypeBuilder, propertyName : string, propertyType : PExpr, access : NemerleAttributes, options : list[PExpr]) : bool {
      def (metadata, validate, readOnly) = GetOptions(propertyType, options);
      def args = [<[ $(propertyName : string) ]>, <[ typeof($propertyType) ]>, <[ typeof($(typeBuilder.ParsedTypeName)) ]>, metadata, validate];
      def name = PropertyFieldName(propertyName);
      def define(property) {
        property.Attributes |= access & NemerleAttributes.AccessModifiers;
        typeBuilder.Define(property);
      }
      if(readOnly) {
        def nameKey = PropertyKeyFieldName(propertyName);
        typeBuilder.Define(<[decl:
          private static $(nameKey : dyn) : DependencyPropertyKey = DependencyProperty.RegisterReadOnly(..$args);
        ]>);
        define(<[decl:
          static $(name : dyn) : DependencyProperty = $(nameKey : dyn).DependencyProperty;
        ]>)
      } else {
        define(<[decl:
          static $(name : dyn) : DependencyProperty = DependencyProperty.Register(..$args);
        ]>)
      }//if
      readOnly
    }

    private MakeGetValue(@this : PExpr, propertyName : string, propertyType : PExpr) : PExpr {
      def name = PropertyFieldName(propertyName);
      <[ $(@this).GetValue($(name : dyn)) :> $propertyType ]>;
    }

    private MakeSetValue(@this : PExpr, propertyName : string, readOnly : bool) : PExpr {
      def name = PropertyFieldName(propertyName, readOnly);
      <[ $(@this).SetValue($(name : dyn), $("value" : dyn)) ]>
    }

    private GetSetterAccessModifiers(readOnly : bool, getterAccessModifiers : NemerleAttributes) : NemerleAttributes {
      match(readOnly) {
        | true => NemerleAttributes.Private
        | _ => getterAccessModifiers & NemerleAttributes.AccessModifiers
      }//match
    }

    private CheckArgumentNull(argument : PExpr) : PExpr {
      <[
        when($(argument) == null) {
          throw ArgumentNullException();
        }//when
      ]>
    }

    public Implement(typeBuilder : TypeBuilder, property : ClassMember.Property, options : list[PExpr]) : void {
      def redundant = property.Attributes & ~NemerleAttributes.AccessModifiers;
      when(redundant != 0) {
        Message.Error(property.Location, $"Unsupported dependency property attributes: \"$redundant\". Only access modifiers allowed.");
      }//when

      def propertyType = property.prop_ty;

      def accessor(accessor) {
        | Some(fn) => fn
        | _ => Message.Error(property.Location, "Both getter and setter should be specified for dependency property."); null
      }
      def getter = accessor(property.get);
      def setter = accessor(property.set);

      def checkAccessorAttributes(accessor) {
        when(accessor.Attributes %&& NemerleAttributes.AccessModifiers) {
          Message.Error(accessor.Location, "Property accessors can not contains access modifiers.")
        }//when
      }
      checkAccessorAttributes(getter);
      checkAccessorAttributes(setter);
      def propertyAccess = property.Attributes & NemerleAttributes.AccessModifiers;

      def readOnly = DeclareFields(typeBuilder, property.Name, propertyType, propertyAccess, options);
      getter.Body = MakeGetValue(<[ this ]>, property.Name, propertyType);
      setter.Attributes |= GetSetterAccessModifiers(readOnly, propertyAccess);
      setter.Body = MakeSetValue(<[ this ]>, property.Name, readOnly);
    }

    public Implement(typeBuilder : TypeBuilder, method : ClassMember.Function, options : list[PExpr]) : void {
      when(!(method.Attributes %&& NemerleAttributes.Static)) {
        Message.Error(method.Location, "Attached property method should be static.");
      }//when

      def redundant = method.Attributes & ~(NemerleAttributes.AccessModifiers | NemerleAttributes.Static);
      when(redundant != 0) {
        Message.Error(method.Location, $"Unsupported dependency property attributes: \"$redundant\". Only access modifiers and $(NemerleAttributes.Static) allowed.");
      }//when

      def GetMethodPrefix = "Get";
      def SetMethodPrefix = "Set";

      def getterName = method.Name;
      when(String.IsNullOrEmpty(getterName) || getterName.Length <= GetMethodPrefix.Length || !getterName.StartsWith(GetMethodPrefix)) {
        Message.Error(method.Location, "Dependency property name should be 'Get<DependencyPropertyName>'.");
      }//when

      def parameters = method.header.Parameters;
      when(parameters.Length != 1) {
        Message.Error(method.Location, "Attached property method should have exactly one parameter of type 'DependencyObject' or derived.");
      }//when
      def parameter = parameters.Head;

      def propertyName = getterName.Substring(GetMethodPrefix.Length);
      def setterName = SetMethodPrefix + propertyName;
      def propertyType = method.header.ReturnType;

      def parameterName = parameter.Name;
      def parameterType = parameter.Type;
      def propertyAccess = method.Attributes & NemerleAttributes.AccessModifiers;

      def readOnly = DeclareFields(typeBuilder, propertyName, propertyType, propertyAccess, options);

      method.Body = <[
        $(CheckArgumentNull(<[ $(parameterName : dyn) ]>));
        $(MakeGetValue(<[ $(parameterName : dyn) ]>, propertyName, propertyType));
      ]>;

      def setter = <[decl:
        static $(setterName : dyn)($(parameterName : dyn) : $(parameterType), value : $(propertyType)) : void {
          $(CheckArgumentNull(<[ $(parameterName : dyn) ]>));
          $(MakeSetValue(<[ $(parameterName : dyn) ]>, propertyName, readOnly));
        }
      ]>;
      setter.Attributes |= GetSetterAccessModifiers(readOnly, propertyAccess);
      typeBuilder.Define(setter);
    }
  }
}

_FR>    private CheckArgumentNull(argument : PExpr) : PExpr {
_FR>      <[
_FR>        when($(argument) == null) {
_FR>          throw ArgumentNullException(/* !!! */);
_FR>        }//when
_FR>      ]>
_FR>    }

_FR>>    private CheckArgumentNull(argument : PExpr) : PExpr {
_FR>>      <[
_FR>>        when($(argument) == null) {
_FR>>          throw ArgumentNullException(/* !!! */);
_FR>>        }//when
_FR>>      ]>
_FR>>    }
_FR>

_FR>Как тут вывести имя аргумента (видимо, argument.ToString())? Эх, "интуитивно" не удалось, надо браться за раздаточный материал

using Nemerle.Assertions;

...

Foo([NotNull] x : object) : void {
}

Foo(x : int) : void
    requires x > 0      // перед выполнением тела
{
...
}

mutable x : int = ... ;

Foo(i : int) : void
    enshures x < 100    // после выполнения тела
{
  x += i
}

typer.BindFixedType(pExpr)

typer.TypeExpr(pExpr)

_FR>И прочее — есть ли в каком виде документ по принятому оформлению (кроме исходников компилятора ?)

[DependencyProperty(IsReadOnly = (3 < 5))]
public DependencyProperty2 : string { get { } set { } }

      mutable metadata, validate, isReadOnly;
      foreach(item in options) {
        | …
        | <[ IsReadOnly = $value ]> => … // Вот здесь "value" имеет тип PExpr, требуется узнать тип выражения
        | …
      }//for

VD>typer.TypeExpr(pExpr)

[DependencyProperty]
public static GetDependencyProperty3(_ : DependencyObject) : int;

      def parameters = method.header.Parameters;
      when(parameters.Length != 1) {
        Message.Error(method.Location, "Attached property method should have exactly one parameter of type 'DependencyObject' or derived.");
      }//when
      def parameter = parameters.Head;

      Message.Hint($"parameter.Name = $(parameter.Name).");
      Message.Hint($"parameter.IsGenerated = $(parameter.IsGenerated).");
      Message.Hint($"parameter.Location.IsGenerated = $(parameter.Location.IsGenerated).");
      Message.Hint($"parameter.Location.IsGeneratedOrEmpty = $(parameter.Location.IsGeneratedOrEmpty).");
      Message.Hint($"parameter.NameLocation.IsGenerated = $(parameter.NameLocation.IsGenerated).");
      Message.Hint($"parameter.NameLocation.IsGeneratedOrEmpty = $(parameter.NameLocation.IsGeneratedOrEmpty).");
      Message.Hint($"parameter.PName.IsGenerated = $(parameter.PName.IsGenerated).");
      Message.Hint($"parameter.PName.Location.IsGenerated = $(parameter.PName.Location.IsGenerated).");
      Message.Hint($"parameter.PName.Location.IsGeneratedOrEmpty = $(parameter.PName.Location.IsGeneratedOrEmpty).");

Warning: hint: parameter.Name = _N_wildcard_2775.
Warning: hint: parameter.IsGenerated = False.
Warning: hint: parameter.Location.IsGenerated = False.
Warning: hint: parameter.Location.IsGeneratedOrEmpty = False.
Warning: hint: parameter.NameLocation.IsGenerated = False.
Warning: hint: parameter.NameLocation.IsGeneratedOrEmpty = False.
Warning: hint: parameter.PName.IsGenerated = False.
Warning: hint: parameter.PName.Location.IsGenerated = False.
Warning: hint: parameter.PName.Location.IsGeneratedOrEmpty = False.

using Nemerle;
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;


  [MacroUsage(MacroPhase.BeforeInheritance, MacroTargets.Method)]
  public macro Macro1(tb : TypeBuilder, m : ParsedMethod)
  {
    Impl.DoWork(tb, m)
  }
  
  
  module Impl {
  
    public DoWork(_ : TypeBuilder, m : ClassMember.Function) : void {
      match(m.header.Parameters) {
        | single :: [] when single.PName.ParcedId == "_" =>
          Message.Hint("Automatic wildecard rename.");
          m.header.Parameters = PParameter(Splicable.Name(Name("value", single.PName.Location, single.PName.color, single.PName.context)), single.modifiers, single.ParsedType) :: [];

        | single :: [] =>
          Message.Hint($"Single parameter $single found no need to rename.");

        | _ => 
          Message.FatalError("Single parameter required.");
      }
    }
  
  }

  [MacroLibrary1.Macro1]
  Foo(_ : string) : void { WriteLine(value) }

_ = System.Diagnostics.Debugger.Launch();

<PropertyType> Get<PropertyName>(DependencyObject+ obj);
Set<PropertyName>(DependencyObject+ obj, <PropertyType> value);

class WatermarkService
{
  public static object GetWatermark(TextBox obj) { }
  public static SetWatermark(TextBox obj, object value) { }
}

class RadioButtonListBoxExtensions
{
  public static object GetItemValue(FrameworkElement obj) { }
  public static SetItemValue(FrameworkElement obj, object value) { }
}

1. Параметры свойства будут нагляднее — их не будут заменять никакие элементы языка.
   
2. Не будет хаков по части объявления attached свойств.
   
3. Не потребуется специальный макрос для AddOwner.
   
4. Макрос перестанет зависеть от параметров конструктора DependencyProperty. Разве что только по части типа значения свойства.