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

Darshan808 · web-flow · commit 823034c41433 · 2025-11-28T15:53:20.000+05:45
diff --git a/IPython/core/completer.py b/IPython/core/completer.py
@@ -1352,6 +1352,8 @@ def _trim_expr(self, code: str) -> str:
             assert res is not None
             if len(res.body) != 1:
                 continue
+            if not isinstance(res.body[0], ast.Expr):
+                continue
             expr = res.body[0].value
             if isinstance(expr, ast.Tuple) and not code[-1] == ")":
                 # we skip implicit tuple, like when trimming `fun(a,b`<completion>
diff --git a/IPython/core/guarded_eval.py b/IPython/core/guarded_eval.py
@@ -30,8 +30,8 @@
 
 from IPython.utils.decorators import undoc
 
-
-from typing import Self, LiteralString
+import types
+from typing import Self, LiteralString, get_type_hints
 
 if sys.version_info < (3, 12):
     from typing_extensions import TypeAliasType
@@ -403,6 +403,9 @@ class EvaluationContext:
     class_transients: dict | None = None
     #: Instance variable name used in the method definition
     instance_arg_name: str | None = None
+    #: Currently associated value
+    #: Useful for adding items to _Duck on annotated assignment
+    current_value: ast.AST | None = None
 
     def replace(self, /, **changes):
         """Return a new copy of the context, with specified changes"""
@@ -566,6 +569,30 @@ def _validate_policy_overrides(
     return all_good
 
 
+def _is_type_annotation(obj) -> bool:
+    """
+    Returns True if obj is a type annotation, False otherwise.
+    """
+    if isinstance(obj, type):
+        return True
+    if isinstance(obj, types.GenericAlias):
+        return True
+    if hasattr(types, "UnionType") and isinstance(obj, types.UnionType):
+        return True
+    if isinstance(obj, (typing._SpecialForm, typing._BaseGenericAlias)):
+        return True
+    if isinstance(obj, typing.TypeVar):
+        return True
+    # Types that support __class_getitem__
+    if isinstance(obj, type) and hasattr(obj, "__class_getitem__"):
+        return True
+    # Fallback: check if get_origin returns something
+    if hasattr(typing, "get_origin") and get_origin(obj) is not None:
+        return True
+
+    return False
+
+
 def _handle_assign(node: ast.Assign, context: EvaluationContext):
     value = eval_node(node.value, context)
     transient_locals = context.transient_locals
@@ -664,12 +691,17 @@ def _handle_assign(node: ast.Assign, context: EvaluationContext):
 
 
 def _handle_annassign(node, context):
-    annotation_value = _resolve_annotation(eval_node(node.annotation, context), context)
-
-    # Use Value for generic types
-    use_value = (
-        isinstance(annotation_value, GENERIC_CONTAINER_TYPES) and node.value is not None
-    )
+    context_with_value = context.replace(current_value=getattr(node, "value", None))
+    annotation_result = eval_node(node.annotation, context_with_value)
+    if _is_type_annotation(annotation_result):
+        annotation_value = _resolve_annotation(annotation_result, context)
+        # Use Value for generic types
+        use_value = (
+            isinstance(annotation_value, GENERIC_CONTAINER_TYPES) and node.value is not None
+        )
+    else:
+        annotation_value = annotation_result
+        use_value = False
 
     # LOCAL VARIABLE
     if getattr(node, "simple", False) and isinstance(node.target, ast.Name):
@@ -801,9 +833,12 @@ def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
 
         if is_property:
             if return_type is not None:
-                context.transient_locals[node.name] = _resolve_annotation(
-                    return_type, context
-                )
+                if _is_type_annotation(return_type):
+                    context.transient_locals[node.name] = _resolve_annotation(
+                        return_type, context
+                    )
+                else:
+                    context.transient_locals[node.name] = return_type
             else:
                 return_value = _infer_return_value(node, func_context)
                 context.transient_locals[node.name] = return_value
@@ -814,7 +849,10 @@ def dummy_function(*args, **kwargs):
             pass
 
         if return_type is not None:
-            dummy_function.__annotations__["return"] = return_type
+            if _is_type_annotation(return_type):
+                dummy_function.__annotations__["return"] = return_type
+            else:
+                dummy_function.__inferred_return__ = return_type
         else:
             inferred_return = _infer_return_value(node, func_context)
             if inferred_return is not None:
@@ -952,6 +990,29 @@ def dummy_function(*args, **kwargs):
     if isinstance(node, ast.BinOp):
         left = eval_node(node.left, context)
         right = eval_node(node.right, context)
+        if (
+            isinstance(node.op, ast.BitOr)
+            and _is_type_annotation(left)
+            and _is_type_annotation(right)
+        ):
+            left_duck = (
+                _Duck(dict.fromkeys(dir(left)))
+                if policy.can_call(left.__dir__)
+                else _Duck()
+            )
+            right_duck = (
+                _Duck(dict.fromkeys(dir(right)))
+                if policy.can_call(right.__dir__)
+                else _Duck()
+            )
+            value_node = context.current_value
+            if value_node is not None and isinstance(value_node, ast.Dict):
+                if dict in [left, right]:
+                    return _merge_values(
+                        [left_duck, right_duck, ast.literal_eval(value_node)],
+                        policy=get_policy(context),
+                    )
+            return _merge_values([left_duck, right_duck], policy=get_policy(context))
         dunders = _find_dunder(node.op, BINARY_OP_DUNDERS)
         if dunders:
             if policy.can_operate(dunders, left, right):
@@ -1061,6 +1122,22 @@ def dummy_function(*args, **kwargs):
         value = eval_node(node.value, context)
         if policy.can_get_attr(value, node.attr):
             return getattr(value, node.attr)
+        try:
+            cls = (
+                value if isinstance(value, type) else getattr(value, "__class__", None)
+            )
+            if cls is not None:
+                resolved_hints = get_type_hints(
+                    cls,
+                    globalns=(context.globals or {}),
+                    localns=(context.locals or {}),
+                )
+                if node.attr in resolved_hints:
+                    annotated = resolved_hints[node.attr]
+                    return _resolve_annotation(annotated, context)
+        except Exception:
+            # Fall through to the guard rejection
+            pass
         raise GuardRejection(
             "Attribute access (`__getattr__`) for",
             type(value),  # not joined to avoid calling `repr`
diff --git a/tests/test_completer.py b/tests/test_completer.py
@@ -1572,6 +1572,39 @@ def __getattr__(self, attr):
             self.assertNotIn(".append", matches)
             self.assertNotIn(".keys", matches)
 
+    def test_completion_fallback_to_annotation_for_attribute(self):
+        code = textwrap.dedent(
+            """
+            class StringMethods:
+                def a():
+                    pass
+
+            class Test:
+                str: StringMethods
+                def __init__(self):
+                    self.str = StringMethods()
+                def __getattr__(self, name):
+                    raise AttributeError(f"{name} not found")
+            """
+        )
+
+        repro = types.ModuleType("repro")
+        sys.modules["repro"] = repro
+        exec(code, repro.__dict__)
+
+        ip = get_ipython()
+        ip.user_ns["repro"] = repro
+        exec("r = repro.Test()", ip.user_ns)
+
+        complete = ip.Completer.complete
+        try:
+            with evaluation_policy("limited"), jedi_status(False):
+                _, matches = complete(line_buffer="r.str.")
+                self.assertIn(".a", matches)
+        finally:
+            sys.modules.pop("repro", None)
+            ip.user_ns.pop("r", None)
+
     def test_policy_warnings(self):
         with self.assertWarns(
             UserWarning,
@@ -2494,6 +2527,15 @@ def _(expected):
             ),
             "bit_length",
         ],
+        [
+            "\n".join(
+                [
+                    "t: list[str]",
+                    "t[0].",
+                ]
+            ),
+            ["capitalize"],
+        ],
     ],
 )
 def test_undefined_variables(use_jedi, evaluation, code, insert_text):
