Outlining: unfinished statements re-expand collapsed sections

[Kelvin4702]

Using the following file:

namespace OutliningTest

module File1 =

    module BeforeModule =
        let foo = "bar"

    // Before
    // comment
    type BeforeType =
        | Hello
        | World of int

    // Paste repro here (line 15)


    module AfterModule =
        let foo = "bar"

    // After
    // comment
    type AfterType =
        | Hello
        | World of int

Repro steps:

• Turn off automatic brace completion in F# Editor options (optional, but helps to create unfinished statements, unmatched double-quotes, braces, parentheses, etc.)
• Paste the test file above into VS.
• Collapse all but the File1 module.
• Type or paste any of the following onto line 15.
  • let a = (4 spaces preceeding: expands blocks after it)
  • let a = (8 spaces preceeding: expands blocks after it, and the block containing it)
  • "unfinished string (4 spaces preceeding: expands blocks after it)
  • "unfinished string (8 spaces preceeding: expands blocks after it, and the block containing it)
  • [1;2;3] |> (4/8 spaces preceeding)
  • doSomething( (4/8 spaces preceeding)
  • match x with (4/8 spaces preceeding)
  • ... list goes on

Sample in VS2019:

This seems to be supported in other editors, such as VSCode(+Ionide) or Notepad++.
VSCode:

Environment:
Windows 10 Enterprise (10.0.17763)
Visual Studio 2019 (16.1.3) (but same on 2017)
Visual F# Tools 10.4 for F# 4.6 (16.1.0-beta.19253.3+42526fe359672a05fd562dc16a91a43d0fe047a7)

[cartermp]

Aha, this is definitely a bug. It's subtle, but you'll notice that:

• The structured guidelines disappear for the constructs that were expanded
• The little collapsing nodes disappear for them as well

This is because we couldn't parse those constructs, and when we call our routine that operates on parsed input, it fails to give back proper spans for us to create BlockSpans out of. Since VS asks our tools for these BlockSpans, and we have little to give, it does what it can (and uncollapses code since there's no scope defined to collapse).

This is exacerbated if you turn off automatic brace completion, since the compiler won't have as much context when it attempts to parse. And this also won't reproduce in VSCode/Ionide because the collapsing routines there don't use something like parsed input to define what you can collapse/uncollapse.