anchor.diff:            | SynExpr.DotNamedIndexedPropertySet (e1,_,e2,e3,_) ->
                 walkExpr e1 || walkExpr e2 || walkExpr e3
   
  -          | SynExpr.LetOrUseBang  (_,_,_,_,e1,e2,_) -> 
  -              walkExpr e1 || walkExpr e2 
  -    walkExpr inpExpr+          | SynExpr.LetOrUseBang  (_,_,_,_,e1,e2,_) ->
  +              walkExpr e1 || walkExpr e2
  +    walkExpr inpExpr
  
positive.code: 
  let mkSynPatVar vis (id:Ident) = SynPat.Named (SynPat.Wild id.idRange,id,false,vis,id.idRange)
  let mkSynThisPatVar (id:Ident) = SynPat.Named (SynPat.Wild id.idRange,id,true,None,id.idRange)
  let mkSynPatMaybeVar lidwd vis m =  SynPat.LongIdent (lidwd,None,None,SynConstructorArgs.Pats [],vis,m) 
  
  /// Extract the argument for patterns corresponding to the declaration of 'new ... = ...'
  let (|SynPatForConstructorDecl|_|) x = 
      match x with 
      | SynPat.LongIdent (LongIdentWithDots([_],_),_,_, SynConstructorArgs.Pats [arg],_,_) -> Some arg
      | _ -> None
  
  /// Recognize the '()' in 'new()'
  let (|SynPatForNullaryArgs|_|) x = 
      match x with 
      | SynPat.Paren(SynPat.Const(SynConst.Unit,_),_) -> Some()
      | _ -> None
      
  let (|SynExprErrorSkip|) (p:SynExpr) = 
      match p with 
      | SynExpr.FromParseError(p,_) -> p
      | _ -> p
  
  let (|SynExprParen|_|) (e:SynExpr) = 
      match e with 
      | SynExpr.Paren(SynExprErrorSkip e,a,b,c) -> Some (e,a,b,c)
      | _ -> None
  
  let (|SynPatErrorSkip|) (p:SynPat) = 
      match p with 
      | SynPat.FromParseError(p,_) -> p
      | _ -> p
  
  /// Push non-simple parts of a patten match over onto the r.h.s. of a lambda.
  /// Return a simple pattern and a function to build a match on the r.h.s. if the pattern is complex
  let rec SimplePatOfPat (synArgNameGenerator: SynArgNameGenerator) p =
      match p with 
      | SynPat.Typed(p',ty,m) -> 
          let p2,laterf = SimplePatOfPat synArgNameGenerator p'
          SynSimplePat.Typed(p2,ty,m), 
          laterf
      | SynPat.Attrib(p',attribs,m) -> 
          let p2,laterf = SimplePatOfPat synArgNameGenerator p'
          SynSimplePat.Attrib(p2,attribs,m), 
          laterf
      | SynPat.Named (SynPat.Wild _, v,thisv,_,m) -> 
          SynSimplePat.Id (v,None,false,thisv,false,m), 
          None
      | SynPat.OptionalVal (v,m) -> 
          SynSimplePat.Id (v,None,false,false,true,m), 
          None
      | SynPat.Paren (p,_) -> SimplePatOfPat synArgNameGenerator p 
      | SynPat.FromParseError (p,_) -> SimplePatOfPat synArgNameGenerator p 
      | _ -> 
          let m = p.Range
          let isCompGen,altNameRefCell,id,item = 
              match p with 
              | SynPat.LongIdent(LongIdentWithDots([id],_),_,None, SynConstructorArgs.Pats [],None,_) -> 
                  // The pattern is 'V' or some other capitalized identifier.
                  // It may be a real variable, in which case we want to maintain its name.
                  // But it may also be a nullary union case or some other identifier.
  
negative.code: //-----------------------------------------------------------------------
  
  [<RequireQualifiedAccess>]
  type SynAccess =
      | Public
      | Internal
      | Private
  
  
  type SequencePointInfoForTarget =
      | SequencePointAtTarget
      | SuppressSequencePointAtTarget
  
  type SequencePointInfoForSeq =
      | SequencePointsAtSeq
      // This means "suppress a in 'a;b'" and "suppress b in 'a before b'"
      | SuppressSequencePointOnExprOfSequential
      // This means "suppress b in 'a;b'" and "suppress a in 'a before b'"
      | SuppressSequencePointOnStmtOfSequential
  
  type SequencePointInfoForTry =
      | SequencePointAtTry of range:range
      // Used for "use" and "for"
      | SequencePointInBodyOfTry
      | NoSequencePointAtTry
  
  type SequencePointInfoForWith =
      | SequencePointAtWith of range:range
      | NoSequencePointAtWith
  
  type SequencePointInfoForFinally =
      | SequencePointAtFinally of range:range
      | NoSequencePointAtFinally
  
  type SequencePointInfoForForLoop =
      | SequencePointAtForLoop of range:range
      | NoSequencePointAtForLoop
  
  type SequencePointInfoForWhileLoop =
      | SequencePointAtWhileLoop of range:range
      | NoSequencePointAtWhileLoop
  
  type SequencePointInfoForBinding =
      | SequencePointAtBinding of range:range
      // Indicates the omission of a sequence point for a binding for a 'do expr'
      | NoSequencePointAtDoBinding
      // Indicates the omission of a sequence point for a binding for a 'let e = expr' where 'expr' has immediate control flow
      | NoSequencePointAtLetBinding
  