Service updates

Author: edgarfgp

src/Compiler/Service/ServiceInterfaceStubGenerator.fs

@@ -904,8 +904,16 @@ module InterfaceStubGenerator =
 
                 | SynExpr.TypeApp(synExpr, _, _synTypeList, _commas, _, _, _range) -> walkExpr synExpr
 
-                | SynExpr.LetOrUse(bindings = synBindingList; body = synExpr) ->
-                    Option.orElse (List.tryPick walkBinding synBindingList) (walkExpr synExpr)
+                | SynExpr.LetOrUse(isComputed = isComputed; bindings = synBindingList; body = synExpr) ->
+                    if isComputed then
+                        [
+                            for SynBinding(expr = bindingExpr) in synBindingList do
+                                yield bindingExpr
+                            yield synExpr
+                        ]
+                        |> List.tryPick walkExpr
+                    else
+                        Option.orElse (List.tryPick walkBinding synBindingList) (walkExpr synExpr)
 
                 | SynExpr.TryWith(tryExpr = synExpr) -> walkExpr synExpr
 

src/Compiler/Service/ServiceParseTreeWalk.fs

@@ -669,17 +669,27 @@ module SyntaxTraversal =
                         ]
                         |> pick expr
 
-                | SynExpr.LetOrUse(isRecursive = isRecursive; bindings = synBindingList; body = synExpr; range = range) ->
-                    match visitor.VisitLetOrUse(path, isRecursive, traverseSynBinding path, synBindingList, range) with
-                    | None ->
+                | SynExpr.LetOrUse(
+                    isRecursive = isRecursive; isComputed = isComputed; bindings = synBindingList; body = synExpr; range = range) ->
+                    if isComputed then
                         [
-                            yield!
-                                synBindingList
-                                |> List.map (fun x -> dive x x.RangeOfBindingWithRhs (traverseSynBinding path))
+                            for SynBinding(headPat = pat; expr = bindingExpr) in synBindingList do
+                                yield dive pat pat.Range traversePat
+                                yield dive bindingExpr bindingExpr.Range traverseSynExpr
                             yield dive synExpr synExpr.Range traverseSynExpr
                         ]
                         |> pick expr
-                    | x -> x
+                    else
+                        match visitor.VisitLetOrUse(path, isRecursive, traverseSynBinding path, synBindingList, range) with
+                        | None ->
+                            [
+                                yield!
+                                    synBindingList
+                                    |> List.map (fun x -> dive x x.RangeOfBindingWithRhs (traverseSynBinding path))
+                                yield dive synExpr synExpr.Range traverseSynExpr
+                            ]
+                            |> pick expr
+                        | x -> x
 
                 | SynExpr.IfThenElse(ifExpr = synExpr; thenExpr = synExpr2; elseExpr = synExprOpt) ->
                     [

src/Compiler/Service/ServiceParsedInputOps.fs

@@ -834,9 +834,17 @@ module ParsedInput =
                 walkExprWithKind (Some EntityKind.Type) e
                 |> Option.orElseWith (fun () -> List.tryPick walkType tys)
 
-            | SynExpr.LetOrUse(bindings = bindings; body = e) ->
-                List.tryPick walkBinding bindings
-                |> Option.orElseWith (fun () -> walkExprWithKind parentKind e)
+            | SynExpr.LetOrUse(isComputed = isComputed; bindings = bindings; body = e) ->
+                if isComputed then
+                    [
+                        for SynBinding(expr = bindingExpr) in bindings do
+                            yield bindingExpr
+                        yield e
+                    ]
+                    |> List.tryPick (walkExprWithKind parentKind)
+                else
+                    List.tryPick walkBinding bindings
+                    |> Option.orElseWith (fun () -> walkExprWithKind parentKind e)
 
             | SynExpr.IfThenElse(ifExpr = e1; thenExpr = e2; elseExpr = e3) ->
                 walkExprWithKind parentKind e1
@@ -2102,9 +2110,16 @@ module ParsedInput =
                 List.iter walkType tys
                 walkExpr e
 
-            | SynExpr.LetOrUse(bindings = bindings; body = e) ->
-                List.iter walkBinding bindings
-                walkExpr e
+            | SynExpr.LetOrUse(isComputed = isComputed; bindings = bindings; body = e) ->
+                if isComputed then
+                    for SynBinding(headPat = pat; expr = bindingExpr) in bindings do
+                        walkPat pat
+                        walkExpr bindingExpr
+
+                    walkExpr e
+                else
+                    List.iter walkBinding bindings
+                    walkExpr e
 
             | SynExpr.TryWith(tryExpr = e; withCases = clauses) ->
                 List.iter walkClause clauses

src/Compiler/Service/ServiceStructure.fs

@@ -263,9 +263,21 @@ module Structure =
                 rcheck Scope.For Collapse.Below r r
                 parseExpr e
 
-            | SynExpr.LetOrUse(bindings = bindings; body = body) ->
-                parseBindings bindings
-                parseExpr body
+            | SynExpr.LetOrUse(isComputed = isComputed; bindings = bindings; body = body) ->
+                if isComputed then
+                    for SynBinding(headPat = pat; expr = expr) in bindings do
+                        // for `let!`, `use!` or `and!` 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 expr.Range
+                        rcheck Scope.LetOrUseBang Collapse.Below r r
+                        parseExpr expr
+
+                    parseExpr body
+                else
+                    parseBindings bindings
+                    parseExpr body
 
             | SynExpr.Match(matchDebugPoint = seqPointAtBinding; clauses = clauses; range = r)
             | SynExpr.MatchBang(matchDebugPoint = seqPointAtBinding; clauses = clauses; range = r) ->

src/Compiler/Service/SynExpr.fs

@@ -444,7 +444,6 @@ module SynExpr =
         [<return: Struct>]
         let (|LetOrUse|_|) =
             dangling (function
-                | SynExpr.LetOrUse _
                 | SynExpr.LetOrUse _ as expr -> Some expr
                 | _ -> None)
 

src/Compiler/SyntaxTree/ParseHelpers.fs

@@ -1066,7 +1066,7 @@ let leadingKeywordIsAbstract =
     | _ -> false
 
 /// Unified helper for creating let/let!/use/use! expressions
-/// Creates either SynExpr.LetOrUse or SynExpr.LetOrUseBang based on isBang parameter
+/// Creates SynExpr.LetOrUse for all cases with appropriate flags
 /// Handles all four cases: 'let', 'let!', 'use', and 'use!'
 let mkLetExpression
     (
@@ -1122,7 +1122,7 @@ let mkLetExpression
                 false,
                 isUse, // Pass through the isUse flag from binding info
                 true, // isFromSource is true for user-written code
-                true, // isComputed is true for bang let/let!
+                true, // isComputed is true for let!/use!
                 binding :: decls,
                 body,
                 mWhole,
@@ -1164,7 +1164,7 @@ let mkLetExpression
                 isRec,
                 isUse, // Pass through the isUse flag from binding info
                 true, // isFromSource is true for user-written code
-                false, // isComputed is false for non-bang let/let!
+                false, // isComputed is false for let/use
                 decls,
                 body,
                 mWhole',