자동 포멧팅 기능 개선

letspurify-ux · letspurify-ux · commit 27decd7c3dc5 · 2026-07-19T17:50:52.000+09:00
diff --git a/src/ui/main_window.rs b/src/ui/main_window.rs
@@ -1832,7 +1832,27 @@ impl AppState {
         self.set_tab_dirty(tab_id, is_dirty);
     }
 
-    fn on_tab_buffer_modified(&mut self, tab_id: QueryTabId, ins: i32, del: i32, buf: &TextBuffer) {
+    fn dirty_state_from_equal_length_local_edit(
+        pristine_text: &str,
+        was_dirty: bool,
+        start: usize,
+        inserted_text: &str,
+    ) -> Option<bool> {
+        let end = start.saturating_add(inserted_text.len());
+        if pristine_text.get(start..end) != Some(inserted_text) {
+            return Some(true);
+        }
+        (!was_dirty).then_some(false)
+    }
+
+    fn on_tab_buffer_modified(
+        &mut self,
+        tab_id: QueryTabId,
+        pos: i32,
+        ins: i32,
+        del: i32,
+        buf: &TextBuffer,
+    ) {
         let Some(index) = self.find_tab_index(tab_id) else {
             return;
         };
@@ -1850,6 +1870,19 @@ impl AppState {
             return;
         }
 
+        let start = pos.max(0) as usize;
+        let inserted_end = pos.saturating_add(ins.max(0)).min(buf.length());
+        let inserted_text = buf.text_range(pos.max(0), inserted_end).unwrap_or_default();
+        if let Some(is_dirty) = Self::dirty_state_from_equal_length_local_edit(
+            &tab.pristine_text,
+            tab.is_dirty,
+            start,
+            &inserted_text,
+        ) {
+            self.set_tab_dirty(tab_id, is_dirty);
+            return;
+        }
+
         let current_text = buf.text();
         self.refresh_tab_dirty_from_text(tab_id, &current_text);
     }
@@ -7273,12 +7306,12 @@ impl MainWindow {
 
         let weak_state_for_dirty = Arc::downgrade(state);
         let mut buffer_for_dirty = editor.get_buffer();
-        buffer_for_dirty.add_modify_callback2(move |buf, _pos, ins, del, _restyled, _deleted| {
+        buffer_for_dirty.add_modify_callback2(move |buf, pos, ins, del, _restyled, _deleted| {
             let Some(state_for_dirty) = weak_state_for_dirty.upgrade() else {
                 return;
             };
             if let Ok(mut s) = state_for_dirty.try_lock() {
-                s.on_tab_buffer_modified(tab_id, ins, del, buf)
+                s.on_tab_buffer_modified(tab_id, pos, ins, del, buf)
             };
         });
     }
@@ -9493,6 +9526,48 @@ mod tests {
     use fltk::enums::{Key, Shortcut};
     use std::sync::{Arc, Mutex};
 
+    #[test]
+    fn equal_length_paste_avoids_full_dirty_scan_when_local_bytes_decide_state() {
+        let pristine = "SELECT employee_name FROM employees;";
+        let start = pristine.find("employee_name").expect("column name");
+
+        assert_eq!(
+            AppState::dirty_state_from_equal_length_local_edit(
+                pristine,
+                false,
+                start,
+                "employee_name",
+            ),
+            Some(false)
+        );
+        assert_eq!(
+            AppState::dirty_state_from_equal_length_local_edit(
+                pristine,
+                false,
+                start,
+                "department_id",
+            ),
+            Some(true)
+        );
+        assert_eq!(
+            AppState::dirty_state_from_equal_length_local_edit(
+                pristine,
+                true,
+                start,
+                "department_id",
+            ),
+            Some(true)
+        );
+    }
+
+    #[test]
+    fn equal_length_edit_scans_fully_only_when_it_may_restore_pristine_text() {
+        assert_eq!(
+            AppState::dirty_state_from_equal_length_local_edit("SELECT 1;", true, 7, "1"),
+            None
+        );
+    }
+
     #[test]
     fn resolve_window_shortcut_prefers_current_key_match() {
         let action = MainWindow::resolve_window_shortcut_action(
diff --git a/src/ui/sql_editor/highlighting.rs b/src/ui/sql_editor/highlighting.rs
@@ -8,6 +8,8 @@ use crate::ui::syntax_highlight::HighlightWordAudit;
 
 const DEFERRED_REHIGHLIGHT_IDLE_DELAY_SECONDS: f64 = 0.15;
 const SEMANTIC_REHIGHLIGHT_OVERSCAN_LINES: usize = 100;
+const LARGE_DOCUMENT_PASTE_LINE_THRESHOLD: usize = 100_000;
+const LARGE_PASTE_DEFER_SEMANTIC_BYTES: usize = 64 * 1024;
 // Keep semantic alias work independent of the total document size. The window
 // is renewed only if lexical-state propagation carries highlighting beyond it.
 const LOCAL_ALIAS_CONTEXT_LOOKAROUND_BYTES: usize = 16 * 1024;
@@ -99,6 +101,14 @@ struct BoundedAliasContext {
     end: usize,
 }
 
+fn should_defer_semantic_alias_context_for_insert(
+    line_count: usize,
+    inserted_text: &str,
+) -> bool {
+    inserted_text.len() >= LARGE_PASTE_DEFER_SEMANTIC_BYTES
+        || (line_count >= LARGE_DOCUMENT_PASTE_LINE_THRESHOLD && inserted_text.len() > 1)
+}
+
 impl BoundedAliasContext {
     fn covers(&self, start: usize, end: usize) -> bool {
         start >= self.start && end <= self.end
@@ -769,25 +779,6 @@ impl SqlEditorWidget {
         self.rehighlight_full_buffer();
     }
 
-    fn handle_buffer_highlight_update(
-        &self,
-        buf: &TextBuffer,
-        pos: i32,
-        ins: i32,
-        del: i32,
-        deleted_text: &str,
-    ) {
-        let inserted_text = inserted_text(buf, &self.highlight_shadow, pos, ins);
-        self.handle_buffer_highlight_update_with_known_inserted_text(
-            buf,
-            pos,
-            ins,
-            del,
-            &inserted_text,
-            deleted_text,
-        );
-    }
-
     fn handle_buffer_highlight_update_with_known_inserted_text(
         &self,
         buf: &TextBuffer,
@@ -828,7 +819,7 @@ impl SqlEditorWidget {
             return;
         }
 
-        let updated = {
+        let (updated, defer_semantic_alias_context) = {
             let mut shadow = self
                 .highlight_shadow
                 .lock()
@@ -847,18 +838,27 @@ impl SqlEditorWidget {
                 return;
             }
 
-            self.apply_main_thread_incremental_highlighting(
-                &mut shadow,
-                &mut style_buffer,
-                shadow_pos,
-                inserted_text.len(),
-                del.max(0) as usize,
-                inserted_text,
-                deleted_text,
+            let defer_semantic_alias_context =
+                should_defer_semantic_alias_context_for_insert(shadow.line_count(), inserted_text);
+            (
+                self.apply_main_thread_incremental_highlighting(
+                    &mut shadow,
+                    &mut style_buffer,
+                    shadow_pos,
+                    inserted_text.len(),
+                    del.max(0) as usize,
+                    inserted_text,
+                    deleted_text,
+                    defer_semantic_alias_context,
+                ),
+                defer_semantic_alias_context,
             )
         };
         match updated {
             Some(true) | Some(false) => {
+                if defer_semantic_alias_context {
+                    self.schedule_deferred_visible_semantic_rehighlight();
+                }
                 self.redraw_editor_if_live();
             }
             None => self.rehighlight_full_buffer(),
@@ -892,6 +892,7 @@ impl SqlEditorWidget {
         del: usize,
         inserted_text: &str,
         deleted_text: &str,
+        defer_semantic_alias_context: bool,
     ) -> Option<bool> {
         let text_len = shadow.len();
         if text_len == 0 {
@@ -909,8 +910,15 @@ impl SqlEditorWidget {
         let mut current_line_idx = shadow.line_index_for_position(start);
         let mut entry_state = shadow.entry_state_for_line(current_line_idx);
         let mut changed_range: Option<(usize, usize)> = None;
-        let mut alias_context =
-            shadow.bounded_alias_context(start, must_cover_end, mysql_compatible);
+        let mut alias_context = if defer_semantic_alias_context {
+            BoundedAliasContext {
+                context: Arc::new(super::query_text::LocalAliasContext::default()),
+                start: 0,
+                end: text_len,
+            }
+        } else {
+            shadow.bounded_alias_context(start, must_cover_end, mysql_compatible)
+        };
 
         while current_line_idx < shadow.line_count() {
             let current_start = shadow.line_start_for_index(current_line_idx);
@@ -1163,6 +1171,23 @@ mod tests {
     use super::*;
     use crate::ui::syntax_highlight::SqlHighlighter;
 
+    #[test]
+    fn large_document_paste_defers_only_semantic_alias_work() {
+        assert!(should_defer_semantic_alias_context_for_insert(
+            LARGE_DOCUMENT_PASTE_LINE_THRESHOLD,
+            "ab"
+        ));
+        assert!(!should_defer_semantic_alias_context_for_insert(
+            LARGE_DOCUMENT_PASTE_LINE_THRESHOLD,
+            "a"
+        ));
+        assert!(should_defer_semantic_alias_context_for_insert(
+            10,
+            &"x".repeat(LARGE_PASTE_DEFER_SEMANTIC_BYTES)
+        ));
+        assert!(!should_defer_semantic_alias_context_for_insert(10, "SELECT"));
+    }
+
     #[test]
     fn incremental_direct_rehighlight_end_returns_zero_for_empty_text() {
         let shadow = HighlightShadowState::default();
diff --git a/src/ui/sql_editor/intellisense_host.rs b/src/ui/sql_editor/intellisense_host.rs
@@ -251,20 +251,60 @@ impl SqlEditorWidget {
         let mut buffer = self.buffer.clone();
         let widget = self.clone();
         let intellisense_runtime = self.intellisense_runtime.clone();
+        let undo_state = self.undo_redo_state.clone();
+        let applying_history_navigation = self.applying_history_navigation.clone();
         let suppress_buffer_callbacks = self.suppress_buffer_callbacks.clone();
         buffer.add_modify_callback2(move |buf, pos, ins, del, _restyled, deleted_text| {
             if ins <= 0 && del <= 0 {
                 return;
             }
+            crate::ui::sql_editor::ime_trace(|| {
+                format!(
+                    "modify pos={pos} ins={ins} del={del} deleted_text={deleted_text:?} \
+                     compose_state={} selection={:?}",
+                    fltk::app::compose_state(),
+                    buf.selection_position(),
+                )
+            });
             if load_mutex_bool(&suppress_buffer_callbacks) {
                 return;
             }
+            let edit = BufferEdit {
+                start: pos.max(0) as usize,
+                deleted_len: del.max(0) as usize,
+                inserted_text: inserted_text(buf, pos, ins),
+                // record_edit reads the authoritative deleted bytes from its
+                // persistent pre-edit snapshot.
+                deleted_text: String::new(),
+            };
+
+            let is_applying_navigation = *applying_history_navigation
+                .lock()
+                .unwrap_or_else(|poisoned| poisoned.into_inner());
+            if !is_applying_navigation {
+                let mut state = undo_state
+                    .lock()
+                    .unwrap_or_else(|poisoned| poisoned.into_inner());
+                if !state.applying_history {
+                    let edit_group =
+                        classify_edit_group(ins, del, &edit.inserted_text, deleted_text);
+                    state.record_edit(&edit, edit_group);
+                }
+            }
+
             intellisense_runtime.apply_buffer_edit(
                 pos.max(0) as usize,
                 ins.max(0) as usize,
                 del.max(0) as usize,
             );
-            widget.handle_buffer_highlight_update(buf, pos, ins, del, deleted_text);
+            widget.handle_buffer_highlight_update_with_known_inserted_text(
+                buf,
+                pos,
+                ins,
+                del,
+                &edit.inserted_text,
+                deleted_text,
+            );
         });
     }
 
diff --git a/src/ui/sql_editor/mod.rs b/src/ui/sql_editor/mod.rs
@@ -2491,7 +2491,6 @@ impl SqlEditorWidget {
         };
 
         widget.setup_intellisense();
-        widget.setup_word_undo_redo();
         widget.setup_syntax_highlighting();
         widget.sync_db_type_from_connection();
         widget.setup_progress_handler(progress_receiver, progress_callback, query_running);
@@ -5050,7 +5049,7 @@ mod execution_state_tests {
         classify_edit_group, inserted_text, load_mutex_bool, load_mutex_bool_option,
         try_mark_query_running, BufferEdit, EditGranularity, EditOperation, HighlightShadowState,
         IntellisenseRuntimeState, QueryProgress, SqlEditorWidget, UndoDelta, UndoSnapshot,
-        WordUndoRedoState, MAX_WORD_UNDO_HISTORY, STYLE_DEFAULT,
+        WordUndoRedoState, MAX_WORD_UNDO_HISTORY,
     };
     use fltk::enums::Event;
     use fltk::text::TextBuffer;
@@ -5422,17 +5421,10 @@ mod execution_state_tests {
         let mut buffer = TextBuffer::default();
         buffer.set_text(original);
 
-        let styles = std::iter::repeat_n(STYLE_DEFAULT, original.len()).collect::<String>();
-        let shadow = Arc::new(Mutex::new(HighlightShadowState::default()));
-        shadow
-            .lock()
-            .unwrap_or_else(|poisoned| poisoned.into_inner())
-            .rebuild(original.to_string(), &styles, Vec::new());
-
         let pos = original.find("a FROM").unwrap_or(0);
         buffer.replace(pos as i32, pos.saturating_add(1) as i32, "'");
 
-        assert_eq!(inserted_text(&buffer, &shadow, pos as i32, 1), "'");
+        assert_eq!(inserted_text(&buffer, pos as i32, 1), "'");
     }
 
     #[test]
diff --git a/src/ui/sql_editor/undo_history.rs b/src/ui/sql_editor/undo_history.rs
