anchor.diff:  
       type ILLocalBuilder(i: int) =
           member __.LocalIndex = i
  +    
  +    [<RequireQualifiedAccess>]
  +    type ILExceptionClauseBuilder =
  +        | Finally of ILCodeLabel
  +        | Fault of ILCodeLabel
  +        | FilterCatch of ILCodeLabel * (ILCodeLabel * ILCodeLabel)
  +        | TypeCatch of ILCodeLabel * ILType
  +
  +    type ILExceptionBlockBuilder(i: ILCodeLabel) =
  +        member __.StartIndex = i
  +        member val Clause : ILExceptionClauseBuilder option = None with get, set
   
       type ILGenerator(methodName) =
           let mutable locals =  ResizeArray<ILLocal>()
           let mutable instrs =  ResizeArray<ILInstr>()
  +        let mutable exceptions = ResizeArray<ILExceptionSpec>()
           let mutable labelCount =  0
           let mutable labels =  Dictionary<ILCodeLabel,int>()
  +        let mutable exceptionBlocks = Stack<ILExceptionBlockBuilder>()
   
           member __.Content = 
               { IsZeroInit = true
                 MaxStack = instrs.Count
                 Locals = locals.ToArray()
                 Code = 
  -                { Labels=labels
  -                  Instrs=instrs.ToArray()
  -                  Exceptions = [| |] // TODO
  +                { Labels = labels
  +                  Instrs = instrs.ToArray()
  +                  Exceptions = exceptions.ToArray()
                     Locals = [| |] (* TODO ILLocalDebugInfo *) }
                }
   
  
positive.code:                         stres, ldres
  
                  let exceptionVar = ilg.DeclareLocal(transType catchVar.Type)
                  locals.Add(catchVar, exceptionVar)
  
                  let _exnBlock = ilg.BeginExceptionBlock()
  
                  emitExpr expectedState body
                  stres()
  
negative.code:                 ilg.EndExceptionBlock()
  
                  ldres()
  
              | TryFinally(body, finallyBody) ->
  
                  let stres, ldres =
                      if isEmpty expectedState then ignore, ignore
                      else
                          let local = ilg.DeclareLocal (transType body.Type)
                          let stres = fun () -> ilg.Emit(I_stloc local.LocalIndex)
                          let ldres = fun () -> ilg.Emit(I_ldloc local.LocalIndex)
                          stres, ldres
                  
                  ilg.BeginExceptionBlock() |> ignore
  
                  emitExpr expectedState body
                  stres()
  
                  ilg.BeginFinallyBlock() |> ignore
  
                  emitExpr expectedState finallyBody
  
                  ilg.EndExceptionBlock()
  
                  ldres()
  
              | VarSet(v,e) ->
                  emitExpr ExpectedStackState.Value e
  