anchor.diff:  let textOfArrPath path = String.concat "." (List.ofArray path)
   let textOfLid lid = textOfPath (pathOfLid lid)
   
  -let rangeOfLid (lid: Ident list) = 
  -    match lid with 
  +let rangeOfLid (lid: Ident list) =
  +    match lid with
       | [] -> failwith "rangeOfLid"
       | [id] -> id.idRange
  -    | h::t -> unionRanges h.idRange (List.last t).idRange 
  +    | h::t -> unionRanges h.idRange (List.last t).idRange
   
   [<RequireQualifiedAccess>]
  -type ScopedPragma = 
  -   | WarningOff of range * int
  +type ScopedPragma =
  +   | WarningOff of range:range * int
      // Note: this type may be extended in the future with optimization on/off switches etc.
   
   // These are the results of parsing + folding in the implicit file name
   /// ImplFile(modname,isScript,qualName,hashDirectives,modules,isLastCompiland)
   
  -/// QualifiedNameOfFile acts to fully-qualify module specifications and implementations, 
  -/// most importantly the ones that simply contribute fragments to a namespace (i.e. the ParsedSigFileFragment.NamespaceFragment case) 
  -/// There may be multiple such fragments in a single assembly.  There may thus also 
  -/// be multiple matching pairs of these in an assembly, all contributing types to the same 
  -/// namespace. 
  +/// QualifiedNameOfFile acts to fully-qualify module specifications and implementations,
  +/// most importantly the ones that simply contribute fragments to a namespace (i.e. the ParsedSigFileFragment.NamespaceFragment case)
  +/// There may be multiple such fragments in a single assembly.  There may thus also
  +/// be multiple matching pairs of these in an assembly, all contributing types to the same
  +/// namespace.
   [<NoEquality; NoComparison>]
  -type QualifiedNameOfFile = 
  -    | QualifiedNameOfFile of Ident 
  -    member x.Text = (let (QualifiedNameOfFile(t)) = x in t.idText)
  -    member x.Id = (let (QualifiedNameOfFile(t)) = x in t)
  -    member x.Range = (let (QualifiedNameOfFile(t)) = x in t.idRange)
  +type QualifiedNameOfFile =
  +    | QualifiedNameOfFile of Ident
  +    member x.Text = (let (QualifiedNameOfFile t) = x in t.idText)
  +    member x.Id = (let (QualifiedNameOfFile t) = x in t)
  +    member x.Range = (let (QualifiedNameOfFile t) = x in t.idRange)
   
   [<NoEquality; NoComparison>]
  -type ParsedImplFileInput = 
  -    | ParsedImplFileInput of string * (*isScript: *) bool * QualifiedNameOfFile * ScopedPragma list * ParsedHashDirective list * SynModuleOrNamespace list * (bool * bool)
  +type ParsedImplFileInput =
  +    | ParsedImplFileInput of fileName:string * isScript:bool * QualifiedNameOfFile * ScopedPragma list * ParsedHashDirective list * SynModuleOrNamespace list * (bool * bool)
   
   [<NoEquality; NoComparison>]
  -type ParsedSigFileInput = 
  -    | ParsedSigFileInput of string * QualifiedNameOfFile * ScopedPragma list * ParsedHashDirective list * SynModuleOrNamespaceSig list
  +type ParsedSigFileInput =
  +    | ParsedSigFileInput of fileName:string * QualifiedNameOfFile * ScopedPragma list * ParsedHashDirective list * SynModuleOrNamespaceSig list
   
   [<NoEquality; NoComparison; RequireQualifiedAccess>]
  -type ParsedInput = 
  +type ParsedInput =
       | ImplFile of ParsedImplFileInput
       | SigFile of ParsedSigFileInput
   
  -    member inp.Range = 
  +    member inp.Range =
           match inp with
  -        | ParsedInput.ImplFile (ParsedImplFileInput(_,_,_,_,_,(SynModuleOrNamespace(_,_,_,_,_,_,_,m) :: _),_))
  -        | ParsedInput.SigFile (ParsedSigFileInput(_,_,_,_,(SynModuleOrNamespaceSig(_,_,_,_,_,_,_,m) :: _))) -> m
  -        | ParsedInput.ImplFile (ParsedImplFileInput(filename,_,_,_,_,[],_))
  -        | ParsedInput.SigFile (ParsedSigFileInput(filename,_,_,_,[])) ->
  -#if DEBUG      
  +        | ParsedInput.ImplFile (ParsedImplFileInput(_,_,_,_,_,(SynModuleOrNamespace(range=m) :: _),_))
  +        | ParsedInput.SigFile (ParsedSigFileInput(_,_,_,_,(SynModuleOrNamespaceSig(range=m) :: _))) -> m
  +        | ParsedInput.ImplFile (ParsedImplFileInput (fileName=filename))
  +        | ParsedInput.SigFile (ParsedSigFileInput (fileName=filename)) ->
  +#if DEBUG
               assert("" = "compiler expects ParsedInput.ImplFile and ParsedInput.SigFile to have at least one fragment, 4488")
  -#endif    
  +#endif
               rangeN filename 0 (* There are no implementations, e.g. due to errors, so return a default range for the file *)
   
   
  
positive.code:       MemberKind: MemberKind }
  
  /// Note the member kind is actually computed partially by a syntax tree transformation in tc.fs
  and 
      [<StructuralEquality; NoComparison; RequireQualifiedAccess>]
      MemberKind = 
      | ClassConstructor
      | Constructor
      | Member 
      | PropertyGet 
      | PropertySet    
      /// An artifical member kind used prior to the point where a get/set property is split into two distinct members.
      | PropertyGetSet    
  
  and 
      [<NoEquality; NoComparison; RequireQualifiedAccess>]
      /// The untyped, unchecked syntax tree for a member signature, used in signature files, abstract member declarations
      /// and member constraints.
      SynMemberSig = 
      | Member of SynValSig  * MemberFlags * range 
      | Interface of SynType  * range
      | Inherit of SynType * range
      | ValField of SynField  * range
      | NestedType  of SynTypeDefnSig * range
  
  and SynMemberSigs = SynMemberSig list
  
  and 
      [<NoEquality; NoComparison>]
      SynTypeDefnKind = 
      | TyconUnspecified 
      | TyconClass 
      | TyconInterface 
      | TyconStruct 
      | TyconRecord
      | TyconUnion
      | TyconAbbrev
  
negative.code: let private isSimplePattern pat =
      let _nowpats,laterf = SimplePatsOfPat (SynArgNameGenerator()) pat
      Option.isNone laterf
  
  /// "fun (UnionCase x) (UnionCase y) -> body"
  ///       ==>
  ///   "fun tmp1 tmp2 ->
  ///        let (UnionCase x) = tmp1 in
  ///        let (UnionCase y) = tmp2 in
  ///        body"
  let PushCurriedPatternsToExpr synArgNameGenerator wholem isMember pats rhs =
      // Two phases
      // First phase: Fold back, from right to left, pushing patterns into r.h.s. expr
      let spatsl,rhs =
          (pats, ([],rhs))
             ||> List.foldBack (fun arg (spatsl,body) ->
                let spats,bodyf = SimplePatsOfPat synArgNameGenerator arg
                // accumulate the body. This builds "let (UnionCase y) = tmp2 in body"
                let body = appFunOpt bodyf body
  