WH>ast MyMacro : Expression
WH>syntax "MyMacro" "(" expr ")"
WH>{
WH>    expr : Expression;
WH>}
WH>typing
WH>{
WH>    Dictionary[key, _] = expr.Type;
WH>    Type = (key, key);
WH>}
WH>

typing
{
  def newKeyTypeVar = flesh();
  def newValTypeVar = flesh();

  // требуем чтобы expr.Type был подтипом Dictionary[_, _]
  expr.Type require Dictionary[newKeyTypeVar, newValTypeVar]; 

  // это должно выполнится только когда станет известен тип ключа
  if (newKeyTypeVar.IsValueType)
    newValTypeVar = int;
  else
    newValTypeVar = string;

  Type = newValTypeVar; // под "=" понимается Unify
}
rewrite // переписывание у тебя вообще не паказано, а по условиям задачи одно должно быть
{
  if (newKeyTypeVar.IsValueType) // дублирование проверки!
    <[ 3 ]>
  else
    <[ "a" ]>
}

VD>typing
VD>{
VD>  def newKeyTypeVar = flesh();
VD>  def newValTypeVar = flesh();

VD>  // требуем чтобы expr.Type был подтипом Dictionary[_, _]
VD>  expr.Type require Dictionary[newKeyTypeVar, newValTypeVar]; 

VD>  // это должно выполнится только когда станет известен тип ключа
VD>  if (newKeyTypeVar.IsValueType)
VD>    newValTypeVar = int;
VD>  else
VD>    newValTypeVar = string;

VD>  Type = newValTypeVar; // под "=" понимается Unify
VD>}
VD>rewrite // переписывание у тебя вообще не паказано, а по условиям задачи одно должно быть
VD>{
VD>  if (newKeyTypeVar.IsValueType) // дублирование проверки!
VD>    <[ 3 ]>
VD>  else
VD>    <[ "a" ]>
VD>}
VD>

// для макросов имеющих синтаксис вызова синтаксис описывать не надо. 
// Параметры по умолчанию имеют тип Expression
macro MyMacro(expr) : Expression
  define types: keyTypeVar, valTypeVar; // описываем свежие типы (переменные типов)
  require: expr.Type subtype of Dictionary[keyTypeVar, valTypeVar];
  require: keyTypeVar unify valTypeVar // или keyTypeVar = valTypeVar
  require: keyTypeVar unify int || keyTypeVar unify string else Error("The type of 'expr' mast be string or int.")
{
  if (keyTypeVar.IsValueType) // проверка не дублируется!
    <[ 3 ]>
  else
    <[ "a" ]>
}

Собственно даже linq выиграет от дополнительных проверок. Например, можно проверить если ли у коллекции методы в которые переписывается запрос

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

public macro MyMacro(expr)
{
  Impl.Transorm(Macros.ImplicitCTX(), expr)
}

module Impl
{
  public Transorm(typer : Typer, expr : PExpr) : PExpr
  {
    Macros.DefineCTX(typer);
    def dicType = <[ ttype: System.Collections.Generic.Dictionary[_, _] ]>;
    def typedExpr = typer.TypeExpr(expr);
    def errorMsg = "The expression mast have the Dictionary[int, _] or Dictionary[string, _].";
    
    
    def delayTyping(lastTry : bool) : option[PExpr]
    {
      match (typedExpr.Type.Hint)
      {
        | Some(FixedType.Class(_, [tKey, _]) as type) when tKey.Hint.IsSome => // когда тип и его первый параметр вывелся
          if (type.Require(dicType))
            unless (dicType.args.Head.Unify(dicType.args.Tail.Head))
              Message.Error(expr.Location, "The TKey and TValue of Dictionary type parameters must be same type.");
          else
            Message.Error(expr.Location, errorMsg);
            
          unless (tKey.TryUnify(typer.InternalType.String) || tKey.TryUnify(typer.InternalType.Int32))
            Message.Error(expr.Location, errorMsg);
            
          Some(if (tKey.Fix().IsValueType) <[ 3 ]> else <[ "a" ]>)
          
        | Some(_) | None => 
          when (lastTry)
            Message.Error(expr.Location, errorMsg);

          None()
      }
    }
    typer.DelayMacro(delayTyping, typer.FreshTypeVar())
  }
}

using System.Collections.Generic;
using System.Console;

module Program
{
  Main() : void
  {
    def d1 = Dictionary();
    d1[4] = MyMacro(d1);
    WriteLine(d1.GetType());
    
    def d2 = Dictionary();
    d2["x"] = MyMacro(d2);
    WriteLine(d2.GetType());
  }
}

System.Collections.Generic.Dictionary`2[System.Int32,System.Int32]
System.Collections.Generic.Dictionary`2[System.String,System.String]

syntax ("for", "(", Optional(init), ";", Optional(cond), ";", Optional(change), ")", body)

from x in xs
where x...
select x...

WH>И после этого ты еще говоришь что у меня много кода

macro MyMacro(expr)
  def types: keyType, valTape;
  require: expr :> #Dictionary[keyType, valTape] else Error("The expression mast have the Dictionary[int, _] or Dictionary[string, _].")
  require: keyType unify #int || keyType unify #string;
  require: keyType unify valTape else Error("The TKey and TValue of Dictionary type parameters must be same type.")
{
  if (tKey.IsValueType) <[ 3 ]> else <[ "a" ]>
}