anchor.diff:              | SynExpr.DotSet (e,_,_,_)
               | SynExpr.Typed (e,_,_)
               | SynExpr.DotIndexedGet (e,_,_,_)
  -            | SynExpr.DotIndexedSet (e,_,_,_,_,_) -> yield! parseExpr e
  +            | SynExpr.DotIndexedSet (e,_,_,_,_,_) -> parseExpr e
               | SynExpr.New (_,_,expr,r) ->
                   let collapse = Range.endToEnd expr.Range r
  -                yield! rcheck Scope.New Collapse.Below r collapse
  -                yield! parseExpr expr
  +                rcheck Scope.New Collapse.Below r collapse
  +                parseExpr expr
               | SynExpr.YieldOrReturn (_,e,r) ->
  -                yield! rcheck Scope.YieldOrReturn Collapse.Below r r
  -                yield! parseExpr e
  +                rcheck Scope.YieldOrReturn Collapse.Below r r
  +                parseExpr e
               | SynExpr.YieldOrReturnFrom (_,e,r) ->
  -                yield! rcheck Scope.YieldOrReturnBang Collapse.Below r r
  -                yield! parseExpr e
  +                rcheck Scope.YieldOrReturnBang Collapse.Below r r
  +                parseExpr e
               | SynExpr.DoBang (e,r) ->
  -                yield! rcheck Scope.Do Collapse.Below r <| Range.modStart 3 r
  -                yield! parseExpr e
  +                rcheck Scope.Do Collapse.Below r <| Range.modStart 3 r
  +                parseExpr e
               | SynExpr.LetOrUseBang (_,_,_,pat,e1,e2,_) ->
                   // for `let!` or `use!` the pattern begins at the end of the keyword so that
                   // this scope can be used without adjustment if there is no `=` on the same line
                   // if there is an `=` the range will be adjusted during the tooltip creation
                   let r = Range.endToEnd pat.Range e1.Range
  -                yield! rcheck Scope.LetOrUseBang Collapse.Below r r
  -                yield! parseExpr e1
  -                yield! parseExpr e2
  +                rcheck Scope.LetOrUseBang Collapse.Below r r
  +                parseExpr e1
  +                parseExpr e2
               | SynExpr.For (_,_,_,_,_,e,r)
               | SynExpr.ForEach (_,_,_,_,_,e,r) ->
  -                yield! rcheck Scope.For Collapse.Below r r
  -                yield! parseExpr e
  +                rcheck Scope.For Collapse.Below r r
  +                parseExpr e
               | SynExpr.LetOrUse (_,_,bindings, body, _) ->
  -                yield! parseBindings bindings
  -                yield! parseExpr body
  +                parseBindings bindings
  +                parseExpr body
               | SynExpr.Match (seqPointAtBinding,_expr,clauses,_,r) ->
                   match seqPointAtBinding with
                   | SequencePointAtBinding sr ->
                       let collapse = Range.endToEnd sr r
  -                    yield! rcheck Scope.Match Collapse.Same r collapse
  +                    rcheck Scope.Match Collapse.Same r collapse
                   | _ -> ()
  -                yield! parseMatchClauses clauses
  +                List.iter parseMatchClause clauses
               | SynExpr.MatchLambda (_,caseRange,clauses,matchSeqPoint,r) ->
                   let caseRange =
                       match matchSeqPoint with
                       | SequencePointAtBinding r -> r
                       | _ -> caseRange
                   let collapse = Range.endToEnd caseRange r
  -                yield! rcheck Scope.MatchLambda Collapse.Same r collapse
  -                yield! parseMatchClauses clauses
  +                rcheck Scope.MatchLambda Collapse.Same r collapse
  +                List.iter parseMatchClause clauses
               | SynExpr.App (atomicFlag,isInfix,funcExpr,argExpr,r) ->
                   // seq exprs, custom operators, etc
                   if ExprAtomicFlag.NonAtomic=atomicFlag && (not isInfix)
  -                   && (function | SynExpr.Ident _    -> true  | _ -> false) funcExpr
  -                   && (function | SynExpr.CompExpr _ -> false | _ -> true ) argExpr then
  +                   && (function SynExpr.Ident _    -> true  | _ -> false) funcExpr
  +                   && (function SynExpr.CompExpr _ -> false | _ -> true ) argExpr then
                      // if the argExrp is a computation expression another match will handle the outlining
                      // these cases must be removed to prevent creating unnecessary tags for the same scope
                       let collapse = Range.endToEnd funcExpr.Range r
  -                    yield! rcheck Scope.SpecialFunc Collapse.Below r collapse
  +                    rcheck Scope.SpecialFunc Collapse.Below r collapse
                   elif ExprAtomicFlag.NonAtomic=atomicFlag && (not isInfix)
  -                   && (function | SynExpr.CompExpr _ -> true | _ -> false) argExpr then
  +                   && (function SynExpr.CompExpr _ -> true | _ -> false) argExpr then
                           let collapse = Range.startToEnd argExpr.Range r
  -                        yield! rcheck Scope.CompExpr Collapse.Same r <| Range.modBoth 1 1 collapse
  -                yield! parseExpr argExpr
  -                yield! parseExpr funcExpr
  +                        rcheck Scope.CompExpr Collapse.Same r <| Range.modBoth 1 1 collapse
  +                parseExpr argExpr
  +                parseExpr funcExpr
               | SynExpr.Sequential (_,_,e1,e2,_) ->
  -                yield! parseExpr e1
  -                yield! parseExpr e2
  +                parseExpr e1
  +                parseExpr e2
               | SynExpr.ArrayOrListOfSeqExpr (isArray,e,r) ->
  -                yield! rcheck  Scope.ArrayOrList Collapse.Same r <| Range.modBoth (if isArray then 2 else 1) (if isArray then 2 else 1) r
  -                yield! parseExpr e
  +                rcheck  Scope.ArrayOrList Collapse.Same r <| Range.modBoth (if isArray then 2 else 1) (if isArray then 2 else 1) r
  +                parseExpr e
               | SynExpr.CompExpr (_arrayOrList,_,e,_r) as _c ->
  -                yield! parseExpr e
  +                parseExpr e
               | SynExpr.ObjExpr (_,argOpt,bindings,extraImpls,newRange,wholeRange) as _objExpr ->
                   match argOpt with
                   | Some (args,_) ->
                       let collapse = Range.endToEnd args.Range wholeRange
  -                    yield! rcheck Scope.ObjExpr Collapse.Below wholeRange collapse
  +                    rcheck Scope.ObjExpr Collapse.Below wholeRange collapse
                   | None ->
                       let collapse = Range.endToEnd newRange wholeRange
  -                    yield! rcheck Scope.ObjExpr Collapse.Below wholeRange collapse
  -                yield! parseBindings bindings
  -                yield! parseExprInterfaces extraImpls
  -            | SynExpr.TryWith (e,_tryRange,matchClauses,_withRange,wholeRange,tryPoint,withPoint) ->
  +                    rcheck Scope.ObjExpr Collapse.Below wholeRange collapse
  +                parseBindings bindings
  +                parseExprInterfaces extraImpls
  +            | SynExpr.TryWith (e,_,matchClauses,_,wholeRange,tryPoint,withPoint) ->
                   match tryPoint, withPoint with
                   | SequencePointAtTry tryRange,  SequencePointAtWith withRange ->
                       let fullrange = Range.startToEnd tryRange wholeRange
  
