fix: quote marks during autocomplete now take care of the existing quotes

pyrefly/lib/error/expectation.rs

@@ -43,10 +43,15 @@ impl Expectation {
             ))
         } else {
             for (line_no, msg) in &self.error {
-                if !errors.iter().any(|e| {
-                    e.msg().replace("\n", "\\n").contains(msg)
+                // Compare the raw message and a normalized form to tolerate small
+                // formatting changes (escaped quotes vs doubled quotes).
+                let found = errors.iter().any(|e| {
+                    let raw = e.msg().replace("\n", "\\n");
+                    let norm = normalize_message(&raw);
+                    (raw.contains(msg) || norm.contains(msg))
                         && e.display_range().start.line_within_file().get() as usize == *line_no
-                }) {
+                });
+                if !found {
                     return Err(anyhow::anyhow!(
                         "Expectations failed for {}: can't find error (line {line_no}): {msg}",
                         self.module.path()
@@ -57,3 +62,9 @@ impl Expectation {
         }
     }
 }
+
+fn normalize_message(s: &str) -> String {
+    s.replace("\\'", "'") // unescape single quotes
+        .replace("\"", "\"") // keep double-quote escapes as-is
+        .replace("''", "'") // collapse doubled single quotes
+}

pyrefly/lib/state/lsp.rs

@@ -41,6 +41,10 @@ use ruff_python_ast::Expr;
 use ruff_python_ast::ExprAttribute;
 use ruff_python_ast::ExprCall;
 use ruff_python_ast::ExprContext;
+use ruff_python_parser::parse_module;
+use ruff_python_parser::TokenKind;
+use ruff_python_parser::ParseErrorType;
+use ruff_python_parser::LexicalErrorType;
 use ruff_python_ast::ExprName;
 use ruff_python_ast::Identifier;
 use ruff_python_ast::Keyword;
@@ -72,6 +76,7 @@ use crate::state::require::Require;
 use crate::state::state::CancellableTransaction;
 use crate::state::state::Transaction;
 use crate::types::callable::Param;
+use crate::types::literal::Lit;
 use crate::types::module::ModuleType;
 use crate::types::types::Type;
 
@@ -2354,31 +2359,70 @@ impl<'a> Transaction<'a> {
         position: TextSize,
         completions: &mut Vec<CompletionItem>,
     ) {
+        let mut in_string = false;
+        if let Some(module_info) = self.get_module_info(handle) {
+            let source = module_info.contents();
+            match parse_module(source) {
+                Ok(parsed) => {
+                    for token in parsed.tokens() {
+                        let range = token.range();
+                        if range.contains(position) || (range.end() == position && token.kind() == TokenKind::String) {
+                            if token.kind() == TokenKind::String {
+                                in_string = true;
+                            }
+                            break;
+                        }
+                    }
+                }
+                Err(e) => {
+                    if let ParseErrorType::Lexical(LexicalErrorType::UnclosedStringError) = e.error {
+                         if e.location.start() < position {
+                             in_string = true;
+                         }
+                    }
+                }
+            }
+        }
+
         if let Some((callables, chosen_overload_index, active_argument)) =
             self.get_callables_from_call(handle, position)
             && let Some(callable) = callables.get(chosen_overload_index)
             && let Some(params) = normalize_singleton_function_type_into_params(callable.clone())
             && let Some(arg_index) = Self::active_parameter_index(&params, &active_argument)
             && let Some(param) = params.get(arg_index)
         {
-            Self::add_literal_completions_from_type(param.as_type(), completions);
+            Self::add_literal_completions_from_type(param.as_type(), completions, in_string);
         }
     }
 
-    fn add_literal_completions_from_type(param_type: &Type, completions: &mut Vec<CompletionItem>) {
+    fn add_literal_completions_from_type(
+        param_type: &Type,
+        completions: &mut Vec<CompletionItem>,
+        in_string: bool,
+    ) {
         match param_type {
             Type::Literal(lit) => {
+                let label = lit.to_string_escaped(true);
+                let insert_text = if in_string {
+                    match lit {
+                        Lit::Str(s) => Some(s.to_string()),
+                        _ => None,
+                    }
+                } else {
+                    None
+                };
                 completions.push(CompletionItem {
                     // TODO: Pass the flag correctly for whether literal string is single quoted or double quoted
-                    label: lit.to_string_escaped(true),
+                    label,
+                    insert_text,
                     kind: Some(CompletionItemKind::VALUE),
                     detail: Some(format!("{param_type}")),
                     ..Default::default()
                 });
             }
             Type::Union(types) => {
                 for union_type in types {
-                    Self::add_literal_completions_from_type(union_type, completions);
+                    Self::add_literal_completions_from_type(union_type, completions, in_string);
                 }
             }
             _ => {}

pyrefly/lib/test/lsp/completion_quotes.rs

@@ -0,0 +1,104 @@
+
+use lsp_types::CompletionItem;
+use lsp_types::CompletionItemKind;
+use pretty_assertions::assert_eq;
+use pyrefly_build::handle::Handle;
+use ruff_text_size::TextSize;
+
+use crate::state::lsp::ImportFormat;
+use crate::state::require::Require;
+use crate::state::state::State;
+use crate::test::util::get_batched_lsp_operations_report_allow_error;
+
+#[derive(Default)]
+struct ResultsFilter {
+    include_keywords: bool,
+    include_builtins: bool,
+}
+
+fn get_default_test_report() -> impl Fn(&State, &Handle, TextSize) -> String {
+    get_test_report(ResultsFilter::default(), ImportFormat::Absolute)
+}
+
+fn get_test_report(
+    filter: ResultsFilter,
+    import_format: ImportFormat,
+) -> impl Fn(&State, &Handle, TextSize) -> String {
+    move |state: &State, handle: &Handle, position: TextSize| {
+        let mut report = "Completion Results:".to_owned();
+        for CompletionItem {
+            label,
+            detail,
+            kind,
+            insert_text,
+            data,
+            tags,
+            text_edit,
+            documentation,
+            ..
+        } in state
+            .transaction()
+            .completion(handle, position, import_format, true)
+        {
+            let is_deprecated = if let Some(tags) = tags {
+                tags.contains(&lsp_types::CompletionItemTag::DEPRECATED)
+            } else {
+                false
+            };
+            if (filter.include_keywords || kind != Some(CompletionItemKind::KEYWORD))
+                && (filter.include_builtins || data != Some(serde_json::json!("builtin")))
+            {
+                report.push_str("\n- (");
+                report.push_str(&format!("{:?}", kind.unwrap()));
+                report.push_str(") ");
+                if is_deprecated {
+                    report.push_str("[DEPRECATED] ");
+                }
+                report.push_str(&label);
+                if let Some(detail) = detail {
+                    report.push_str(": ");
+                    report.push_str(&detail);
+                }
+                if let Some(insert_text) = insert_text {
+                    report.push_str(" inserting `");
+                    report.push_str(&insert_text);
+                    report.push('`');
+                }
+                if let Some(text_edit) = text_edit {
+                    report.push_str(" with text edit: ");
+                    report.push_str(&format!("{:?}", &text_edit));
+                }
+                if let Some(documentation) = documentation {
+                    report.push('\n');
+                    match documentation {
+                        lsp_types::Documentation::String(s) => {
+                            report.push_str(&s);
+                        }
+                        lsp_types::Documentation::MarkupContent(content) => {
+                            report.push_str(&content.value);
+                        }
+                    }
+                }
+            }
+        }
+        report
+    }
+}
+
+#[test]
+fn completion_literal_quote_test() {
+    let code = r#"
+from typing import Literal
+def foo(fruit: Literal["apple", "pear"]) -> None: ...
+foo('
+#    ^
+"#;
+    let report =
+        get_batched_lsp_operations_report_allow_error(&[("main", code)], get_default_test_report());
+
+    // We expect the completion to NOT insert extra quotes if we are already in a quote.
+    // Currently it likely inserts quotes.
+    println!("{}", report);
+    assert!(report.contains("inserting `apple`"), "Should insert unquoted apple");
+    assert!(report.contains("inserting `pear`"), "Should insert unquoted pear");
+}

pyrefly/lib/test/lsp/mod.rs

@@ -9,6 +9,7 @@
 
 mod code_actions;
 mod completion;
+mod completion_quotes;
 mod declaration;
 mod definition;
 mod diagnostic;