anchor.diff:                  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 -> 
  +        Some (fun e ->
                   let clause = Clause(p,None,e,m,SuppressSequencePointAtTarget)
  -                SynExpr.Match(NoSequencePointAtInvisibleBinding,item,[clause],false,clause.Range)) 
  +                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) -> 
  +    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), 
  +        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', 
  +//    | 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) 
  +            (List.map (SimplePatOfPat synArgNameGenerator) ps)
               ([], None)
           SynSimplePats.SimplePats (ps2,m),
           laterf
  -    | SynPat.Paren(SynPat.Const (SynConst.Unit,m),_) 
  -    | SynPat.Const (SynConst.Unit,m) -> 
  +    | 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
  
positive.code:             match this with
              | LongIdentWithDots([],_) -> failwith "rangeOfLidwd"
              | LongIdentWithDots([id],_) -> id.idRange
              | LongIdentWithDots(h::t,dotms) -> 
                  let nonExtraDots = if dotms.Length = t.Length then dotms else List.take t.Length dotms
                  unionRanges h.idRange (List.last t).idRange |> unionRanges (List.last nonExtraDots)
  
  //------------------------------------------------------------------------
  //  AST: the grammar of implicitly scoped type parameters 
  //-----------------------------------------------------------------------
  
  type TyparStaticReq = 
      | NoStaticReq 
      | HeadTypeStaticReq 
  
  [<NoEquality; NoComparison>]
  type SynTypar = 
      | Typar of Ident * TyparStaticReq * (* isCompGen: *) bool 
      with member this.Range =
              match this with
              | Typar(id,_,_) ->
  
negative.code:     /// types of optional arguments for function and member signatures.
      let HasOptionalArgs (SynValInfo(args,_)) = List.exists (List.exists IsOptionalArg) args
  
      /// Add a parameter entry to the syntactic value information to represent the '()' argument to a property getter. This is
      /// used for the implicit '()' argument in property getter signature specifications.
      let IncorporateEmptyTupledArgForPropertyGetter (SynValInfo(args,retInfo)) = SynValInfo([]::args,retInfo)
  
      /// Add a parameter entry to the syntactic value information to represent the 'this' argument. This is
      /// used for the implicit 'this' argument in member signature specifications.
      let IncorporateSelfArg (SynValInfo(args,retInfo)) = SynValInfo(selfMetadata::args,retInfo)
  
      /// Add a parameter entry to the syntactic value information to represent the value argument for a property setter. This is
      /// used for the implicit value argument in property setter signature specifications.
      let IncorporateSetterArg (SynValInfo(args,retInfo)) =
           let args =
               match args with
               | [] -> [unnamedTopArg]
               | [arg] -> [arg@[unnamedTopArg1]]
               | _ -> failwith "invalid setter type"
           SynValInfo(args,retInfo)
  
      /// Get the argument counts for each curried argument group. Used in some adhoc places in tc.fs.
  