simplify-logic

Author: Darshan808

IPython/core/completer.py

@@ -2383,49 +2383,16 @@ def _determine_completion_context(self, line):
                 # Recursively determine the context of the expression
                 return self._determine_completion_context(expr)
 
-        # Match tuples followed by a dot (e.g., (a, b).index)
-        tuple_attr_match = re.search(
-            r"\(\s*[a-zA-Z_][a-zA-Z0-9_]*\s*(,\s*[a-zA-Z_][a-zA-Z0-9_]*\s*)+\)\.$", line
-        )
-        if tuple_attr_match:
-            return self._CompletionContextType.ATTRIBUTE
-
-        # Match for number literals should come first
         # Handle plain number literals - should be global context
-        if re.search(r"^[-+]?\d+\.(\d+)?$", line):
+        # Ex: 3. -42.14 but not 3.1.
+        if re.search(r"(?<!\w)(?<!\d\.)([-+]?\d+\.(\d+)?)(?!\w)$", line):
             return self._CompletionContextType.GLOBAL
 
-        # Match numeric literals in parentheses followed by dot
-        # Handles cases like (3).to_
-        numeric_paren_attr_match = re.search(
-            r"\([-+]?\d+(\.\d*)?\)(\.([a-zA-Z_][a-zA-Z0-9_]*)?)?$", line
-        )
-        if numeric_paren_attr_match:
-            return self._CompletionContextType.ATTRIBUTE
-
-        # Match float literals followed by dot and optional attribute
-        # Handles cases like 3.1.as_, -3.1.r_
-        float_attr_match = re.search(r"[-+]?\d+\.\d+\.([a-zA-Z_][a-zA-Z0-9_]*)?$", line)
-        if float_attr_match:
-            return self._CompletionContextType.ATTRIBUTE
-
-        # Handle indexed access followed by dot - like d[0].k
-        indexed_attr_match = re.search(
-            r"[a-zA-Z_][a-zA-Z0-9_]*\[[^\]]+\]\.([a-zA-Z_][a-zA-Z0-9_]*)?$", line
-        )
-        if indexed_attr_match:
-            return self._CompletionContextType.ATTRIBUTE
-
-        # Match 'word-dot-word' at end for attribute context.
-        # Ex: 'obj.', 'np.random.ran'.
-        chain_match = re.search(
-            r"([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)?$", line
-        )
+        # Handle all other attribute matches np.ran, d[0].k, (a,b).count
+        chain_match = re.search(r".*(.+\.(?:[a-zA-Z]\w*)?)$", line)
         if chain_match:
             return self._CompletionContextType.ATTRIBUTE
 
-        # No attribute pattern → GLOBAL.
-        # Ex: 'var', '', '3.', '-42.5.'
         return self._CompletionContextType.GLOBAL
 
     def _is_in_string_or_comment(self, text):
@@ -2488,28 +2455,31 @@ def _is_in_string_or_comment(self, text):
                 i += 2
                 continue
 
-            # Handle expressions in f-strings or t-strings
-            if (
-                in_template_string
-                and text[i] == "{"
-                and not (in_expression and expression_depth > 0 and text[i - 1] != "{")
-            ):
-                in_expression = True
-                expression_depth += 1
-                i += 1
-                continue
-            elif in_template_string and text[i] == "}" and in_expression:
-                expression_depth -= 1
-                if expression_depth == 0:
-                    in_expression = False
-                i += 1
-                continue
+            # Handle nested braces within f-strings
+            if in_template_string:
+                # Special handling for consecutive opening braces
+                if i + 1 < len(text) and text[i : i + 2] == "{{":
+                    i += 2
+                    continue
 
-            # Handle nested braces within expressions
-            if in_expression and text[i] == "{":
-                expression_depth += 1
-            elif in_expression and text[i] == "}" and expression_depth > 0:
-                expression_depth -= 1
+                # Detect start of an expression
+                if text[i] == "{":
+                    # Only increment depth and mark as expression if not already in an expression
+                    # or if we're at a top-level nested brace
+                    if not in_expression or (in_expression and expression_depth == 0):
+                        in_expression = True
+                        expression_depth += 1
+                    i += 1
+                    continue
+
+                # Detect end of an expression
+                if text[i] == "}":
+                    expression_depth -= 1
+                    if expression_depth <= 0:
+                        in_expression = False
+                        expression_depth = 0
+                    i += 1
+                    continue
 
             # Handle quotes - also reset template string when closing quotes are encountered
             if (
@@ -2555,7 +2525,6 @@ def _is_in_string_or_comment(self, text):
         )
 
         # Return tuple (is_string, is_in_expression)
-        # For nested f-strings, we're in a string but not necessarily in an expression
         return (
             is_string or (in_template_string and not in_expression),
             in_expression and expression_depth > 0,

tests/test_completer.py

@@ -1805,6 +1805,8 @@ def _(expected):
         ('f"greeting {user.na', "attribute"),  # Cursor in f-string expression
         ('t"welcome {guest.na', "attribute"),  # Cursor in t-string expression
         ('f"hello {name} worl', "global"),  # Cursor in f-string outside expression
+        ('f"hello {{a.', "global"),
+        ('f"hello {{{a.', "attribute"),
         # Backslash escapes in strings
         ('var = "string with \\"escaped quote and a dot.', "global"),
         ("escaped = 'single \\'quote\\' with a dot.", "global"),
@@ -1821,17 +1823,21 @@ def _(expected):
         ("multiple_nesting = {key: [value.attr", "attribute"),
         # Numbers
         ("3.", "global"),
+        ("3.14", "global"),
         ("-42.14", "global"),
+        ("x = func(3.14", "global"),
+        ("x = func(a3.", "attribute"),
+        ("x = func(a3.12", "global"),
+        ("3.1.", "attribute"),
+        ("-3.1.", "attribute"),
+        ("(3).", "attribute"),
         # Additional cases
+        ("", "global"),
         ('str_with_code = "x.attr', "global"),
         ('f"formatted {obj.attr', "attribute"),
         ('f"formatted {obj.attr}', "global"),
         ("dict_with_dots = {'key.with.dots': value.attr", "attribute"),
         ("d[f'{a}']['{a.", "global"),
-        ("3.", "global"),
-        ("3.1.", "attribute"),
-        ("-3.1.", "attribute"),
-        ("(3).", "attribute"),
     ],
 )
 def test_completion_context(line, expected):
@@ -1846,7 +1852,9 @@ def test_completion_context(line, expected):
 @pytest.mark.parametrize(
     "line, expected",
     [
-        ("f'{f'a.", "global"),
+        ("f'{f'a.", "global"),  # Nested f-string
+        ("3a.", "global"),  # names starting with numbers or other symbols
+        ("$).", "global"),  # random things with dot at end
     ],
 )
 def test_unsupported_completion_context(line, expected):