Add tests for completer and implement completion of variable names

Author: krassowski

IPython/core/completer.py

@@ -1127,7 +1127,16 @@ def complete(self, text, state):
         except IndexError:
             return None
 
-    def global_matches(self, text):
+    def global_matches(self, text: str):
+        """Compute matches when text is a simple name.
+
+        Return a list of all keywords, built-in functions and names currently
+        defined in self.namespace or self.global_namespace that match.
+
+        """
+        return self._global_matches(text)
+
+    def _global_matches(self, text: str, context: Optional[CompletionContext] = None):
         """Compute matches when text is a simple name.
 
         Return a list of all keywords, built-in functions and names currently
@@ -1137,12 +1146,41 @@ def global_matches(self, text):
         matches = []
         match_append = matches.append
         n = len(text)
-        for lst in [
+
+        search_lists = [
             keyword.kwlist,
             builtin_mod.__dict__.keys(),
             list(self.namespace.keys()),
             list(self.global_namespace.keys()),
-        ]:
+        ]
+        if context and context.full_text.count("\n") > 1:
+            # try to evaluate on full buffer
+            previous_lines = "\n".join(
+                context.full_text.split("\n")[: context.cursor_line]
+            )
+            if previous_lines:
+                all_code_lines_before_cursor = (
+                    self._extract_code(previous_lines) + "\n" + text
+                )
+                context = EvaluationContext(
+                    globals=self.global_namespace,
+                    locals=self.namespace,
+                    evaluation=self.evaluation,
+                    auto_import=self._auto_import,
+                    policy_overrides=self.policy_overrides,
+                )
+                try:
+                    obj = guarded_eval(
+                        all_code_lines_before_cursor,
+                        context,
+                    )
+                except Exception as e:
+                    if self.debug:
+                        warnings.warn(f"Evaluation exception {e}")
+
+                search_lists.append(list(context.transient_locals.keys()))
+
+        for lst in search_lists:
             for word in lst:
                 if word[:n] == text and word != "__builtins__":
                     match_append(word)
@@ -1157,6 +1195,7 @@ def global_matches(self, text):
             for word in shortened.keys():
                 if word[:n] == text and word != "__builtins__":
                     match_append(shortened[word])
+
         return matches
 
     def attr_matches(self, text):
@@ -2718,7 +2757,7 @@ def python_matcher(self, context: CompletionContext) -> SimpleMatcherResult:
                 # catches <undefined attributes>.<tab>
                 return SimpleMatcherResult(completions=[], suppress=False)
         else:
-            matches = self.global_matches(context.token)
+            matches = self._global_matches(context.token, context)
             # TODO: maybe distinguish between functions, modules and just "variables"
             return SimpleMatcherResult(
                 completions=[

tests/test_completer.py

@@ -1974,6 +1974,87 @@ def _(expected):
             _(["completion_a"])
 
 
+@pytest.mark.parametrize(
+    "use_jedi,evaluation",
+    [
+        [True, "minimal"],
+        [False, "limited"],
+    ],
+)
+@pytest.mark.parametrize(
+    "code,insert_text",
+    [
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def my_method(self) -> str:",
+                    "        return 1",
+                    "my_instance = NotYetDefined()",
+                    "my_insta",
+                ]
+            ),
+            "my_instance",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def my_method(self) -> str:",
+                    "        return 1",
+                    "instance = NotYetDefined()",
+                    "instance.",
+                ]
+            ),
+            "my_method",
+        ],
+        [
+            "\n".join(
+                [
+                    "class NotYetDefined:",
+                    "    def my_method(self) -> str:",
+                    "        return 1",
+                    "my_instance = NotYetDefined()",
+                    "my_instance.my_method().",
+                ]
+            ),
+            "capitalize",
+        ],
+        [
+            "\n".join(
+                [
+                    "my_instance = 1.1",
+                    "assert my_instance.",
+                ]
+            ),
+            "as_integer_ratio",
+        ],
+        [
+            "\n".join(
+                [
+                    "def my_test() -> float:",
+                    "    pass",
+                    "my_test().",
+                ]
+            ),
+            "as_integer_ratio",
+        ],
+    ],
+)
+def test_undefined_variables(use_jedi, evaluation, code, insert_text):
+    offset = len(code)
+    ip.Completer.use_jedi = use_jedi
+    ip.Completer.evaluation = evaluation
+
+    with provisionalcompleter():
+        completions = list(ip.Completer.completions(text=code, offset=offset))
+        match = [c for c in completions if c.text.lstrip(".") == insert_text]
+        message_on_fail = (
+            f"{insert_text} not found among {[c.text for c in completions]}"
+        )
+        assert len(match) == 1, message_on_fail
+
+
 @pytest.mark.parametrize(
     "line,expected",
     [