anchor.diff:          e1 |> Option.iter walkExpr
   
       and walkExpr = function
  +        | SynExpr.Paren (e, _, _, _)
  +        | SynExpr.Quote(_, _, e, _, _)
  +        | SynExpr.Typed(e, _, _)
  +        | SynExpr.InferredUpcast(e, _)
  +        | SynExpr.InferredDowncast(e, _) 
  +        | SynExpr.AddressOf(_, e, _, _)
  +        | SynExpr.DoBang(e, _)
  +        | SynExpr.YieldOrReturn(_, e, _)
  +        | SynExpr.ArrayOrListOfSeqExpr(_, e, _)
  +        | SynExpr.CompExpr(_, _, e, _)
  +        | SynExpr.Lambda(_, _, _, e, _)
  +        | SynExpr.Do(e, _)
  +        | SynExpr.Assert(e, _)
  +        | SynExpr.Lazy(e, _)
  +        | SynExpr.YieldOrReturnFrom(_, e, _) -> walkExpr e
           | SynExpr.LongIdent (_, ident, _, _) -> addLongIdentWithDots ident
  -        | SynExpr.Ident ident -> addIdent ident
  -        | SynExpr.Paren (e, _, _, _) -> walkExpr e
  -        | SynExpr.Quote(_, _, e, _, _) -> walkExpr e
  -        | SynExpr.Typed(e, _, _) -> walkExpr e
  -        | SynExpr.Tuple(es, _, _) -> List.iter walkExpr es
  +        | SynExpr.New(_, t, e, _)
  +        | SynExpr.TypeTest(e, t, _)
  +        | SynExpr.Upcast(e, t, _) 
  +        | SynExpr.Downcast(e, t, _) -> walkExpr e; walkType t
  +        | SynExpr.Tuple(es, _, _)
  +        | Sequentials es
           | SynExpr.ArrayOrList(_, es, _) -> List.iter walkExpr es
  +        | SynExpr.App(_, _, e1, e2, _)
  +        | SynExpr.TryFinally(e1, e2, _, _, _)
  +        | SynExpr.While(_, e1, e2, _) -> List.iter walkExpr [e1; e2]
           | SynExpr.Record(_, _, fields, _) -> 
               fields |> List.iter (fun ((ident, _), e, _) -> 
                           addLongIdentWithDots ident
                           e |> Option.iter walkExpr)
  -        | SynExpr.New(_, t, e, _) -> 
  -            walkExpr e
  -            walkType t
  +        | SynExpr.Ident ident -> addIdent ident
           | SynExpr.ObjExpr(ty, argOpt, bindings, ifaces, _, _) -> 
               argOpt |> Option.iter (fun (e, ident) -> 
                   walkExpr e
  
positive.code:     let visitType ty =
          let (SynTypeDefn.TypeDefn (_, repr, defns, _)) = ty
          match repr with
          | SynTypeDefnRepr.ObjectModel (_, defns, _) ->
              for d in defns do visitMember d
          | _ -> ()
          for d in defns do visitMember d
  
      let rec visitDeclarations decls = 
          for declaration in decls do
              match declaration with
              | SynModuleDecl.Let (_, bindings, _) -> visitBindindgs bindings
              | SynModuleDecl.DoExpr (_, expr, _) -> visitExpr expr
              | SynModuleDecl.Types (types, _) -> for ty in types do visitType ty
              | SynModuleDecl.NestedModule (_, decls, _, _) -> visitDeclarations decls
              | _ -> ()
  
      let visitModulesAndNamespaces modulesOrNss =
          for moduleOrNs in modulesOrNss do
              let (SynModuleOrNamespace(_, _, decls, _, _, _, _)) = moduleOrNs
              visitDeclarations decls
  
      ast 
      |> Option.iter (function
          | ParsedInput.ImplFile implFile ->
              let (ParsedImplFileInput(_, _, _, _, _, modules, _)) = implFile
              visitModulesAndNamespaces modules
          | _ -> ())
      quotationRanges
     
  
negative.code:         | SynIndexerArg.Two (e1, e2) -> List.iter walkExpr [e1; e2]
  
      and walkType = function
          | SynType.Array(_, t, _)
          | SynType.HashConstraint(t, _)
          | SynType.MeasurePower(t, _, _) -> walkType t
          | SynType.Fun(t1, t2, _)
          | SynType.MeasureDivide(t1, t2, _) -> walkType t1; walkType t2
          | SynType.LongIdent ident -> addLongIdentWithDots ident
          | SynType.App(ty, _, types, _, _, _, _) -> walkType ty; List.iter walkType types
          | SynType.LongIdentApp(_, _, _, types, _, _, _) -> List.iter walkType types
          | SynType.Tuple(ts, _) -> ts |> List.iter (fun (_, t) -> walkType t)
          | SynType.WithGlobalConstraints(t, typeConstraints, _) -> 
              walkType t; List.iter walkTypeConstraint typeConstraints
          | _ -> ()
  
      and walkClause (Clause(pat, e1, e2, _, _)) =
  