anchor.diff:      /// from an untyped AST for the purposes of block structure.
       [<RequireQualifiedAccess>]
       module private Range =
  -        let inline union (r1:range) (r2:range) =
  -            let startPos =
  -                if r1.StartLine <= r2.StartLine
  -                 && r1.StartColumn <= r2.StartColumn then r1.Start else r2.Start
  -            let endPos =
  -                if r1.EndLine >= r2.EndLine
  -                 && r1.EndColumn >= r2.EndColumn then r1.End else r2.End
  -            mkFileIndexRange r1.FileIndex startPos endPos
   
           let unionOpts (r1:range option) (r2:range option) =
               match r1 , r2 with
               | None, None -> None
               | Some r, None -> Some r
               | None , Some r -> Some r
  -            | Some r1, Some r2 -> union r1 r2|> Some
  +            | Some r1, Some r2 -> unionRanges r1 r2 |> Some
   
           /// Create a range starting at the end of r1 and finishing at the end of r2
  -        let inline endToEnd (r1: range) (r2: range) = mkFileIndexRange r1.FileIndex r1.End   r2.End
  +        let inline endToEnd (r1: range) (r2: range) = mkFileIndexRange r1.FileIndex r1.End r2.End
   
           /// Create a range starting at the end of r1 and finishing at the start of r2
           let inline endToStart (r1: range) (r2: range) = mkFileIndexRange r1.FileIndex r1.End r2.Start
  
positive.code:             let rEnd   = Range.mkPos r.EndLine   (r.EndColumn - modEnd)
              mkFileIndexRange r.FileIndex rStart rEnd
  
  
      let longIdentRange (longId:LongIdent) =
          Range.startToEnd (List.head longId).idRange (List.last longId).idRange
  
      let rangeOfTypeArgsElse other (typeArgs:SynTyparDecl list) =
          match typeArgs with
          | [] -> other
          | ls ->
              ls|> List.map (fun (TyparDecl (_,typarg)) -> typarg.Range)
              |> List.reduce Range.union
  
      let rangeOfSynPatsElse other (synPats:SynSimplePat list) =
          match synPats with
          | [] -> other
          | ls ->
              ls |> List.map (
                  fun ( SynSimplePat.Attrib (range=r)
                      | SynSimplePat.Id (range=r)
                      | SynSimplePat.Typed (range=r)) -> r)
              |> List.reduce Range.union
  
  
      /// Scope indicates the way a range/snapshot should be collapsed. |Scope.Scope.Same| is for a scope inside
  
negative.code:                         // This is not the best way to establish the position of `else`
                          // the AST doesn't provide an easy way to find the position of the keyword
                          // as such `else` will be left out of block structuring and outlining until a
                          // a suitable approach is determined
                          yield! parseExpr elseExpr
                  | None -> ()
              | SynExpr.While (_,_,e,r) ->
  