jaclang 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/vendor/mypyc/test-data/run-singledispatch.test

@@ -0,0 +1,698 @@
+# Test cases related to the functools.singledispatch decorator
+# Most of these tests are marked as xfails because mypyc doesn't support singledispatch yet
+# (These tests will be re-enabled when mypyc supports singledispatch)
+
+[case testSpecializedImplementationUsed]
+from functools import singledispatch
+
+@singledispatch
+def fun(arg) -> bool:
+    return False
+
+@fun.register
+def fun_specialized(arg: str) -> bool:
+    return True
+
+def test_specialize() -> None:
+    assert fun('a')
+    assert not fun(3)
+
+[case testSubclassesOfExpectedTypeUseSpecialized]
+from functools import singledispatch
+class A: pass
+class B(A): pass
+
+@singledispatch
+def fun(arg) -> bool:
+    return False
+
+@fun.register
+def fun_specialized(arg: A) -> bool:
+    return True
+
+def test_specialize() -> None:
+    assert fun(B())
+    assert fun(A())
+
+[case testSuperclassImplementationNotUsedWhenSubclassHasImplementation]
+from functools import singledispatch
+class A: pass
+class B(A): pass
+
+@singledispatch
+def fun(arg) -> bool:
+    # shouldn't be using this
+    assert False
+
+@fun.register
+def fun_specialized(arg: A) -> bool:
+    return False
+
+@fun.register
+def fun_specialized2(arg: B) -> bool:
+    return True
+
+def test_specialize() -> None:
+    assert fun(B())
+    assert not fun(A())
+
+[case testMultipleUnderscoreFunctionsIsntError]
+from functools import singledispatch
+
+@singledispatch
+def fun(arg) -> str:
+    return 'default'
+
+@fun.register
+def _(arg: str) -> str:
+    return 'str'
+
+@fun.register
+def _(arg: int) -> str:
+    return 'int'
+
+# extra function to make sure all 3 underscore functions aren't treated as one OverloadedFuncDef
+def a(b): pass
+
+@fun.register
+def _(arg: list) -> str:
+    return 'list'
+
+def test_singledispatch() -> None:
+    assert fun(0) == 'int'
+    assert fun('a') == 'str'
+    assert fun([1, 2]) == 'list'
+    assert fun({'a': 'b'}) == 'default'
+
+[case testCanRegisterCompiledClasses]
+from functools import singledispatch
+class A: pass
+
+@singledispatch
+def fun(arg) -> bool:
+    return False
+@fun.register
+def fun_specialized(arg: A) -> bool:
+    return True
+
+def test_singledispatch() -> None:
+    assert fun(A())
+    assert not fun(1)
+
+[case testTypeUsedAsArgumentToRegister]
+from functools import singledispatch
+
+@singledispatch
+def fun(arg) -> bool:
+    return False
+
+@fun.register(int)
+def fun_specialized(arg) -> bool:
+    return True
+
+def test_singledispatch() -> None:
+    assert fun(1)
+    assert not fun('a')
+
+[case testUseRegisterAsAFunction]
+from functools import singledispatch
+
+@singledispatch
+def fun(arg) -> bool:
+    return False
+
+def fun_specialized_impl(arg) -> bool:
+    return True
+
+fun.register(int, fun_specialized_impl)
+
+def test_singledispatch() -> None:
+    assert fun(0)
+    assert not fun('a')
+
+[case testRegisterDoesntChangeFunction]
+from functools import singledispatch
+
+@singledispatch
+def fun(arg) -> bool:
+    return False
+
+@fun.register(int)
+def fun_specialized(arg) -> bool:
+    return True
+
+def test_singledispatch() -> None:
+    assert fun_specialized('a')
+
+# TODO: turn this into a mypy error
+[case testNoneIsntATypeWhenUsedAsArgumentToRegister]
+from functools import singledispatch
+
+@singledispatch
+def fun(arg) -> bool:
+    return False
+
+try:
+    @fun.register
+    def fun_specialized(arg: None) -> bool:
+        return True
+except TypeError:
+    pass
+
+[case testRegisteringTheSameFunctionSeveralTimes]
+from functools import singledispatch
+
+@singledispatch
+def fun(arg) -> bool:
+    return False
+
+@fun.register(int)
+@fun.register(str)
+def fun_specialized(arg) -> bool:
+    return True
+
+def test_singledispatch() -> None:
+    assert fun(0)
+    assert fun('a')
+    assert not fun([1, 2])
+
+[case testTypeIsAnABC]
+from functools import singledispatch
+from collections.abc import Mapping
+
+@singledispatch
+def fun(arg) -> bool:
+    return False
+
+@fun.register
+def fun_specialized(arg: Mapping) -> bool:
+    return True
+
+def test_singledispatch() -> None:
+    assert not fun(1)
+    assert fun({'a': 'b'})
+
+[case testSingleDispatchMethod-xfail]
+from functools import singledispatchmethod
+class A:
+    @singledispatchmethod
+    def fun(self, arg) -> str:
+        return 'default'
+
+    @fun.register
+    def fun_int(self, arg: int) -> str:
+        return 'int'
+
+    @fun.register
+    def fun_str(self, arg: str) -> str:
+        return 'str'
+
+def test_singledispatchmethod() -> None:
+    x = A()
+    assert x.fun(5) == 'int'
+    assert x.fun('a') == 'str'
+    assert x.fun([1, 2]) == 'default'
+
+[case testSingleDispatchMethodWithOtherDecorator-xfail]
+from functools import singledispatchmethod
+class A:
+    @singledispatchmethod
+    @staticmethod
+    def fun(arg) -> str:
+        return 'default'
+
+    @fun.register
+    @staticmethod
+    def fun_int(arg: int) -> str:
+        return 'int'
+
+    @fun.register
+    @staticmethod
+    def fun_str(arg: str) -> str:
+        return 'str'
+
+def test_singledispatchmethod() -> None:
+    x = A()
+    assert x.fun(5) == 'int'
+    assert x.fun('a') == 'str'
+    assert x.fun([1, 2]) == 'default'
+
+[case testSingledispatchTreeSumAndEqual]
+from functools import singledispatch
+
+class Tree:
+    pass
+class Leaf(Tree):
+    pass
+class Node(Tree):
+    def __init__(self, value: int, left: Tree, right: Tree) -> None:
+        self.value = value
+        self.left = left
+        self.right = right
+
+@singledispatch
+def calc_sum(x: Tree) -> int:
+    raise TypeError('invalid type for x')
+
+@calc_sum.register
+def _(x: Leaf) -> int:
+    return 0
+
+@calc_sum.register
+def _(x: Node) -> int:
+    return x.value + calc_sum(x.left) + calc_sum(x.right)
+
+@singledispatch
+def equal(to_compare: Tree, known: Tree) -> bool:
+    raise TypeError('invalid type for x')
+
+@equal.register
+def _(to_compare: Leaf, known: Tree) -> bool:
+    return isinstance(known, Leaf)
+
+@equal.register
+def _(to_compare: Node, known: Tree) -> bool:
+    if isinstance(known, Node):
+        if to_compare.value != known.value:
+            return False
+        else:
+            return equal(to_compare.left, known.left) and equal(to_compare.right, known.right)
+    return False
+
+def build(n: int) -> Tree:
+    if n == 0:
+        return Leaf()
+    return Node(n, build(n - 1), build(n - 1))
+
+def test_sum_and_equal():
+    tree = build(5)
+    tree2 = build(5)
+    tree2.right.right.right.value = 10
+    assert calc_sum(tree) == 57
+    assert calc_sum(tree2) == 65
+    assert equal(tree, tree)
+    assert not equal(tree, tree2)
+    tree3 = build(4)
+    assert not equal(tree, tree3)
+
+[case testSimulateMypySingledispatch]
+from functools import singledispatch
+from mypy_extensions import trait
+from typing import Iterator, Union, TypeVar, Any, List, Type
+# based on use of singledispatch in stubtest.py
+class Error:
+    def __init__(self, msg: str) -> None:
+        self.msg = msg
+
+@trait
+class Node: pass
+
+class MypyFile(Node): pass
+class TypeInfo(Node): pass
+
+
+@trait
+class SymbolNode(Node): pass
+@trait
+class Expression(Node): pass
+class TypeVarLikeExpr(SymbolNode, Expression): pass
+class TypeVarExpr(TypeVarLikeExpr): pass
+class TypeAlias(SymbolNode): pass
+
+class Missing: pass
+MISSING = Missing()
+
+T = TypeVar("T")
+
+MaybeMissing = Union[T, Missing]
+
+@singledispatch
+def verify(stub: Node, a: MaybeMissing[Any], b: List[str]) -> Iterator[Error]:
+    yield Error('unknown node type')
+
+@verify.register(MypyFile)
+def verify_mypyfile(stub: MypyFile, a: MaybeMissing[int], b: List[str]) -> Iterator[Error]:
+    if isinstance(a, Missing):
+        yield Error("shouldn't be missing")
+        return
+    if not isinstance(a, int):
+        # this check should be unnecessary because of the type signature and the previous check,
+        # but stubtest.py has this check
+        yield Error("should be an int")
+        return
+    yield from verify(TypeInfo(), str, ['abc', 'def'])
+
+@verify.register(TypeInfo)
+def verify_typeinfo(stub: TypeInfo, a: MaybeMissing[Type[Any]], b: List[str]) -> Iterator[Error]:
+    yield Error('in TypeInfo')
+    yield Error('hello')
+
+@verify.register(TypeVarExpr)
+def verify_typevarexpr(stub: TypeVarExpr, a: MaybeMissing[Any], b: List[str]) -> Iterator[Error]:
+    if False:
+        yield None
+
+def verify_list(stub, a, b) -> List[str]:
+    """Helper function that converts iterator of errors to list of messages"""
+    return list(err.msg for err in verify(stub, a, b))
+
+def test_verify() -> None:
+    assert verify_list(TypeAlias(), 'a', ['a', 'b']) == ['unknown node type']
+    assert verify_list(MypyFile(), MISSING, ['a', 'b']) == ["shouldn't be missing"]
+    assert verify_list(MypyFile(), 5, ['a', 'b']) == ['in TypeInfo', 'hello']
+    assert verify_list(TypeInfo(), str, ['a', 'b']) == ['in TypeInfo', 'hello']
+    assert verify_list(TypeVarExpr(), 'a', ['x', 'y']) == []
+
+
+[case testArgsInRegisteredImplNamedDifferentlyFromMainFunction]
+from functools import singledispatch
+
+@singledispatch
+def f(a) -> bool:
+    return False
+
+@f.register
+def g(b: int) -> bool:
+    return True
+
+def test_singledispatch():
+    assert f(5)
+    assert not f('a')
+
+[case testKeywordArguments]
+from functools import singledispatch
+
+@singledispatch
+def f(arg, *, kwarg: int = 0) -> int:
+    return kwarg + 10
+
+@f.register
+def g(arg: int, *, kwarg: int = 5) -> int:
+    return kwarg - 10
+
+def test_keywords():
+    assert f('a') == 10
+    assert f('a', kwarg=3) == 13
+    assert f('a', kwarg=7) == 17
+
+    assert f(1) == -5
+    assert f(1, kwarg=4) == -6
+    assert f(1, kwarg=6) == -4
+
+[case testGeneratorAndMultipleTypesOfIterable]
+from functools import singledispatch
+from typing import *
+
+@singledispatch
+def f(arg: Any) -> Iterable[int]:
+    yield 1
+
+@f.register
+def g(arg: str) -> Iterable[int]:
+    return [0]
+
+def test_iterables():
+    assert f(1) != [1]
+    assert list(f(1)) == [1]
+    assert f('a') == [0]
+
+[case testRegisterUsedAtSameTimeAsOtherDecorators]
+from functools import singledispatch
+from typing import TypeVar
+
+class A: pass
+class B: pass
+
+T = TypeVar('T')
+
+def decorator(f: T) -> T:
+    return f
+
+@singledispatch
+def f(arg) -> int:
+    return 0
+
+@f.register
+@decorator
+def h(arg: str) -> int:
+    return 2
+
+def test_singledispatch():
+    assert f(1) == 0
+    assert f('a') == 2
+
+[case testDecoratorModifiesFunction]
+from functools import singledispatch
+from typing import Callable, Any
+
+class A: pass
+
+def decorator(f: Callable[[Any], int]) -> Callable[[Any], int]:
+    def wrapper(x) -> int:
+        return f(x) * 7
+    return wrapper
+
+@singledispatch
+def f(arg) -> int:
+    return 10
+
+@f.register
+@decorator
+def h(arg: str) -> int:
+    return 5
+
+
+def test_singledispatch():
+    assert f('a') == 35
+    assert f(A()) == 10
+
+[case testMoreSpecificTypeBeforeLessSpecificType]
+from functools import singledispatch
+class A: pass
+class B(A): pass
+
+@singledispatch
+def f(arg) -> str:
+    return 'default'
+
+@f.register
+def g(arg: B) -> str:
+    return 'b'
+
+@f.register
+def h(arg: A) -> str:
+    return 'a'
+
+def test_singledispatch():
+    assert f(B()) == 'b'
+    assert f(A()) == 'a'
+    assert f(5) == 'default'
+
+[case testMultipleRelatedClassesBeingRegistered]
+from functools import singledispatch
+
+class A: pass
+class B(A): pass
+class C(B): pass
+
+@singledispatch
+def f(arg) -> str: return 'default'
+
+@f.register
+def _(arg: A) -> str: return 'a'
+
+@f.register
+def _(arg: C) -> str: return 'c'
+
+@f.register
+def _(arg: B) -> str: return 'b'
+
+def test_singledispatch():
+    assert f(A()) == 'a'
+    assert f(B()) == 'b'
+    assert f(C()) == 'c'
+    assert f(1) == 'default'
+
+[case testRegisteredImplementationsInDifferentFiles]
+from other_a import f, A, B, C
+@f.register
+def a(arg: A) -> int:
+    return 2
+
+@f.register
+def _(arg: C) -> int:
+    return 3
+
+def test_singledispatch():
+    assert f(B()) == 1
+    assert f(A()) == 2
+    assert f(C()) == 3
+    assert f(1) == 0
+
+[file other_a.py]
+from functools import singledispatch
+
+class A: pass
+class B(A): pass
+class C(B): pass
+
+@singledispatch
+def f(arg) -> int:
+    return 0
+
+@f.register
+def g(arg: B) -> int:
+    return 1
+
+[case testOrderCanOnlyBeDeterminedFromMRONotIsinstanceChecks]
+from mypy_extensions import trait
+from functools import singledispatch
+
+@trait
+class A: pass
+@trait
+class B: pass
+class AB(A, B): pass
+class BA(B, A): pass
+
+@singledispatch
+def f(arg) -> str:
+    return "default"
+    pass
+
+@f.register
+def fa(arg: A) -> str:
+    return "a"
+
+@f.register
+def fb(arg: B) -> str:
+    return "b"
+
+def test_singledispatch():
+    assert f(AB()) == "a"
+    assert f(BA()) == "b"
+
+[case testCallingFunctionBeforeAllImplementationsRegistered]
+from functools import singledispatch
+
+class A: pass
+class B(A): pass
+
+@singledispatch
+def f(arg) -> str:
+    return 'default'
+
+assert f(A()) == 'default'
+assert f(B()) == 'default'
+assert f(1) == 'default'
+
+@f.register
+def g(arg: A) -> str:
+    return 'a'
+
+assert f(A()) == 'a'
+assert f(B()) == 'a'
+assert f(1) == 'default'
+
+@f.register
+def _(arg: B) -> str:
+    return 'b'
+
+assert f(A()) == 'a'
+assert f(B()) == 'b'
+assert f(1) == 'default'
+
+
+[case testDynamicallyRegisteringFunctionFromInterpretedCode]
+from functools import singledispatch
+
+class A: pass
+class B(A): pass
+class C(B): pass
+class D(C): pass
+
+@singledispatch
+def f(arg) -> str:
+    return "default"
+
+@f.register
+def _(arg: B) -> str:
+    return 'b'
+
+[file register_impl.py]
+from native import f, A, B, C
+
+@f.register(A)
+def a(arg) -> str:
+    return 'a'
+
+@f.register
+def c(arg: C) -> str:
+    return 'c'
+
+[file driver.py]
+from native import f, A, B, C
+from register_impl import a, c
+# We need a custom driver here because register_impl has to be run before we test this (so that the
+# additional implementations are registered)
+assert f(C()) == 'c'
+assert f(A()) == 'a'
+assert f(B()) == 'b'
+assert a(C()) == 'a'
+assert c(A()) == 'c'
+
+[case testMalformedDynamicRegisterCall]
+from functools import singledispatch
+
+@singledispatch
+def f(arg) -> None:
+    pass
+[file register.py]
+from native import f
+from testutil import assertRaises
+
+with assertRaises(TypeError, 'Invalid first argument to `register()`'):
+    @f.register
+    def _():
+        pass
+
+[file driver.py]
+import register
+
+[case testCacheClearedWhenNewFunctionRegistered]
+from functools import singledispatch
+
+@singledispatch
+def f(arg) -> str:
+    return 'default'
+
+[file register.py]
+from native import f
+class A: pass
+class B: pass
+class C: pass
+
+# annotated function
+assert f(A()) == 'default'
+@f.register
+def _(arg: A) -> str:
+    return 'a'
+assert f(A()) == 'a'
+
+# type passed as argument
+assert f(B()) == 'default'
+@f.register(B)
+def _(arg: B) -> str:
+    return 'b'
+assert f(B()) == 'b'
+
+# 2 argument form
+assert f(C()) == 'default'
+def c(arg) -> str:
+    return 'c'
+f.register(C, c)
+assert f(C()) == 'c'
+
+
+[file driver.py]
+import register