Backport PR ipython#14898: Fix attribute completion for expressions with comparison operators

Author: krassowski

IPython/core/completer.py

@@ -1145,16 +1145,61 @@ def attr_matches(self, text):
     # we simple attribute matching with normal identifiers.
     _ATTR_MATCH_RE = re.compile(r"(.+)\.(\w*)$")
 
+    def _strip_code_before_operator(self, code: str) -> str:
+        o_parens = {"(", "[", "{"}
+        c_parens = {")", "]", "}"}
+
+        # Dry-run tokenize to catch errors
+        try:
+            _ = list(tokenize.generate_tokens(iter(code.splitlines()).__next__))
+        except tokenize.TokenError:
+            # Try trimming the expression and retrying
+            trimmed_code = self._trim_expr(code)
+            try:
+                _ = list(
+                    tokenize.generate_tokens(iter(trimmed_code.splitlines()).__next__)
+                )
+                code = trimmed_code
+            except tokenize.TokenError:
+                return code
+
+        tokens = _parse_tokens(code)
+        encountered_operator = False
+        after_operator = []
+        nesting_level = 0
+
+        for t in tokens:
+            if t.type == tokenize.OP:
+                if t.string in o_parens:
+                    nesting_level += 1
+                elif t.string in c_parens:
+                    nesting_level -= 1
+                elif t.string != "." and nesting_level == 0:
+                    encountered_operator = True
+                    after_operator = []
+                    continue
+
+            if encountered_operator:
+                after_operator.append(t.string)
+
+        if encountered_operator:
+            return "".join(after_operator)
+        else:
+            return code
+
     def _attr_matches(
         self, text: str, include_prefix: bool = True
     ) -> Tuple[Sequence[str], str]:
         m2 = self._ATTR_MATCH_RE.match(text)
         if not m2:
             return [], ""
         expr, attr = m2.group(1, 2)
+        try:
+            expr = self._strip_code_before_operator(expr)
+        except tokenize.TokenError:
+            pass
 
         obj = self._evaluate_expr(expr)
-
         if obj is not_found:
             return [], ""
 

IPython/core/tests/test_completer.py

@@ -595,7 +595,9 @@ def test_greedy_completions(self):
         """
         ip = get_ipython()
         ip.ex("a=list(range(5))")
+        ip.ex("b,c = 1, 1.2")
         ip.ex("d = {'a b': str}")
+        ip.ex("x=y='a'")
         _, c = ip.complete(".", line="a[0].")
         self.assertFalse(".real" in c, "Shouldn't have completed on a[0]: %s" % c)
 
@@ -653,6 +655,41 @@ def _(line, cursor_pos, expect, message, completion):
                 "Should have completed on `a.app`: %s",
                 Completion(2, 4, "append"),
             )
+            _(
+                "x.upper() == y.",
+                15,
+                ".upper",
+                "Should have completed on `x.upper() == y.`: %s",
+                Completion(15, 15, "upper"),
+            )
+            _(
+                "(x.upper() == y.",
+                16,
+                ".upper",
+                "Should have completed on `(x.upper() == y.`: %s",
+                Completion(16, 16, "upper"),
+            )
+            _(
+                "(x.upper() == y).",
+                17,
+                ".bit_length",
+                "Should have completed on `(x.upper() == y).`: %s",
+                Completion(17, 17, "bit_length"),
+            )
+            _(
+                "{'==', 'abc'}.",
+                14,
+                ".add",
+                "Should have completed on `{'==', 'abc'}.`: %s",
+                Completion(14, 14, "add"),
+            )
+            _(
+                "b + c.",
+                6,
+                ".hex",
+                "Should have completed on `b + c.`: %s",
+                Completion(6, 6, "hex"),
+            )
 
     def test_omit__names(self):
         # also happens to test IPCompleter as a configurable