private static IForeachStatement IsYieldForeachPattern(IYieldStatement yieldReturn, IType ienumerableType)
    {
      // detect "yield return $0;" where $0 - reference expression
      var yieldExpression = yieldReturn.Expression as IReferenceExpression;
      if (yieldExpression == null) return null;

      // detect if "yield return $0;" is right inside foreach statement
      var foreachStatement = yieldReturn.Parent as IForeachStatement;
      if (foreachStatement == null)
      {
        // ok, we may be inside single statement block
        var block = yieldReturn.Parent as IBlock;
        if (block == null || block.Statements.Count != 1) return null;

        foreachStatement = block.Parent as IForeachStatement;
        if (foreachStatement == null) return null;
      }

      // detect if $0 resolves into foreach statement iteration variable
      if (foreachStatement.IteratorDeclaration == null) return null;
      var target = foreachStatement.IteratorDeclaration.DeclaredElement;
      var resolved = yieldExpression.Reference.Resolve().DeclaredElement;
      if (!DeclaredElementEqualityComparer.ElementComparer.Equals(target, resolved)) return null;

      // detect the type of foreach statement collection expression
      if (foreachStatement.Collection == null) return null;
      var collectionType = foreachStatement.Collection.Type();
      if (collectionType.IsUnknown) return null;

      // detect if foreach statement collection is convertible into IEnumerable<T>
      var conversionRule = foreachStatement.GetTypeConversionRule();
      if (!conversionRule.IsImplicitlyConvertibleTo(collectionType, ienumerableType)) return null;

      return foreachStatement;
    }

var someNode = node as SomeNode;
if (someNode != null) {
   ...
}

VD>Я, вообще-то, тоже с юмором. Я ж тебя не первый год знаю.

object x = 0;
if (x is int) {
    int y = x + 1;
    Console.WriteLine(y);
}

void Foo(int? x) {
    if (x != null) {
        int y = x + 1; // никаких x.Value
        ...
    }
}

П>object x = 0;
П>if (x is int) {
П>    int y = x + 1;
П>    Console.WriteLine(y);
П>}
П>

П>void Foo(int? x) {
П>    if (x != null) {
П>        int y = x + 1; // никаких x.Value
П>        ...
П>    }
П>}
П>

П>То есть макросом поменять тип некоторой локальной переменной внутри некоторого скоупа. Если такое выражается макросом, то круто вообще!

match (x)
{
  | Some(x) => // "x" переопределен. Теперь это просто int
    def y = x + 1; // никаких x.Value
    ...

  | None => сообщаем об ошибке
}

def a = x.?y.?z + 1;

match (yieldReturn.Parent)
{
  | x is IForeachStatement => ...
  | x is IBlock            => ...
  ...
}

def isYieldForeachPattern(stmt : IStatment)
{
  | IStatment where(Parent=foreachStatement is IForeachStatement)
  | IStatment where(Parent=IBlock where(Statements=st, Parent=foreachStatement is IForeachStatement)) when st.Count == 1 =>
    def target = foreachStatement.IteratorDeclaration.DeclaredElement;
    def resolved = yieldExpression.Reference.Resolve().DeclaredElement;
    unless (DeclaredElementEqualityComparer.ElementComparer.Equals(target, resolved))
      return null;
    unless (foreachStatement?.Collection.Type().IsValid)
      return null;

    // detect if foreach statement collection is convertible into IEnumerable<T>
    def conversionRule = foreachStatement.GetTypeConversionRule();
    if (conversionRule.IsImplicitlyConvertibleTo(collectionType, ienumerableType)) foreachStatement else null

  | _ => null
}

  private static IForeachStatement IsYieldForeachPattern(IYieldStatement yieldReturn, IType ienumerableType)
  {
    comp Maybe
    {
      // detect "yield return $0;" where $0 - reference expression
      defcomp yieldExpression = yieldReturn.Expression maybe IReferenceExpression;

      // detect if "yield return $0;" is right inside foreach statement
      defcomp foreachStatement = yieldReturn.Parent maybe IForeachStatement
      ...
    }
  }

      var yieldExpression = yieldReturn.Expression as IReferenceExpression;
      if (yieldExpression == null) return null;

      // detect if "yield return $0;" is right inside foreach statement
      var foreachStatement = yieldReturn.Parent as IForeachStatement;
      if (foreachStatement == null)
      {
        // ok, we may be inside single statement block
        var block = yieldReturn.Parent as IBlock;
        if (block == null || block.Statements.Count != 1) return null;

        foreachStatement = block.Parent as IForeachStatement;
        if (foreachStatement == null) return null;
      }
      ...

| IStatment where(Parent=foreachStatement is IForeachStatement)
| IStatment where(Parent=IBlock where(Statements=st, Parent=foreachStatement is IForeachStatement)) when st.Count == 1 => ...

[assembly: ExtensionPattern(IStatment,
  ParentForeach(foreachStatement)
  = IStatment where(Parent=foreachStatement is IForeachStatement))]

[assembly: ExtensionPattern(IStatment,
  ParentForeachBlock(foreachStatement, statements)
  = IStatment where(Parent=IBlock where(Statements=statements, Parent=foreachStatement is IForeachStatement)))]

| ParentForeach(foreachStatement) | ParentForeachBlock(foreachStatement, st) when st.Count == 1 => ...

when (x is IDisposable) // некоторые паттерны уже работают как булевы, осталось доработать if/when
  x.Dispose()

when (x matches [arg1, arg2]) // для остальных можно ввести оператор
{
  f(arg1, arg2)
}

mutable retTy = ty1;

when (!args1.IsEmpty && argsTys.Length == args1.Length)
{
  NList.Iter2(args1, argsTys, trySetType);

  when (retTy is PExpr.Wildcard)
    retTy = PExpr.TypedType(ret);
}

when ((x is IDisposable) as x)
  x.Dispose()

when (x is IDisposable as x)
  x.Dispose()

Z>when (x matches [arg1, arg2]) // для остальных можно ввести оператор
Z>{
Z>  f(arg1, arg2)
Z>}