positive.code:     /// Set of visitor utilities, designed for the express purpose of fetching ranges
      /// from an untyped AST for the purposes of block structure.
      [<RequireQualifiedAccess>]
      module private Range =
          /// 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
  
          /// 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
  
          /// Create a range beginning at the start of r1 and finishing at the end of r2
          let inline startToEnd (r1: range) (r2: range) = mkFileIndexRange r1.FileIndex r1.Start r2.End
  
          /// Create a range beginning at the start of r1 and finishing at the start of r2
          let inline startToStart (r1: range) (r2: range) = mkFileIndexRange r1.FileIndex r1.Start r2.Start
  
          /// Create a new range from r by shifting the starting column by m
          let inline modStart  (m:int) (r: range) =
              let modstart = mkPos r.StartLine (r.StartColumn+m)
              mkFileIndexRange r.FileIndex modstart r.End
  
          /// Create a new range from r by shifting the ending column by m
          let inline modEnd (m:int) (r: range) =
              let modend = mkPos r.EndLine (r.EndColumn+m)
              mkFileIndexRange r.FileIndex r.Start modend
  
  
          /// Produce a new range by adding modStart to the StartColumn of `r`
          /// and subtracting modEnd from the EndColumn of `r`
          let inline modBoth modStart modEnd (r:range) =
              let rStart = mkPos r.StartLine (r.StartColumn+modStart)
              let rEnd   = mkPos r.EndLine   (r.EndColumn - modEnd)
              mkFileIndexRange r.FileIndex rStart rEnd
  
