Infer type for `__init__` calls (including `__new__` mods)

IPython/core/guarded_eval.py

@@ -1,4 +1,4 b''
-from inspect import signature, Signature
+from inspect import isclass, signature, Signature
 from typing import (
     Any,
     Callable,
@@ -337,6 +337,7 b' class _IdentitySubscript:'
 IDENTITY_SUBSCRIPT = _IdentitySubscript()
 SUBSCRIPT_MARKER = "__SUBSCRIPT_SENTINEL__"
 UNKNOWN_SIGNATURE = Signature()
+NOT_EVALUATED = object()
 
 
 class GuardRejection(Exception):
@@ -590,6 +591,34 b' def eval_node(node: Union[ast.AST, None], context: EvaluationContext):'
         if policy.can_call(func) and not node.keywords:
             args = [eval_node(arg, context) for arg in node.args]
             return func(*args)
+        if isclass(func):
+            # this code path gets entered when calling class e.g. `MyClass()`
+            # or `my_instance.__class__()` - in both cases `func` is `MyClass`.
+            # Should return `MyClass` if `__new__` is not overridden,
+            # otherwise whatever `__new__` return type is.
+            overridden_return_type = _eval_return_type(
+                func.__new__, policy, node, context
+            )
+            if overridden_return_type is not NOT_EVALUATED:
+                return overridden_return_type
+            return _create_duck_for_type(func)
+        else:
+            return_type = _eval_return_type(func, policy, node, context)
+            if return_type is not NOT_EVALUATED:
+                return return_type
+        raise GuardRejection(
+            "Call for",
+            func,  # not joined to avoid calling `repr`
+            f"not allowed in {context.evaluation} mode",
+        )
+    raise ValueError("Unhandled node", ast.dump(node))
+
+
+def _eval_return_type(func, policy, node, context):
+    """Evaluate return type of a given callable function.
+
+    Returns the built-in type, a duck or NOT_EVALUATED sentinel.
+    """
         try:
             sig = signature(func)
         except ValueError:
@@ -599,24 +628,28 b' def eval_node(node: Union[ast.AST, None], context: EvaluationContext):'
         not_empty = sig.return_annotation is not Signature.empty
         not_stringized = not isinstance(sig.return_annotation, str)
         if not_empty and not_stringized:
-            duck = Duck()
             # if allow-listed builtin is on type annotation, instantiate it
             if policy.can_call(sig.return_annotation) and not node.keywords:
                 args = [eval_node(arg, context) for arg in node.args]
+            # if custom class is in type annotation, mock it;
                 return sig.return_annotation(*args)
+        return _create_duck_for_type(sig.return_annotation)
+    return NOT_EVALUATED
+
+
+def _create_duck_for_type(duck_type):
+    """Create an imitation of an object of a given type (a duck).
+
+    Returns the duck or NOT_EVALUATED sentinel if duck could not be created.
+    """
+    duck = Duck()
             try:
-                # if custom class is in type annotation, mock it;
                 # this only works for heap types, not builtins
-                duck.__class__ = sig.return_annotation
+        duck.__class__ = duck_type
                 return duck
             except TypeError:
                 pass
-        raise GuardRejection(
-            "Call for",
-            func,  # not joined to avoid calling `repr`
-            f"not allowed in {context.evaluation} mode",
-        )
-    raise ValueError("Unhandled node", ast.dump(node))
+    return NOT_EVALUATED
 
 
 SUPPORTED_EXTERNAL_GETITEM = {

IPython/core/tests/test_guarded_eval.py

@@ -267,16 +267,34 b' class CallCreatesBuiltin:'
         return frozenset()
 
 
+class HasStaticMethod:
+    @staticmethod
+    def static_method() -> HeapType:
+        return HeapType()
+
+
+class InitReturnsFrozenset:
+    def __new__(self) -> frozenset:  # type:ignore[misc]
+        return frozenset()
+
+
 @pytest.mark.parametrize(
-    "data,good,bad,expected, equality",
+    "data,good,expected,equality",
     [
-        [[1, 2, 3], "data.index(2)", "data.append(4)", 1, True],
-        [{"a": 1}, "data.keys().isdisjoint({})", "data.update()", True, True],
-        [CallCreatesHeapType(), "data()", "data.__class__()", HeapType, False],
-        [CallCreatesBuiltin(), "data()", "data.__class__()", frozenset, False],
+        [[1, 2, 3], "data.index(2)", 1, True],
+        [{"a": 1}, "data.keys().isdisjoint({})", True, True],
+        # test cases for `__call__`
+        [CallCreatesHeapType(), "data()", HeapType, False],
+        [CallCreatesBuiltin(), "data()", frozenset, False],
+        # Test cases for `__init__`
+        [HeapType, "data()", HeapType, False],
+        [InitReturnsFrozenset, "data()", frozenset, False],
+        [HeapType(), "data.__class__()", HeapType, False],
+        # test cases for static and class methods
+        [HasStaticMethod, "data.static_method()", HeapType, False],
     ],
 )
-def test_evaluates_calls(data, good, bad, expected, equality):
+def test_evaluates_calls(data, good, expected, equality):
     context = limited(data=data)
     value = guarded_eval(good, context)
     if equality:
@@ -284,6 +302,17 b' def test_evaluates_calls(data, good, bad, expected, equality):'
     else:
         assert isinstance(value, expected)
 
+
[e-mail](
+    "data,bad",
+    [
+        [[1, 2, 3], "data.append(4)"],
+        [{"a": 1}, "data.update()"],
+    ],
+)
+def test_rejects_calls_with_side_effects(data, bad):
+    context = limited(data=data)
+
     with pytest.raises(GuardRejection):
         guarded_eval(bad, context)