Merge branch 'main' into use-value-for-completion

Darshan808 · web-flow · commit 4240389b6940 · 2025-11-28T15:57:45.000+05:45
diff --git a/IPython/core/completer.py b/IPython/core/completer.py
@@ -2213,6 +2213,17 @@ def file_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
         #  starts with `/home/`, `C:\`, etc)
 
         text = context.token
+        code_until_cursor = self._extract_code(context.text_until_cursor)
+        completion_type = self._determine_completion_context(code_until_cursor)
+        in_cli_context = self._is_completing_in_cli_context(code_until_cursor)
+        if (
+            completion_type == self._CompletionContextType.ATTRIBUTE
+            and not in_cli_context
+        ):
+            return {
+                "completions": [],
+                "suppress": False,
+            }
 
         # chars that require escaping with backslash - i.e. chars
         # that readline treats incorrectly as delimiters, but we
@@ -2482,8 +2493,9 @@ def _jedi_matcher(self, context: CompletionContext) -> _JediMatcherResult:
         )
         return {
             "completions": matches,
-            # static analysis should not suppress other matchers
-            "suppress": {_get_matcher_id(self.file_matcher)} if matches else False,
+            # static analysis should not suppress other matcher
+            # NOTE: file_matcher is automatically suppressed on attribute completions
+            "suppress": False,
         }
 
     def _jedi_matches(
@@ -2599,12 +2611,47 @@ def _determine_completion_context(self, line):
             return self._CompletionContextType.GLOBAL
 
         # Handle all other attribute matches np.ran, d[0].k, (a,b).count
-        chain_match = re.search(r".*(.+\.(?:[a-zA-Z]\w*)?)$", line)
+        chain_match = re.search(r".*(.+(?<!\s)\.(?:[a-zA-Z]\w*)?)$", line)
         if chain_match:
             return self._CompletionContextType.ATTRIBUTE
 
         return self._CompletionContextType.GLOBAL
 
+    def _is_completing_in_cli_context(self, text: str) -> bool:
+        """
+        Determine if we are completing in a CLI alias, line magic, or bang expression context.
+        """
+        stripped = text.lstrip()
+        if stripped.startswith("!") or stripped.startswith("%"):
+            return True
+        # Check for CLI aliases
+        try:
+            tokens = stripped.split(None, 1)
+            if not tokens:
+                return False
+            first_token = tokens[0]
+
+            # Must have arguments after the command for this to apply
+            if len(tokens) < 2:
+                return False
+
+            # Check if first token is a known alias
+            if not any(
+                alias[0] == first_token for alias in self.shell.alias_manager.aliases
+            ):
+                return False
+
+            try:
+                if first_token in self.shell.user_ns:
+                    # There's a variable defined, so the alias is overshadowed
+                    return False
+            except (AttributeError, KeyError):
+                pass
+
+            return True
+        except Exception:
+            return False
+
     def _is_in_string_or_comment(self, text):
         """
         Determine if the cursor is inside a string or comment.
@@ -2726,7 +2773,11 @@ def python_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
         """Match attributes or global python names"""
         text = context.text_until_cursor
         text = self._extract_code(text)
-        completion_type = self._determine_completion_context(text)
+        in_cli_context = self._is_completing_in_cli_context(text)
+        if in_cli_context:
+            completion_type = self._CompletionContextType.GLOBAL
+        else:
+            completion_type = self._determine_completion_context(text)
         if completion_type == self._CompletionContextType.ATTRIBUTE:
             try:
                 matches, fragment = self._attr_matches(
@@ -2746,8 +2797,6 @@ def python_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
                 matches = _convert_matcher_v1_result_to_v2(
                     matches, type="attribute", fragment=fragment
                 )
-                if matches["completions"]:
-                    matches["suppress"] = {_get_matcher_id(self.file_matcher)}
                 return matches
             except NameError:
                 # catches <undefined attributes>.<tab>
diff --git a/tests/test_completer.py b/tests/test_completer.py
@@ -424,11 +424,17 @@ def test_local_file_completions(self):
             c = ip.complete(prefix)[1]
             self.assertEqual(c, names)
 
-            # Now check with a function call
-            cmd = 'a = f("%s' % prefix
-            c = ip.complete(prefix, cmd)[1]
-            comp = {prefix + s for s in suffixes}
-            self.assertTrue(comp.issubset(set(c)))
+            test_cases = {
+                "function call": 'a = f("',
+                "shell bang": "!ls ",
+                "ls magic": r"%ls ",
+                "alias ls": "ls ",
+            }
+            for name, code in test_cases.items():
+                cmd = f"{code}{prefix}"
+                c = ip.complete(prefix, cmd)[1]
+                comp = {prefix + s for s in suffixes}
+                self.assertTrue(comp.issubset(set(c)), msg=f"completes in {name}")
 
     def test_quoted_file_completions(self):
         ip = get_ipython()
@@ -2656,6 +2662,14 @@ def test_undefined_variables_without_jedi(code, insert_text):
                 "x.b[0].",
             ]
         ),
+        "\n".join(
+            [
+                "class MyClass():",
+                "    b: list[str]",
+                "x = MyClass()",
+                "x.fake_attr().",
+            ]
+        ),
     ],
 )
 def test_no_file_completions_in_attr_access(code):
@@ -2724,6 +2738,7 @@ def test_no_file_completions_in_attr_access(code):
         ('f"formatted {obj.attr}', "global"),
         ("dict_with_dots = {'key.with.dots': value.attr", "attribute"),
         ("d[f'{a}']['{a.", "global"),
+        ("ls .", "global"),
     ],
 )
 def test_completion_context(line, expected):
@@ -2734,6 +2749,37 @@ def test_completion_context(line, expected):
     assert result.value == expected, f"Failed on input: '{line}'"
 
 
+@pytest.mark.parametrize(
+    "line,expected,expected_after_assignment",
+    [
+        ("test_alias file", True, False),  # overshadowed by variable
+        ("test_alias .", True, False),
+        ("test_alias file.", True, False),
+        ("%test_alias .file.ext", True, True),  # magic, not affected by variable
+        ("!test_alias file.", True, True),  # bang, not affected by variable
+    ],
+)
+def test_completion_in_cli_context(line, expected, expected_after_assignment):
+    """Test completion context with and without variable overshadowing"""
+    ip = get_ipython()
+    ip.run_cell("alias test_alias echo test_alias")
+    get_context = ip.Completer._is_completing_in_cli_context
+
+    # Normal case
+    result = get_context(line)
+    assert result == expected, f"Failed on input: '{line}'"
+
+    # Test with alias assigned as a variable
+    try:
+        ip.user_ns["test_alias"] = "some_value"
+        result_after_assignment = get_context(line)
+        assert (
+            result_after_assignment == expected_after_assignment
+        ), f"Failed after assigning 'ls' as a variable for input: '{line}'"
+    finally:
+        ip.user_ns.pop("test_alias", None)
+
+
 @pytest.mark.xfail(reason="Completion context not yet supported")
 @pytest.mark.parametrize(
     "line, expected",
