Improve handling for multiline strings

This change always breaks before a multiline string and ensures the
surrounding code is appropriately broken too.

Author: jgardn3r

CHANGELOG.md

@@ -16,6 +16,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Changed
 
 - Unterminated string literals will never mangle other tokens.
+- Improved support for multiline strings.
 
 ## [0.5.1] - 2025-06-02
 

core/CHANGELOG.md

@@ -27,6 +27,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Conditional directive parsing now uses a greedy algorithm that avoids the exponential
   performance issues with the old algorithm.
 - Unterminated string literals will never mangle other tokens by always breaking after.
+- Improved support for multiline strings. They will now always break before, and
+  break surrounding contexts.
 
 ## 0.5.1 - 2025-06-02
 

core/datatests/generators/optimising_line_formatter.rs

@@ -4672,6 +4672,78 @@ mod expressions {
                         '
                         ;
                 ",
+                multiline = "
+                    A :=
+                        '''
+                        ''';
+                    A :=
+                        '''
+                        '''
+                            + BB
+                            + CC;
+                    A :=
+                        '''
+                        '''[11111 + 11111 + 1111];
+                    A :=
+                        '''
+                        '''[
+                            11111 + 11111 + 11111
+                        ];
+                    A :=
+                        '''
+                        '''.B(1111 + 1111 + 1111);
+                    A :=
+                        '''
+                        '''.B(
+                            11111 + 11111 + 11111
+                        );
+                    A :=
+                        B(
+                            '''
+                            '''
+                        );
+                    A :=
+                        B(
+                            C,
+                            '''
+                            ''',
+                            D
+                        );
+                    A :=
+                        B(
+                            C,
+                            '''
+                            '''
+                                +
+                                '''
+                            ''',
+                            D
+                        );
+                ",
+                multiline_diff = {
+                    "
+                    A :=
+                    '''
+                         ''';
+                    A := '''
+                              '''.B(11 + 11 + 11);
+                    A :=
+                    '''
+                               '''.B(11 + 11 + 11);
+                    ",
+                    "
+                    A :=
+                        '''
+                         ''';
+                    A :=
+                        '''
+                              '''.B(11 + 11 + 11);
+                    A :=
+                        '''
+                               '''
+                            .B(11 + 11 + 11);
+                    "
+                }
             );
         }
     }

core/src/defaults/reconstructor.rs

@@ -1,5 +1,7 @@
 use std::cmp::Ordering;
 
+use itertools::Itertools;
+
 use crate::{
     formatter::Cursor,
     lang::*,
@@ -17,6 +19,7 @@ impl DelphiLogicalLinesReconstructor {
     }
 }
 
+#[derive(Debug)]
 struct InternalCursor<'cursor> {
     cursor: &'cursor mut Cursor,
     tok_idx: usize,
@@ -28,6 +31,7 @@ struct CursorTrackerImpl<'cursor> {
     cursors: Vec<InternalCursor<'cursor>>,
 }
 
+#[derive(Debug)]
 enum TokPos {
     /// Position of a cursor inside a token
     InContent {
@@ -265,6 +269,7 @@ impl CursorTracker for CursorTrackerImpl<'_> {
     }
 
     fn relocate_cursors(&mut self, formatted_tokens: &FormattedTokens) {
+        dbg!(&self.cursors);
         for cursor in &mut self.cursors {
             let token = match formatted_tokens.get_token(cursor.tok_idx) {
                 Some(t) => t,
@@ -698,8 +703,11 @@ A = 1 + {
 
 } | | | | | | | | A;
 
-A = 1     + '''
-''' + | | | | Spaces;",
+A := 1     + '''
+'''  + | | | | |Spaces;
+
+A := 1     + '''
+    '''  + | | | | | Spaces;",
                 "\
 A
     = 1
@@ -709,8 +717,19 @@ A
 }
   | | | | | | ||A;
 
-A = 1 + '''
-''' + | | | |  Spaces;",
+A :=
+    1
+        +
+        '''
+'''
+        +||| |     |Spaces;
+
+A :=
+    1
+        +
+        '''
+    '''
+        +  | | | | |Spaces;",
             );
         }
     }

core/src/rules/optimising_line_formatter/contexts.rs

@@ -445,6 +445,14 @@ impl<'a> SpecificContextStack<'a> {
 
         let curr_token_type = self.get_token_type_from_line_index(line_index);
         match (last_real_token_type, curr_token_type) {
+            (_, Some(TT::TextLiteral(TextLiteralKind::MultiLine))) => {
+                // There is necessarily a break within a multiline string
+                // literal so contexts must be updated accordingly
+                self.update_last_matching_context(node, context_matches!(_), |_, data| {
+                    data.is_broken = true;
+                });
+                self.update_operator_precedences(node, true);
+            }
             (_, Some(TT::Comment(CommentKind::InlineBlock | CommentKind::InlineLine))) => {
                 /*
                     When formatting comments, there are some considerations to be made:

core/src/rules/optimising_line_formatter/requirements.rs

@@ -339,11 +339,14 @@ impl InternalOptimisingLineFormatter<'_, '_> {
             }
             (
                 _,
-                Some(TT::Comment(
-                    CommentKind::IndividualLine
-                    | CommentKind::IndividualBlock
-                    | CommentKind::MultilineBlock,
-                )),
+                Some(
+                    TT::Comment(
+                        CommentKind::IndividualLine
+                        | CommentKind::IndividualBlock
+                        | CommentKind::MultilineBlock,
+                    )
+                    | TT::TextLiteral(TextLiteralKind::MultiLine),
+                ),
             ) => Some(DR::MustBreak),
             (
                 Some(