anchor.diff:              | true, replacement -> replacement
               | false, _ -> e
           | e -> e
  -    transformExprTree replaceVars' bodyExpr
  +    visit replaceVars' bodyExpr
   
   let (|RestAndTail|_|) (xs: _ list) =
       match List.rev xs with
  
positive.code: open Fable.AST.Fable.Util
  open System.Collections.Generic
  
  let rec transformExprTree f e =
      match e with
      | Value kind ->
          match kind with
          | Spread e -> Value(Spread(f e))
          | TypeRef(e, gen) -> Value(TypeRef(e, List.map (fun (n,e) -> n, f e) gen))
          | TupleConst exprs -> Value(TupleConst(List.map f exprs))
          | ArrayConst(kind, t) ->
              match kind with
              | ArrayValues exprs -> ArrayConst(ArrayValues(List.map f exprs), t) |> Value
              | ArrayAlloc e -> ArrayConst(ArrayAlloc(f e), t) |> Value
          | Lambda(args, body, info) -> Value(Lambda(args, f body, info))
          | Null | This | Super | IdentValue _ | ImportRef _
          | NumberConst _ | StringConst _ | BoolConst _ | RegexConst _
          | UnaryOp _ | BinaryOp _ | LogicalOp _ | Emit _ -> e
      | Apply(callee, args, kind, typ, range) ->
          Apply(f callee, List.map f args, kind, typ, range)
      | Wrapped(expr, t) ->
          Wrapped(f expr, t)
      | VarDeclaration (var, expr, isMut, range) ->
          VarDeclaration(var, f expr, isMut, range)
      | Sequential (exprs, range) ->
          Sequential(List.map f exprs, range)
      | IfThenElse(cond, thenExpr, elseExpr, r) ->
          IfThenElse(f cond, f thenExpr, f elseExpr, r)
      | Set(callee, prop, value, r) ->
          Set(f callee, Option.map f prop, f value, r)
      | ObjExpr(decls, ifcs, baseClass, r) ->
          let decls = decls |> List.map (fun (m, idents, e) ->
                  m, idents, f e)
          ObjExpr(decls, ifcs, Option.map f baseClass, r)
      | Loop (kind, r) ->
          match kind with
          | While(e1, e2) -> Loop(While(f e1, f e2), r)
          | For(i, e1, e2, e3, up) -> Loop(For(i, f e1, f e2, f e3, up), r)
          | ForOf(i, e1, e2) -> Loop(ForOf(i, f e1, f e2), r)
      | TryCatch(body, catch, finalizer, r) ->
          TryCatch(f body,
                   Option.map (fun (i, e) -> i, f e) catch,
                   Option.map f finalizer, r)
      | Switch(matchValue, cases, defaultCase, t, r) ->
          Switch(f matchValue,
                 List.map (fun (cases, body) -> List.map f cases, f body) cases,
                 Option.map f defaultCase, t, r)
      | Quote e -> Quote(f e)
      | Throw(e, t, r) -> Throw(f e, t, r)
      | DebugBreak _ -> e
      |> f
  
  
negative.code:             | [] -> lambdaBody
              | prevExprs -> Sequential(prevExprs@[lambdaBody], range)
          | e -> e
      visit optimizeExpr' expr
  
  let rec optimizeDeclaration (com: ICompiler) = function
      | EntityDeclaration(e, isPublic, privName, decls, r) ->
  