@@ -2521,6 +2563,42 @@ def test_undefined_variables(use_jedi, evaluation, code, insert_text):
                 ]
             ),
             ["append"],
+        ],
+          "\n".join(
+                [
+                    "t: int | dict = {'a': []}",
+                    "t.",
+                ]
+            ),
+            ["keys", "bit_length"],
+        ],
+        [
+            "\n".join(
+                [
+                    "t: int | dict = {'a': []}",
+                    "t['a'].",
+                ]
+            ),
+            "append",
+        ],
+        # Test union types
+        [
+            "\n".join(
+                [
+                    "t: int | str",
+                    "t.",
+                ]
+            ),
+            ["bit_length", "capitalize"],
+        ],
+        [
+            "\n".join(
+                [
+                    "def func() -> int | str: pass",
+                    "func().",
+                ]
+            ),
+            ["bit_length", "capitalize"],
         ],
         [
             "\n".join(
@@ -2531,6 +2609,18 @@ def test_undefined_variables(use_jedi, evaluation, code, insert_text):
             ),
             ["capitalize"],
         ],
+        [
+            "\n".join(
+                [
+                    "class T:",
+                    "   @property",
+                    "   def p(self) -> int | str: pass",
+                    "t = T()",
+                    "t.p.",
+                ]
+            ),
+            ["bit_length", "capitalize"],
+        ],
     ],
 )
 def test_undefined_variables_without_jedi(code, insert_text):
@@ -2692,6 +2782,7 @@ def test_misc_no_jedi_completions(setup, code, expected, not_expected):
         ("x = {1, y", "y"),
         ("x = [1, y", "y"),
         ("x = fun(1, y", "y"),
+        (" assert a", "a"),
     ],
 )
 def test_trim_expr(code, expected):
diff --git a/tests/test_guarded_eval.py b/tests/test_guarded_eval.py
@@ -12,6 +12,11 @@
     TypeGuard,
     Union,
     TypedDict,
+    TypeVar,
+    List,
+    Callable,
+    Any,
+    Dict,
 )
 from functools import partial
 from IPython.core.guarded_eval import (
@@ -22,6 +27,7 @@
 )
 from IPython.testing import decorators as dec
 import pytest
+from IPython.core.guarded_eval import _is_type_annotation
 
 
 from typing import Self, LiteralString
@@ -579,6 +585,38 @@ def test_mock_class_and_func_instances(code, expected):
     assert isinstance(value, expected)
 
 
+@pytest.mark.parametrize(
+    "annotation,expected",
+    [
+        # Basic types
+        (int, True),
+        (str, True),
+        (list, True),
+        # Typing generics
+        (list[str], True),
+        (dict[str, int], True),
+        (Optional[int], True),
+        (Union[int, str], True),
+        # Special forms
+        (AnyStr, True),
+        (TypeVar("T"), True),
+        (Callable[[int], str], True),
+        (Literal["GET", "POST"], True),
+        (Any, True),
+        (str | int, True),
+        # Nested
+        (List[Dict[str, int]], True),
+        # Non-annotations
+        (42, False),
+        ("string", False),
+        ([1, 2, 3], False),
+        (None, False),
+    ],
+)
+def test_is_type_annotation(annotation, expected):
+    assert _is_type_annotation(annotation) == expected
+
+
 @pytest.mark.parametrize(
     "code,expected",
     [
