public ForAllMethods(this typer : Typer, changeBoby : PExpr -> PExpr): void
        {
            def types = typer.Manager.NameTree.NamespaceTree.GetTypeBuilders(onlyTopDeclarations=false);
            
            def bindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance |
                                BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

            foreach (method is MethodBuilder in types.SelectMany(_.GetMembers(bindingFlags)))
                method.Body = changeBoby(<[ $(method.Body) : $(method.ReturnType : typed) ]>) <- { Location = method.Body.Location };
        }
        
        public HintIssues(this typer : Typer, body : PExpr, getIssues: PExpr -> IEnumerable[string]) : PExpr
        {
            typer.TransformWhenAllTypesWouldBeInfered(
                (pexpr, _) =>
                    {
                        ExprWalker().Walk(pexpr,info =>
                            {
                                match(info.Node)
                                {
                                    | node is PExpr =>
                                        foreach(issue in getIssues(node))
                                            Message.Hint(node.Location, issue);
                                    | _ => ()
                                }
                            });
                        pexpr
                    },
                typer.TypeExpr(body), body);
        }

    macro CheckCountAny(body : PExpr)
    syntax ("checkCountAny", body) 
    {
        CheckCountAnyImpl.DoTransform(Macros.ImplicitCTX(), body)
    }
    
    module CheckCountAnyImpl
    {
        public DoTransform(typer : Typer, body : PExpr) : PExpr
        {
            Macros.DefineCTX(typer);
            
            def enumType = <[ ttype: System.Collections.Generic.IEnumerable[_] ]>;
            
            typer.HintIssues(body, node => 
                comp enumerable
                {
                    match(node)
                    {
                        | <[ $o.Count() > 0 ]>
                        | <[ 0 < $o.Count() ]>
                        | <[ $o.Count() >= 1 ]>
                        | <[ 1 <= $o.Count() ]> =>
                            when(typer.TypeExpr(o).FixedType().TryRequire(enumType))
                                yield $"Change '$node' to '$o.Any()' to avoid possible enumeration of entire sequence.";
                        | _ => ()
                    }
                });
        }
    }

    [MacroUsage(MacroPhase.WithTypedMembers, MacroTargets.Assembly)]
    macro CheckCountAny()
    {
        CheckCountAnyImpl.DoTransform(Macros.ImplicitCTX())
    }

    module CheckCountAnyImpl
    {
        public DoTransform(typer : Typer) : void
        {
            Macros.DefineCTX(typer);
            
            typer.ForAllMethods(body => <[ CheckCountAny($body) ]>);
        }
    }

using CheckCountAnyMacro;

[assembly: CheckCountAny]

class A
{
    public Count():int {42}
}

class B : IEnumerable[int]
{
    public Count():int {42}
    public GetEnumerator() : IEnumerator[int] {null}
}

A>                    match(node)
A>                    {
A>                        | <[ $o.Count() > 0 ]>
A>                        | <[ 0 < $o.Count() ]>
A>                        | <[ $o.Count() >= 1 ]>
A>                        | <[ 1 <= $o.Count() ]> =>
A>                            when(typer.TypeExpr(o).FixedType().TryRequire(enumType))
A>                                yield $"Change '$node' to '$o.Any()' to avoid possible enumeration of entire sequence.";
A>

 match(node)
 {
     | <[ $o.Count() > 0 ]>
     | <[ 0 < $o.Count() ]>
     | <[ $o.Count() >= 1 ]>
     | <[ 1 <= $o.Count() ]> =>
         when((node.TypedObject :> TExpr).Type.TryRequire(enumType))
             yield $"Change '$node' to '$o.Any()' to avoid possible enumeration of entire

A>>                    match(node)
A>>                    {
A>>                        | <[ $o.Count() > 0 ]>
A>>                        | <[ 0 < $o.Count() ]>
A>>                        | <[ $o.Count() >= 1 ]>
A>>                        | <[ 1 <= $o.Count() ]> =>
A>>                            when(typer.TypeExpr(o).FixedType().TryRequire(enumType))
A>>                                yield $"Change '$node' to '$o.Any()' to avoid possible enumeration of entire sequence.";
A>>

Обратившись к свойству PExpr.TypedObject. Оно заполняется компилятором в процессе типизации. Это свойство имеет тип object, так как в него могут помещаться объекты разного типа (например, типизированное представление параметра или типизированное выражение), но в подавляющем большинстве случаев в него помещается ссылка на соответствующий TExpr (т.е. на соответствующее типизированное AST). Учтите, что значение свойства TypedObject доступно только после того, как PExpr (напрямую или в составе другого PExpr) будет типизирован методом Typer.TypeExpr().

[IssueMacro]//или что-нибудь такое
macro CheckCountAny(typer : Typer, expr : PExpr): IEnumerable[string * LazyValue[PExpr]]
{
  //...
}

match(node)
{
    | <[ $o > 0 ]>
    | <[ 0 < $o ]>
    | <[ $o >= 1 ]>
    | <[ 1 <= $o ]> =>
        match(o.TypedObject)
        {
            | countCall is TExpr.Call when /*ЧТО ТУТ ДОЛЖНО БЫТЬ?*/ =>
                yield $"Change '$node' to '$o.Any()' to avoid possible enumeration of entire..."
            | _ => ()
        }
    | _ => ()
};

A>match(node)
A>{
A>    | <[ $o > 0 ]>
A>    | <[ 0 < $o ]>
A>    | <[ $o >= 1 ]>
A>    | <[ 1 <= $o ]> =>
A>        match(o.TypedObject)
A>        {
A>            | countCall is TExpr.Call when /*ЧТО ТУТ ДОЛЖНО БЫТЬ?*/ =>
A>                yield $"Change '$node' to '$o.Any()' to avoid possible enumeration of entire..."
A>            | _ => ()
A>        }
A>    | _ => ()
A>};
A>

    | <[ 1 <= $o ]> =>
        match(o.TypedObject)
        {
            | TExpr.Call(StaticRef(from, meth is IMethod, typeArgs)) when анализируем meth =>
              ...