@@ -69,8 +69,11 @@ type internal FSharpExtractLetBindingRefactoring [<ImportingConstructor>] () =
                     let indentSize =
                         options.GetOption(FormattingOptions.IndentationSize, FSharpConstants.FSharpLanguageName)
 
+                    let! defines, langVersion = document.GetFsharpParsingOptionsAsync(nameof FSharpExtractLetBindingRefactoring)
                     let names = usedNames parseResults.ParseTree
-                    let literalLines = linesInsideLiterals parseResults.ParseTree
+
+                    let literalLines =
+                        linesInsideLiterals sourceText parseResults.ParseTree defines langVersion
 
                     if isSelected then
                         match anchorsOf target.Expr target.Path with
 
@@ -11,6 +11,7 @@ open Microsoft.CodeAnalysis.Text
 open FSharp.Compiler.Syntax
 open FSharp.Compiler.SyntaxTrivia
 open FSharp.Compiler.Text
+open FSharp.Compiler.Tokenization
 
 /// A place in front of which a declaration used by the selected expression can be inserted.
 [<RequireQualifiedAccess; NoComparison; NoEquality>]
@@ -76,25 +77,107 @@ let restOfLineIsClosers (sourceText: SourceText) (position: pos) =
     code
     |> Seq.forall (fun c -> Char.IsWhiteSpace c || c = ')' || c = ']' || c = '}' || c = '|')
 
