class x   
  REF n : List[x]

 match (e)   
        | <[ $(name : name) : $type ]> => 
          fld_name = name
          fld_type = type
        | _ =>  Message.Error(expr.Location, <#Expected: name : type #>)

$refer = $fld_type();

def fld_type_create = MainParser.ParseExpr(typeBuilder.GlobalEnv, $"$(fld_type.ToString())()", false);
//и так пробовал
def fld_type_create = MainParser.ParseExpr(typeBuilder.GlobalEnv, $"$(fld_type.ToString())", false);

$refer = $fld_type_create;

class x   
  REF n : List.[x]

  [MacroUsage(MacroPhase.BeforeInheritance, MacroTargets.Method)]\
  macro REF(typeBuilder : TypeBuilder, _ : ClassMember.Function, expr : PExpr)\
  syntax ("REF", expr)
  
    FieldFormer(typeBuilder, expr).proccessREF()

_C_>  REF n : List[x] 
_C_>

_C_> match (e)   
_C_>        | <[ $(name : name) : $type ]> => 
_C_>          fld_type = type
_C_>

_C_>$refer = $fld_type();
_C_>

match (e)   
  | <[ $(name : name) : $type ]> => 
      def typerType = typer.BindFixedType(type);
      match (typerType)
      {
        | Class(typeInfo, typeArgs) =>
          def hasCtor = 
            typeInfo.IsValueType
            || typeInfo.LookupMember(".ctor")
                       .OfType.[IMethod]()
                       .Where(ctor => ctor.Header.Parameters.IsEmpty && ctor.CanAccess(typer.CurrentType))
                       .Any();
          if (hasCtor)
          {
            def typedTypeArgs = typeArgs.Map(tv => <[ $(tv : typed) ]>);
            _ = <[ $(PExpr.FromQualifiedIdentifier(typer.Manager, typeInfo.FullName)).[..$typedTypeArgs](); ]>;
            // ...
          }
          else
            Message.FatalError(type.Location, $"Type '$typeInfo' has no default constructor.");

        // для остальных типов реализуй обработку по необходимости...
        | Array
        | Fun
        | Tuple
        | Tuple
        | Intersection
        | Out
        | Ref
        | StaticTypeVarRef
        | Void => Message.FatalError(type.Location, $"Unsupported type: '$typeInfo'.");
      }

_C_>def fld_type_create = MainParser.ParseExpr(typeBuilder.GlobalEnv, $"$(fld_type.ToString())()", false);
_C_>//и так пробовал
_C_>def fld_type_create = MainParser.ParseExpr(typeBuilder.GlobalEnv, $"$(fld_type.ToString())", false);
_C_>

VD>Ну, ты лихой товарищ!

def block = <[decl:      
        partial class $name
        {   public static convert_up(datamap: datamap_file, arr: array[exchange_struct], 
              delta:int): IEnumerable[$name]
            /*метод получения множества классов из плоского массива в базе
              delta - смещение мем-блока arr   */ 
            { empty_exchange = exchange_struct();
                            
              size_exchange_struct = memblock.size_type(exchange_struct);
                            
              ...
            }
            //преобразование произвольного IEnumerable[X] в массив его структур для записи в базу
            public static to_array(datamap_:datamap_file, seq: IEnumerable[$name])
            {                
                lst = List();
                ...
            }
            ...

[assembly: SerializeMap(DateTyme(Ticks))]

_C_>def block = <[decl:      
_C_>        partial class $name
_C_>        {   public static convert_up(datamap: datamap_file, arr: array[exchange_struct], 
_C_>              delta:int): IEnumerable[$name]
_C_>            /*метод получения множества классов из плоского массива в базе
_C_>              delta - смещение мем-блока arr   */ 
_C_>            { empty_exchange = exchange_struct();
_C_>              size_exchange_struct = memblock.size_type(exchange_struct);
_C_>              ...
_C_>            }
_C_>            //преобразование произвольного IEnumerable[X] в массив его структур для записи в базу
_C_>            public static to_array(datamap_:datamap_file, seq: IEnumerable[$name])
_C_>            {                
_C_>                lst = List();
_C_>                ...
_C_>            }
_C_>            ...
_C_>

    private str2expr(name : string): PExpr
    /*генерация PExpr для составных имен*/
      PExpr.FromQualifiedIdentifier((Manager,name))

    public yyy(): void 
      def name = expr("xxx")
      
      def block = <[decl:      
        partial class $name //не проходит
        {   public static convert_up(datamap: datamap_file, arr: array[exchange_struct],

      def cname = "xxx"
      
      def block = <[decl:      
        partial class $(cname: dyn) //проходит

       <[
        class dummy
        {   static empty_exchange : exchange_struct;
            static size_exchange_struct : int = memblock.size_type(typeof(exchange_struct));
            
            public static convert_up(datamap: datamap_file, arr: array[exchange_struct], mutable delta:int): Seq[$name]
            
            //сбой при генерации этого метода
            { 
              foreach(st in arr)
              {                                
                yield if (st != empty_exchange) $name(datamap, st, delta) else null;                                                     
                delta += size_exchange_struct;
              }           
            }

namespace DBLib
  
  [MacroUsage(MacroPhase.BeforeTypedMembers, MacroTargets.Class)]\
  macro Persist(typeBuilder : TypeBuilder)
  
    ClassFormer(typeBuilder)

  [ManagerAccess(ManagerClass.Instance)]\
  class ClassFormer
    typeBuilder :TypeBuilder
    
    private str2expr(name : string): PExpr
    /*генерация PExpr для составных имен*/
      PExpr.FromQualifiedIdentifier((Manager,name))
    
    public this(tb : TypeBuilder)      
      typeBuilder = tb
      
      def name = str2expr("x")
            
      def block = <[decl:      
        class dummy
        {   static empty_exchange : exchange_struct;
            static size_exchange_struct : int = memblock.size_type(typeof(exchange_struct));
            
            public static convert_up(datamap: datamap_file, arr: array[exchange_struct], mutable delta:int): Seq[$name]
            /*метод получения множества классов из плоского массива в базе
              delta - смещение мем-блока arr   */ 
            { 
              foreach(st in arr)
              { 
                when (st != empty_exchange) yield null                
                
              }           
            }
          }
         ]>

using DBLib

[Persist]\
partial class x 
  public struct exchange_struct
    i : int

foreach(member in block.td.GetMembers())
        tb.DefineWithSource(member)

[ManagerAccess(ManagerClass.Instance)]\
  class ClassFormer
    typeBuilder :TypeBuilder
    
    private str2expr(name : string): PExpr
    /*генерация PExpr для составных имен*/
      PExpr.FromQualifiedIdentifier((Manager,name))
    
    public this(tb : TypeBuilder)      
      typeBuilder = tb
      
      def name = str2expr("x")
      
      def save_block = tb.UserData["str_saves"] :> list[PExpr] ?? []
      
      //typeBuilder.GetMemType()
      
      def block = <[decl:      
        class dummy /*для копирования из него членов и методов*/
        {               
            static size_exchange_struct : int = memblock.size_type(typeof(exchange_struct));
            
            public static convert_up(datamap: datamap_file, arr: array[exchange_struct], mutable delta:int): array[$name]
            /*метод получения множества классов из плоского массива в базе, delta - смещение мем-блока в arr */ 
            { 
              mutable count = 0;              
              def result = array(arr.Length);
              
              foreach( st in arr)
              { 
                result[count] = if (st._null) null else $(tb.ParsedTypeName)();//(datamap, st, delta);                   
                delta += size_exchange_struct;                
                ++count;
              }
              result
            }
            //преобразование произвольного IEnumerable[X] в массив его структур для записи в базу
            public static to_array(datamap:datamap_file, seq: Seq[$name]) : array[exchange_struct]
            {                
                def lst = List();
                                    
                foreach (o in seq)
                  if (o != null)
                  {   
                    o.datamap = datamap;                                    
                    o.save_strings()    ;                                
                    lst.Add(o._exchange) ;
                  }
                  else
                  { def st = exchange_struct();
                    st._null = true;
                    lst.Add(st);
                  }              
                lst.ToArray();
             }
                            
            //загрузка одного объекта, на который может быть много ссылок    
            public static load(datamap:datamap_file, delta:int): $name
            {                
                mutable obj;                           
                unless (delta == 0 || datamap.map_objects.TryGetValue(delta, out obj))                     
                {
                  obj = $(tb.ParsedTypeName)();//(datamap, delta)     ;                       
                  datamap.map_objects[delta] = obj;
                }            
                obj
              }           
            //метод для считывая объекта из базы. может понабиться при отмене изменений
            //public force_load(replace:bool): $name 
            //{ 
            //    def new_val = $(tb.ParsedTypeName)(datamap, datamap.load.[exchange_struct](address), address);
                
            //    when (replace)
            //      datamap.map_objects[address] = new_val;                
            //    new_val
            //}                
            public save_null(): void
            //метит в массиве как null
            { _exchange._null = true;
              when (address != 0)
                save();     
            }
            //сохраняет все строки объекта
            public save_strings(): void
            {                
               ..$save_block
            }            
            //сохраняет объект                        
            public save(): void
            {                
                save_strings();                            
                datamap.write(_exchange, ref address);
            }                        
            //файл базы, откуда объект
            //одновременно можно работать с несколькими базами                        
            public mutable datamap: datamap_file;                        
            //смещение в базе                        
            public mutable address: int;
            
            //объявление типа структуры                                                            
            public this() {}
                                            
            public this(dmap:datamap_file)
            {                
                datamap = dmap
            }                
            public this(dmap:datamap_file, addr:int)
            {                
                datamap = dmap;                            
                address = addr;                            
                _exchange = datamap.load.[exchange_struct](address);
            }                            
            public this(dmap:datamap_file, data_class:exchange_struct, addr:int)
            {                
                datamap = dmap;                            
                _exchange = data_class;                            
                address = addr;
            }           
          } ]> 
    
      foreach(member in block.td.GetMembers())
        tb.DefineWithSource(member)

           public static load(datamap:datamap_file, delta:int): $name
            {                
                mutable obj;                           
                unless (delta == 0 || datamap.map_objects.TryGetValue(delta, out obj))                     
                {
                  obj = $(tb.ParsedTypeName)();//(datamap, delta)     ;                       
                  datamap.map_objects[delta] = obj;
                }            
                obj :> $name //вместо obj
              }

  Test() : int // сообщение будет выдано на "int"
  {
    null
  }

error : expected int, got object+ in function body: the `null' literal is not a valid value of type int

_C_>      def name = str2expr("x")

_C_>            //загрузка одного объекта, на который может быть много ссылок    
_C_>            public static load(datamap:datamap_file, delta:int): $name
_C_>            {                
_C_>                mutable obj;
_C_>                unless (delta == 0 || datamap.map_objects.TryGetValue(delta, out obj))                     
_C_>                {
_C_>                  obj = $(tb.ParsedTypeName)();//(datamap, delta)     ;                       
_C_>                  datamap.map_objects[delta] = obj;
_C_>                }            
_C_>                obj
_C_>              }

obj :> $name