* Use `getSourceLineStr` and enable handling sensitive indentation
  inside parens.

* Represent precedence for more kinds of expression than just symbolic
  infix operators.

* Handle exprs potentially confusable with type applications.

* Handle more numeric literal cases.

* We're still calling the logic directly inside of
  `DocumentDiagnosticAnalyzer` rather than exporting the type as an
  implementation of the `IFSharpUnnecessaryParenthesesDiagnosticAnalyzer`
  interface, since that interface does not exist upstream in Roslyn, and
  it seems like we would currently prefer not to go through the
  logistics of upstreaming it.

* +Assorted other bits and bobs

* Upon further thought, I'm pretty sure we _don't_ need to memoize
  the checking for dangling right-hand expressions, because we never
  dive deeper than needed for the check at hand, and the check will
  be quite shallow unless there are vast amounts of, say, nested matches
  inside of an if-condition body, but even then, such a check is both
  necessary and will only happen once, e.g.:

  ```fsharp
  let f x =
    if
       (match x with
        | _ ->
            match x with
            | _ ->
                match x with
                | _ ->
                    match x with
                    | _ ->
                        match x with
                        | _ ->
                            if x then x else x) then x else x
  ```

  If any other if-expression were found, or any nested parenthesized
  expression, or any construct without an exposed right-hand expression,
  the dive would end.

* This test purported to test FS1182, but the actual diagnostic that is
  generated from the example is FS1183.

…s.fs