-let linesInsideLiterals (parseTree: ParsedInput) =
-    (HashSet<int>(), parseTree)
-    ||> ParsedInput.fold (fun lines _ node ->
-        match node with
-        | SyntaxNode.SynExpr(SynExpr.Const(range = m))
-        | SyntaxNode.SynExpr(SynExpr.InterpolatedString(range = m))
-        | SyntaxNode.SynPat(SynPat.Const(range = m)) ->
-            for line in m.StartLine + 1 .. m.EndLine do
-                lines.Add(Line.toZ line) |> ignore
-        | _ -> ()
+/// Whether a line lexed from this state starts inside a string literal.
+let private continuesString (state: FSharpTokenizerColorState) =
+    match state with
+    | FSharpTokenizerColorState.InitialState
+    | FSharpTokenizerColorState.Token
+    | FSharpTokenizerColorState.IfDefSkip
+    | FSharpTokenizerColorState.EndLineThenSkip
+    | FSharpTokenizerColorState.EndLineThenToken
+    | FSharpTokenizerColorState.Comment
+    | FSharpTokenizerColorState.SingleLineComment
+    | FSharpTokenizerColorState.StringInComment
+    | FSharpTokenizerColorState.VerbatimStringInComment
+    | FSharpTokenizerColorState.TripleQuoteStringInComment -> false
+    // String, VerbatimString, TripleQuoteString and the extended interpolated string state, which the public enum does not name.
+    | _ -> true
+
+let private isSkipped (state: FSharpTokenizerLexState) =
+    match FSharpLineTokenizer.ColorStateOfLexState state with
+    | FSharpTokenizerColorState.IfDefSkip
+    | FSharpTokenizerColorState.EndLineThenSkip -> true
+    | _ -> false
+
+let private startsWithDirective (code: ReadOnlySpan<char>) (keyword: string) =
+    code.StartsWith(keyword.AsSpan(), StringComparison.Ordinal)
+    && (code.Length = keyword.Length
+        || Char.IsWhiteSpace code[keyword.Length]
+        || code[keyword.Length] = '/')
+
+/// Whether the line is a directive the lexer recognizes while it skips an inactive branch.
+let private isSkippedDirective (line: string) =
+    let code = line.AsSpan().TrimStart()
+
+    startsWithDirective code "#if"
+    || startsWithDirective code "#elif"
+    || startsWithDirective code "#else"
+    || startsWithDirective code "#endif"
+
+let private scanLine (tokenizer: FSharpSourceTokenizer) (line: string) (state: FSharpTokenizerLexState) =
+    let lineTokenizer = tokenizer.CreateLineTokenizer line
+
+    let rec loop state =
+        match lineTokenizer.ScanToken state with
+        | Some _, next -> loop next
+        | None, next -> next
+
+    loop state
+
+/// Lines inside multi-line string literals of the branches of `#if` the defines leave inactive. Each run of inactive
+/// lines between two directives is lexed as the code it is when its branch is taken.
+let private linesInsideInactiveLiterals (sourceText: SourceText) (defines: string list) (langVersion: string) (lines: HashSet<int>) =
+    let fileTokenizer = FSharpSourceTokenizer(defines, None, Some langVersion)
+    let branchTokenizer = FSharpSourceTokenizer([], None, Some langVersion)
+    let mutable fileState = FSharpTokenizerLexState.Initial
+    let mutable branchState = FSharpTokenizerLexState.Initial
+
+    for line in sourceText.Lines do
+        let text = line.ToString()
+
+        if isSkipped fileState && not (isSkippedDirective text) then
+            if continuesString (FSharpLineTokenizer.ColorStateOfLexState branchState) then
+                lines.Add line.LineNumber |> ignore
+
+            branchState <- scanLine branchTokenizer text branchState
+        else
+            branchState <- FSharpTokenizerLexState.Initial
+
+        fileState <- scanLine fileTokenizer text fileState
+
+/// Lines inside multi-line string literals, including those in branches of `#if` the defines leave inactive.
+let linesInsideLiterals (sourceText: SourceText) (parseTree: ParsedInput) (defines: string list) (langVersion: string) =
+    let lines =
+        (HashSet<int>(), parseTree)
+        ||> ParsedInput.fold (fun lines _ node ->
+            match node with
+            | SyntaxNode.SynExpr(SynExpr.Const(range = m))
+            | SyntaxNode.SynExpr(SynExpr.InterpolatedString(range = m))
+            | SyntaxNode.SynPat(SynPat.Const(range = m)) ->
+                for line in m.StartLine + 1 .. m.EndLine do
+                    lines.Add(Line.toZ line) |> ignore
+            | _ -> ()
+
+            lines)
+
+    let directives =
+        match parseTree with
+        | ParsedInput.ImplFile file -> file.Trivia.ConditionalDirectives
+        | ParsedInput.SigFile file -> file.Trivia.ConditionalDirectives
+
+    if not directives.IsEmpty then
+        linesInsideInactiveLiterals sourceText defines langVersion lines
 
-        lines)
+    lines
 
 let usedNames (parseTree: ParsedInput) =
     (HashSet<string>(StringComparer.Ordinal), parseTree)
     ||> ParsedInput.fold (fun names _ node ->
         match node with
         | SyntaxNode.SynExpr(SynExpr.Ident ident)
         | SyntaxNode.SynExpr(SynExpr.LongIdent(longDotId = SynLongIdent(id = ident :: _)))
+        | SyntaxNode.SynExpr(SynExpr.LongIdentSet(longDotId = SynLongIdent(id = ident :: _)))
+        | SyntaxNode.SynExpr(SynExpr.NamedIndexedPropertySet(longDotId = SynLongIdent(id = ident :: _)))
         | SyntaxNode.SynPat(SynPat.Named(ident = SynIdent(ident, _)))
         | SyntaxNode.SynPat(SynPat.LongIdent(longDotId = SynLongIdent(id = ident :: _))) -> names.Add ident.idText |> ignore
         | _ -> ()
 
@@ -309,6 +309,62 @@ let ``Lines inside a multi-line string are not re-indented`` () =
 
     Assert.Equal(expected, extracted extractToLetBinding code "String.Format(\"\"\"Hello\n{0}\"\"\", name)")
 
+[<Fact>]
+let ``Lines inside a multi-line string in an inactive branch are not re-indented`` () =
+    // The code contains a triple-quoted string, which a triple-quoted literal cannot hold.
+    let code =
+        "module M\n\nlet r = combine 1 [\n            #if ALT\n            \"\"\"first\n    preserved\n            last\"\"\"\n            #else\n            \"\"\n            #endif\n            ]\n"
+
+    let expected =
+        "module M\n\nlet r =\n    let extracted = 1\n    combine extracted [\n        #if ALT\n        \"\"\"first\n    preserved\n            last\"\"\"\n        #else\n        \"\"\n        #endif\n        ]\n"
+
+    Assert.Equal(expected, extractedAt extractToLetBinding code (TextSpan(code.IndexOf("1 [", StringComparison.Ordinal), 1)))
+
+[<Theory>]
+[<InlineData("let extracted = { Value = 0 }", "extracted.Value <- ")>]
+[<InlineData("let extracted = [| 0 |]", "extracted[0] <- ")>]
+[<InlineData("let mutable extracted = 0", "extracted <- ")>]
+let ``Name does not collide with an assignment target from another file`` (declaration: string, assignment: string) =
+    let dependency =
+        """
+module Dependency
+
+type Box = { mutable Value: int }
+
+DECLARATION
+"""
+            .Replace("DECLARATION", declaration)
+
+    let code =
+        """
+module M
+
+open Dependency
+
+let f () =
+    ASSIGNMENT({ Value = 1 }).Value
+"""
+            .Replace("ASSIGNMENT", assignment)
+
+    let expected =
+        """
+module M
+
+open Dependency
+
+let f () =
+    let extracted1 = { Value = 1 }
+    ASSIGNMENTextracted1.Value
+"""
+            .Replace("ASSIGNMENT", assignment)
+
+    use context = TestContext.CreateWithCodeAndDependency code dependency
+
+    let document =
+        refactorSpan code (selectionOf code "({ Value = 1 })") extractToLetBinding context (new FSharpExtractLetBindingRefactoring())
+
+    Assert.Equal(expected, (document.GetTextAsync() |> GetTaskResult).ToString())
+
 let private greet =
     """
 module M
 
@@ -8,6 +8,8 @@ open Microsoft.CodeAnalysis
 open Microsoft.CodeAnalysis.Text
 open Microsoft.VisualStudio.FSharp.Editor.CancellableTasks
 
+open FSharp.Test.ProjectGeneration
+
 open FSharp.Editor.Tests.Helpers
 open Microsoft.CodeAnalysis.CodeRefactorings
 open Microsoft.CodeAnalysis.CodeActions
@@ -31,11 +33,19 @@ type TestContext(Solution: Solution) =
         new TestContext(solution)
 
     static member CreateWithCodeAndDependency (code: string) (codeForPreviousFile: string) =
-        let mutable solution = RoslynTestHelpers.CreateSolution(codeForPreviousFile)
-
-        let firstProject = solution.Projects.First()
-        solution <- solution.AddDocument(DocumentId.CreateNewId(firstProject.Id), "test2.fs", code, filePath = "C:\\test2.fs")
-
+        let project =
+            { SyntheticProject.Create(
+                  { sourceFile "First" [] with
+                      Source = codeForPreviousFile
+                  },
+                  { sourceFile "Second" [ "First" ] with
+                      Source = code
+                  }
+              ) with
+                AutoAddModules = false
+            }
+
+        let solution, _ = RoslynTestHelpers.CreateSolution project
         new TestContext(solution)
 
 let tryRefactor (code: string) (cursorPosition) (context: TestContext) (refactorProvider: 'T :> CodeRefactoringProvider) =