negative.code:         | UnionDefn
          | Comment
          | XmlDocComment
          override self.ToString() = 
              match self with
              | Open                -> "Open"
              | Namespace           -> "Namespace"
              | Module              -> "Module"
              | Type                -> "Type"
              | Member              -> "Member"
              | LetOrUse            -> "LetOrUse"
              | Val                 -> "Val"
              | CompExpr            -> "CompExpr"
              | IfThenElse          -> "IfThenElse"
              | ThenInIfThenElse    -> "ThenInIfThenElse"
              | ElseInIfThenElse    -> "ElseInIfThenElse"
              | TryWith             -> "TryWith"
              | TryInTryWith        -> "TryInTryWith"
              | WithInTryWith       -> "WithInTryWith"
              | TryFinally          -> "TryFinally"
              | TryInTryFinally     -> "TryInTryFinally"
              | FinallyInTryFinally -> "FinallyInTryFinally"
              | ArrayOrList         -> "ArrayOrList"
              | ObjExpr             -> "ObjExpr"
              | For                 -> "For"
              | While               -> "While"
              | Match               -> "Match"
              | MatchLambda         -> "MatchLambda"
              | MatchClause         -> "MatchClause"
              | Lambda              -> "Lambda"
              | CompExprInternal    -> "CompExprInternal"
              | Quote               -> "Quote"
              | Record              -> "Record"
              | SpecialFunc         -> "SpecialFunc"
              | Do                  -> "Do"
              | New                 -> "New"
              | Attribute           -> "Attribute"
              | Interface           -> "Interface"
              | HashDirective       -> "HashDirective"
              | LetOrUseBang        -> "LetOrUseBang"
              | TypeExtension       -> "TypeExtension"
              | YieldOrReturn       -> "YieldOrReturn"
              | YieldOrReturnBang   -> "YieldOrReturnBang"
              | Tuple               -> "Tuple"
              | UnionCase           -> "UnionCase"
              | EnumCase            -> "EnumCase"
              | RecordField         -> "RecordField"
              | RecordDefn          -> "RecordDefn"
              | UnionDefn           -> "UnionDefn"
              | Comment             -> "Comment"
              | XmlDocComment       -> "XmlDocComment"
  
      /// Stores the range for a construct, the sub-range that should be collapsed for outlinging,
      /// a tag for the construct type, and a tag for the collapse style
      [<NoComparison>]
      type ScopeRange = 
          { Scope: Scope
            Collapse: Collapse
            /// HintSpan in BlockSpan
            Range: range
            /// TextSpan in BlockSpan
            CollapseRange: range }
  
      type LineNumber = int
      type LineStr = string
      type CommentType = SingleLine | XmlDoc
  
      [<NoComparison>]
      type CommentList =
          { Lines: ResizeArray<LineNumber * LineStr>
            Type: CommentType }
          static member New ty lineStr =
              { Type = ty
                Lines = ResizeArray [lineStr] }
  
      /// Returns outlining ranges for given parsed input.                
      let getOutliningRanges (sourceLines: string[]) (parsedInput: ParsedInput) =
          let acc = ResizeArray()
  
          /// Validation function to ensure that ranges yielded for outlinging span 2 or more lines
          let inline rcheck scope collapse (fullRange: range) (collapseRange: range) = 
              if fullRange.StartLine <> fullRange.EndLine then 
                  acc.Add { Scope = scope
                            Collapse = collapse
                            Range = fullRange
                            CollapseRange = collapseRange }
  
            //============================================//
           //     Implementation File AST Traversal      //
          //============================================//
  
          let rec parseExpr expression =
              match expression with
              | SynExpr.Upcast (e,_,_)
              | SynExpr.Downcast (e,_,_)
  