anchor.diff:  
       /// Only used in FSharp.Core
       | LibraryOnlyUnionCaseFieldSet of SynExpr * longId:LongIdent * int * SynExpr * range:range
  -  
  +
       /// Inserted for error recovery
  -    | ArbitraryAfterError  of debugStr:string * range:range  
  +    | ArbitraryAfterError  of debugStr:string * range:range
   
       /// Inserted for error recovery
  -    | FromParseError  of expr:SynExpr * range:range  
  +    | FromParseError  of expr:SynExpr * range:range
   
       /// Inserted for error recovery when there is "expr." and missing tokens or error recovery after the dot
  -    | DiscardAfterMissingQualificationAfterDot  of expr:SynExpr * range:range  
  +    | DiscardAfterMissingQualificationAfterDot  of expr:SynExpr * range:range
   
       /// 'use x = fixed expr'
  -    | Fixed of SynExpr * range  
  +    | Fixed of SynExpr * range
   
       /// Get the syntactic range of source code covered by this construct.
  -    member e.Range = 
  -        match e with 
  -        | SynExpr.Paren(_,_,_,m) 
  -        | SynExpr.Quote(_,_,_,_,m) 
  -        | SynExpr.Const(_,m) 
  +    member e.Range =
  +        match e with
  +        | SynExpr.Paren(_,_,_,m)
  +        | SynExpr.Quote(_,_,_,_,m)
  +        | SynExpr.Const(_,m)
           | SynExpr.Typed (_,_,m)
           | SynExpr.Tuple (_,_,m)
           | SynExpr.StructTuple (_,_,m)
  
positive.code:                 let altNameRefCell = Some (ref (Undecided (mkSynId m (synArgNameGenerator.New()))))
                  let item = mkSynIdGetWithAlt m id altNameRefCell
                  false,altNameRefCell,id,item
              | _ -> 
                  let nm = synArgNameGenerator.New()
                  let id = mkSynId m nm
                  let item = mkSynIdGet m nm
                  true,None,id,item
          SynSimplePat.Id (id,altNameRefCell,isCompGen,false,false,id.idRange),
          Some (fun e -> 
                  let clause = Clause(p,None,e,m,SuppressSequencePointAtTarget)
                  SynExpr.Match(NoSequencePointAtInvisibleBinding,item,[clause],false,clause.Range)) 
  
  let appFunOpt funOpt x = match funOpt with None -> x | Some f -> f x
  let composeFunOpt funOpt1 funOpt2 = match funOpt2 with None -> funOpt1 | Some f -> Some (fun x -> appFunOpt funOpt1 (f x))
  let rec SimplePatsOfPat synArgNameGenerator p =
      match p with 
      | SynPat.FromParseError (p,_) -> SimplePatsOfPat synArgNameGenerator p 
      | SynPat.Typed(p',ty,m) -> 
          let p2,laterf = SimplePatsOfPat synArgNameGenerator p'
          SynSimplePats.Typed(p2,ty,m), 
          laterf
  //    | SynPat.Paren (p,m) -> SimplePatsOfPat synArgNameGenerator p 
      | SynPat.Tuple (ps,m) 
      | SynPat.Paren(SynPat.Tuple (ps,m),_) -> 
          let ps2,laterf = 
            List.foldBack 
              (fun (p',rhsf) (ps',rhsf') -> 
                p'::ps', 
                (composeFunOpt rhsf rhsf'))
              (List.map (SimplePatOfPat synArgNameGenerator) ps) 
              ([], None)
          SynSimplePats.SimplePats (ps2,m),
          laterf
      | SynPat.Paren(SynPat.Const (SynConst.Unit,m),_) 
      | SynPat.Const (SynConst.Unit,m) -> 
          SynSimplePats.SimplePats ([],m),
          None
      | _ -> 
          let m = p.Range
          let sp,laterf = SimplePatOfPat synArgNameGenerator p
          SynSimplePats.SimplePats ([sp],m),laterf
  
negative.code: /// Function and member definitions have strongly syntactically constrained arities.  We infer
  /// the arity from the syntax.
  ///
  /// For example, we record the arity for:
  /// StaticProperty --> [1]               -- for unit arg
  /// this.InstanceProperty --> [1;1]        -- for unit arg
  /// StaticMethod(args) --> map InferSynArgInfoFromSimplePat args
  