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

namespace MacroTestLib
{
  // Выполняется на фазе BeforeInheritance, так как этот макрос должен изменять список 
  // реализованных интерфейсов.
  [MacroUsage(MacroPhase.BeforeInheritance, MacroTargets.Class)]
  macro Disposable(typeBuilder : TypeBuilder)
  {
    // Добавляем "наследование" IDisposable.
    typeBuilder.AddImplementedInterface(<[ System.IDisposable ]>);
    // Добавляем метод Dispose. Метод помечаем макроатрибутом ImplementDispose.
    // Он "вызовится" позже.
    typeBuilder.Define(<[ decl: [MacroTestLib.ImplementDispose] public Dispose() : void { } ]>);
  }
}

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.Linq;

namespace MacroTestLib
{
  // Макрос работает на фазе WithTypedMembers, так как ему нужна информация о типх членов.
  /// Данный макрос должен применяться к методу Dispose!
  [MacroUsage(MacroPhase.WithTypedMembers, MacroTargets.Method)]
  macro ImplementDispose(typeBuilder : TypeBuilder, method : MethodBuilder)
  {
    ImplementDisposeImpl.DoTransform(Macros.ImplicitCTX(), typeBuilder, method)
  }
  
  module ImplementDisposeImpl
  {
    public DoTransform(typer : Typer, typeBuilder : TypeBuilder, method : MethodBuilder) : void
    {
      Macros.DefineCTX(typer); // это нружно для цитаты <[ ttype: System.IDisposable ]>
      
      // assert2(false);
      
      // Так надо получать описание типа в макросах. Использовать System.Type в макросах нельзя!
      def iDisposableType = <[ ttype: System.IDisposable ]>;
      
      def isMemberTypeImplementIDisposable(member : IMember) : bool
      {
        // Вызвать Dispose() имеет смысл только у полей и свойств определенных в текущем классе. Фильтрум их...
        (member is IProperty || member is IField) 
        // Получаем тип члена и проверям, что он унифицируется с IDisposable. А использовать System.Type в макросах нельзя!
        && member.GetMemType().TryRequire(iDisposableType)
      }
      
      // Получаем все экземплярные поля и свойства типы которых реализуют IDisposable.
      def members = typeBuilder.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Instance 
                                         | BindingFlags.Public       | BindingFlags.NonPublic)
                               .Filter(isMemberTypeImplementIDisposable);
      
      // Преобразуем список членов в список выражений проиводящий обращение к ним и вызвающих от них Dispose().
      // Оператор ?. позволяет защититься от вызова по нулевому указателю.
      def exprs = members.Map(m => <[ (this.$(m.Name :  usesite) : System.IDisposable)?.Dispose() ]>);
      
      // Заменяем тело Dispose-а данного класа. Цитата ..$х раскрывает список выражений.
      method.Body = <[ { ..$exprs } ]>; 
    }
  }
}

using System.Console;
using System.IO;

using MacroTestLib;

[Record]
[Disposable]
class Test
{
  private FileStream : FileStream;
  private Str : string;
  private Reader : TextReader;
}

module Program2
{
  Main() : void
  {
    def x = Test(null, "", null);
    x.Dispose();
  }
}

public void Dispose()
{
    IDisposable fileStream = this.FileStream;
    if (fileStream != null)
    {
        fileStream.Dispose();
    }
    IDisposable reader = this.Reader;
    if (reader != null)
    {
        reader.Dispose();
    }
}