Add warning FS3885 for let-in with multi-line body in sequence expressions

docs/release-notes/.FSharp.Compiler.Service/11.0.100.md

@@ -22,3 +22,4 @@
 
 * Added warning FS3884 when a function or delegate value is used as an interpolated string argument. ([PR #19289](https://github.com/dotnet/fsharp/pull/19289))
 * Add `#version;;` directive to F# Interactive to display version and environment information. ([Issue #13307](https://github.com/dotnet/fsharp/issues/13307), [PR #19332](https://github.com/dotnet/fsharp/pull/19332))
+* Added warning FS3885 when `let ... in` with explicit `in` keyword has a body that extends to subsequent lines, which causes all subsequent lines to become part of the `let` body due to the parser's greedy behavior. ([Issue #7741](https://github.com/dotnet/fsharp/issues/7741), [PR #19501](https://github.com/dotnet/fsharp/pull/19501))

docs/release-notes/.Language/preview.md

@@ -2,6 +2,7 @@
 
 * Warn (FS3884) when a function or delegate value is used as an interpolated string argument, since it will be formatted via `ToString` rather than being applied. ([PR #19289](https://github.com/dotnet/fsharp/pull/19289))
 * Added `MethodOverloadsCache` language feature (preview) that caches overload resolution results for repeated method calls, significantly improving compilation performance. ([PR #19072](https://github.com/dotnet/fsharp/pull/19072))
+* Warn (FS3885) when `let ... in` with explicit `in` keyword has a body that extends to subsequent lines, causing unexpected scoping. ([Issue #7741](https://github.com/dotnet/fsharp/issues/7741), [PR #19501](https://github.com/dotnet/fsharp/pull/19501))
 
 ### Fixed
 

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -6041,6 +6041,16 @@ and TcExprUndelayed (cenv: cenv) (overallTy: OverallTy) env tpenv (synExpr: SynE
             errorR(Error(FSComp.SR.tcConstructRequiresComputationExpression(), leadingKeyword.Range))
         | _ -> ()
 
+        // Warn when 'let ... in' has an explicit 'in' keyword and the body is a sequential expression
+        // spanning multiple lines. This indicates the user likely intended the 'let ... in' to scope only
+        // over the expression on the same line, but the parser greedily consumed subsequent lines as body.
+        match letOrUse with
+        | { Trivia = { InKeyword = Some inRange }; Body = SynExpr.Sequential(expr2 = expr2) }
+            when g.langVersion.SupportsFeature LanguageFeature.WarnOnLetInSequenceExpression
+                 && expr2.Range.StartLine > inRange.StartLine ->
+            warning(Error(FSComp.SR.tcLetExpressionWithInHasMultiLineBody(), inRange))
+        | _ -> ()
+
         TcLinearExprs (TcExprThatCanBeCtorBody cenv) cenv env overallTy tpenv false synExpr id
 
     | SynExpr.TryWith (synBodyExpr, synWithClauses, mTryToLast, spTry, spWith, trivia) ->

src/Compiler/FSComp.txt

@@ -1809,8 +1809,10 @@ featureWarnWhenFunctionValueUsedAsInterpolatedStringArg,"Warn when a function va
 featureMethodOverloadsCache,"Support for caching method overload resolution results for improved compilation performance."
 featureImplicitDIMCoverage,"Implicit dispatch slot coverage for default interface member implementations"
 featurePreprocessorElif,"#elif preprocessor directive"
+featureWarnOnLetInSequenceExpression,"Warn when 'let ... in' is used in a sequence expression and the body extends to subsequent lines"
 3880,optsLangVersionOutOfSupport,"Language version '%s' is out of support. The last .NET SDK supporting it is available at https://dotnet.microsoft.com/en-us/download/dotnet/%s"
 3881,optsUnrecognizedLanguageFeature,"Unrecognized language feature name: '%s'. Use a valid feature name such as 'NameOf' or 'StringInterpolation'."
 3882,lexHashElifMustBeFirst,"#elif directive must appear as the first non-whitespace character on a line"
 3883,lexHashElifMustHaveIdent,"#elif directive should be immediately followed by an identifier"
 3884,tcFunctionValueUsedAsInterpolatedStringArg,"This expression is a function value. When used in an interpolated string it will be formatted using its 'ToString' method, which is likely not the intended behavior. Consider applying the function to its arguments."
+3885,tcLetExpressionWithInHasMultiLineBody,"The use of 'in' in 'let ... in' on a single line followed by additional code on subsequent lines causes all subsequent lines to be part of the 'let' body. This may lead to unexpected scoping. Either remove the 'in' keyword and rely on indentation, or add parentheses to clarify the intended scope."

src/Compiler/Facilities/LanguageFeatures.fs

@@ -108,6 +108,7 @@ type LanguageFeature =
     | MethodOverloadsCache
     | ImplicitDIMCoverage
     | PreprocessorElif
+    | WarnOnLetInSequenceExpression
 
 /// LanguageVersion management
 type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array) =
@@ -251,6 +252,7 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array)
                 // Put stabilized features here for F# 11.0 previews via .NET SDK preview channels
                 LanguageFeature.WarnWhenFunctionValueUsedAsInterpolatedStringArg, languageVersion110
                 LanguageFeature.PreprocessorElif, languageVersion110
+                LanguageFeature.WarnOnLetInSequenceExpression, languageVersion110
 
                 // Difference between languageVersion110 and preview - 11.0 gets turned on automatically by picking a preview .NET 11 SDK
                 // previewVersion is only when "preview" is specified explicitly in project files  and users also need a preview SDK
@@ -453,6 +455,7 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array)
         | LanguageFeature.MethodOverloadsCache -> FSComp.SR.featureMethodOverloadsCache ()
         | LanguageFeature.ImplicitDIMCoverage -> FSComp.SR.featureImplicitDIMCoverage ()
         | LanguageFeature.PreprocessorElif -> FSComp.SR.featurePreprocessorElif ()
+        | LanguageFeature.WarnOnLetInSequenceExpression -> FSComp.SR.featureWarnOnLetInSequenceExpression ()
 
     /// Get a version string associated with the given feature.
     static member GetFeatureVersionString feature =

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -99,6 +99,7 @@ type LanguageFeature =
     | MethodOverloadsCache
     | ImplicitDIMCoverage
     | PreprocessorElif
+    | WarnOnLetInSequenceExpression
 
 /// LanguageVersion management
 type LanguageVersion =

src/Compiler/Interactive/fsi.fs

@@ -1532,7 +1532,7 @@ type internal FsiConsoleInput
 
     /// Try to get the first line, if we snarfed it while probing.
     member _.TryGetFirstLine() =
-        let r = firstLine in
+        let r = firstLine
         firstLine <- None
         r
 

src/Compiler/Utilities/HashMultiMap.fs

@@ -169,7 +169,7 @@ type internal HashMultiMap<'Key, 'Value when 'Key: not null>(size: int, comparer
             | _ -> false
 
         member s.Remove(k: 'Key) =
-            let res = s.ContainsKey(k) in
+            let res = s.ContainsKey(k)
             s.Remove(k)
             res