-- Type checker test cases for Python 2.x mode.


[case testUnicode]
u = u'foo'
if int():
    u = unicode()
if int():
    s = ''
if int():
    s = u'foo' # E: Incompatible types in assignment (expression has type "unicode", variable has type "str")
if int():
    s = b'foo'
[builtins_py2 fixtures/python2.pyi]

[case testTypeVariableUnicode]
from typing import TypeVar
T = TypeVar(u'T')

[case testPrintStatement]
print ''() # E: "str" not callable
print 1, 1() # E: "int" not callable

[case testPrintStatementWithTarget]
class A:
    def write(self, s):
        # type: (str) -> None
        pass

class B:
    def write(self):
        # type: () -> int
        pass

print >>A(), ''
print >>None, ''
print >>1, '' # E: "int" has no attribute "write"
print >>(None + ''), None # E: Unsupported left operand type for + ("None")
print >> B(), ''  # E: Argument "file" to "print" has incompatible type "def () -> builtins.int"; expected "def (builtins.str) -> Any"

[case testDivision]
class A:
    def __div__(self, x):
        # type: (int) -> str
        pass
s = A() / 1
if int():
    s = ''
if int():
    s = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "str")

[case testStrUnicodeCompatibility]
import typing
def f(x):
    # type: (unicode) -> None
    pass
f('')
f(u'')
f(b'')
[builtins_py2 fixtures/python2.pyi]

[case testStaticMethodWithCommentSignature]
class A:
    @staticmethod
    def f(x): # type: (int) -> str
        return ''
A.f(1)
A.f('') # E: Argument 1 to "f" of "A" has incompatible type "str"; expected "int"
[builtins_py2 fixtures/staticmethod.pyi]

[case testRaiseTupleTypeFail]
import typing
x = None # type: typing.Type[typing.Tuple[typing.Any, typing.Any, typing.Any]]
raise x # E: Exception must be derived from BaseException
[builtins_py2 fixtures/exception.pyi]

[case testRaiseTupleOfThreeOnPython2]
from types import TracebackType
from typing import Optional, Tuple, Type

e = None  # type: Optional[TracebackType]

# Correct raising several items:

raise BaseException
raise BaseException(1)
raise (BaseException,)
raise (BaseException(1),)
raise BaseException, 1
raise BaseException, 1, e
raise BaseException, 1, None

raise Exception
raise Exception(1)
raise Exception()
raise Exception(1), None
raise Exception(), None
raise Exception(1), None, None
raise Exception(1), None, e
raise (Exception,)
raise (Exception(1),)
raise Exception, 1
raise Exception, 1, e
raise Exception, 1, None

# Errors:

raise int, 1  # E: Argument 1 must be "Type[builtins.BaseException]" subtype
raise int, None  # E: Argument 1 must be "Union[builtins.BaseException, Type[builtins.BaseException]]" subtype
raise Exception(1), 1  # E: Argument 1 must be "Type[builtins.BaseException]" subtype
raise Exception(1), 1, None # E: Argument 1 must be "Type[builtins.BaseException]" subtype
raise Exception, 1, 1  # E: Argument 3 must be "Union[types.TracebackType, None]" subtype
raise int, 1, 1  # E: Argument 1 must be "Type[builtins.BaseException]" subtype \
                 # E: Argument 3 must be "Union[types.TracebackType, None]" subtype

# Correct raising tuple:

t1 = (BaseException,)
t2 = (Exception(1), 2, 3, 4)  # type: Tuple[Exception, int, int, int]
t3 = (Exception,)  # type: Tuple[Type[Exception], ...]
t4 = (Exception(1),)  # type: Tuple[Exception, ...]

raise t1
raise t2
raise t3
raise t4

# Errors:

raise t1, 1, None  # E: Argument 1 must be "Type[builtins.BaseException]" subtype
raise t2, 1        # E: Argument 1 must be "Type[builtins.BaseException]" subtype
raise t3, 1, e     # E: Argument 1 must be "Type[builtins.BaseException]" subtype
raise t4, 1, 1     # E: Argument 1 must be "Type[builtins.BaseException]" subtype \
                   # E: Argument 3 must be "Union[types.TracebackType, None]" subtype

w1 = ()
w2 = (1, Exception)
w3 = (1,)  # type: Tuple[int, ...]

raise w1  # E: Exception must be derived from BaseException
raise w2  # E: When raising a tuple, first element must by derived from BaseException
raise w3  # E: When raising a tuple, first element must by derived from BaseException

# Bare raise:

try:
    pass
except Exception:
    raise  # ok
[builtins_py2 fixtures/exception.pyi]
[file types.pyi]
class TracebackType: pass

[case testTryExceptWithTuple]
try:
    None
except BaseException, e:
    e() # E: "BaseException" not callable
[builtins_py2 fixtures/exception.pyi]

[case testTryExceptUnsupported]
try:
    pass
except BaseException, (e, f):  # E: Sorry, "except <expr>, <anything but a name>" is not supported
    pass
try:
    pass
except BaseException, [e, f, g]:  # E: Sorry, "except <expr>, <anything but a name>" is not supported
    pass
try:
    pass
except BaseException, e[0]:  # E: Sorry, "except <expr>, <anything but a name>" is not supported
    pass
[builtins_py2 fixtures/exception.pyi]

[case testAlternateNameSuggestions]
class Foo(object):
    def say_hello(self):
        pass
    def say_hell(self):
        pass
    def say_hullo(self):
        pass
    def say_goodbye(self):
        pass
    def go_away(self):
        pass
    def go_around(self):
        pass
    def append(self):
        pass
    def extend(self):
        pass
    def _add(self):
        pass

f = Foo()
f.say_hallo() # E: "Foo" has no attribute "say_hallo"; maybe "say_hullo", "say_hello", or "say_hell"?
f.go_array() # E: "Foo" has no attribute "go_array"; maybe "go_away"?
f.add() # E: "Foo" has no attribute "add"; maybe "append", "extend", or "_add"?

[case testTupleArgListDynamicallyTyped]
def f(x, (y, z)):
    x = y + z
f(1, 1)
f(1, (1, 2))

[case testTupleArgListAnnotated]
from typing import Tuple
def f(x, (y, z)): # type: (object, Tuple[int, str]) -> None
    x() # E
    y() # E
    z() # E
f(object(), (1, ''))
f(1, 1) # E
[builtins_py2 fixtures/tuple.pyi]
[out]
main:3: error: "object" not callable
main:4: error: "int" not callable
main:5: error: "str" not callable
main:7: error: Argument 2 to "f" has incompatible type "int"; expected "Tuple[int, str]"

[case testNestedTupleArgListAnnotated]
from typing import Tuple
def f(x, (y, (a, b))): # type: (object, Tuple[int, Tuple[str, int]]) -> None
    x() # E
    y() # E
    a() # E
    b() # E
f(object(), (1, ('', 2)))
f(1, 1) # E
[builtins fixtures/tuple.pyi]
[out]
main:3: error: "object" not callable
main:4: error: "int" not callable
main:5: error: "str" not callable
main:6: error: "int" not callable
main:8: error: Argument 2 to "f" has incompatible type "int"; expected "Tuple[int, Tuple[str, int]]"

[case testBackquoteExpr]
`1`.x # E: "str" has no attribute "x"

[case testImportFromPython2Builtin]
from __builtin__ import int as i
x = 1 # type: i
y = '' # type: i  # E: Incompatible types in assignment (expression has type "str", variable has type "int")

[case testImportPython2Builtin]
import __builtin__
x = 1 # type: __builtin__.int
y = '' # type: __builtin__.int  # E: Incompatible types in assignment (expression has type "str", variable has type "int")

[case testImportAsPython2Builtin]
import __builtin__ as bi
x = 1 # type: bi.int
y = '' # type: bi.int  # E: Incompatible types in assignment (expression has type "str", variable has type "int")

[case testImportFromPython2BuiltinOverridingDefault]
from __builtin__ import int
x = 1 # type: int
y = '' # type: int  # E: Incompatible types in assignment (expression has type "str", variable has type "int")

-- Copied from check-functions.test
[case testEllipsisWithArbitraryArgsOnBareFunctionInPython2]
def f(x, y, z): # type: (...) -> None
    pass

-- Copied from check-functions.test
[case testEllipsisWithSomethingAfterItFailsInPython2]
def f(x, y, z): # type: (..., int) -> None
    pass
[out]
main:1: error: Ellipses cannot accompany other argument types in function type signature

[case testLambdaTupleArgInPython2]
f = lambda (x, y): x + y
f((0, 0))

def g(): # type: () -> None
    pass
reveal_type(lambda (x,): g()) # N: Revealed type is "def (Any)"
[out]

[case testLambdaTupleArgInferenceInPython2]
from typing import Callable, Tuple

def f(c):
    # type: (Callable[[Tuple[int, int]], int]) -> None
    pass
def g(c):
    # type: (Callable[[Tuple[int, int]], str]) -> None
    pass

f(lambda (x, y): y)
f(lambda (x, y): x()) # E: "int" not callable
g(lambda (x, y): y) # E: Argument 1 to "g" has incompatible type "Callable[[Tuple[int, int]], int]"; expected "Callable[[Tuple[int, int]], str]" \
    # E: Incompatible return value type (got "int", expected "str")
[out]

[case testLambdaSingletonTupleArgInPython2]
f = lambda (x,): x + 1
f((0,))
[out]

[case testLambdaNoTupleArgInPython2]
f = lambda (x): x + 1
f(0)
[out]

[case testDefTupleEdgeCasesPython2]
def f((x,)): return x
def g((x)): return x
f(0) + g(0)
[out]

[case testLambdaAsSortKeyForTuplePython2]
from typing import Any, Tuple, Callable
def bar(key):
    # type: (Callable[[Tuple[int, int]], int]) -> int
    pass
def foo():
    # type: () -> int
    return bar(key=lambda (a, b): a)
[out]

[case testImportBuiltins]

import __builtin__
__builtin__.str

[case testUnicodeAlias]
from typing import List
Alias = List[u'Foo']
class Foo: pass
[builtins_py2 fixtures/python2.pyi]

[case testExec]
exec('print 1 + 1')

[case testUnicodeDocStrings]
# flags: --python-version=2.7
__doc__ = u"unicode"

class A:
    u"unicode"

def f():
    # type: () -> None
    u"unicode"

[case testMetaclassBasics]
class M(type):
    x = 0  # type: int
    def test(cls):
        # type: () -> str
        return "test"

class A(object):
    __metaclass__ = M

reveal_type(A.x) # N: Revealed type is "builtins.int"
reveal_type(A.test()) # N: Revealed type is "builtins.str"

[case testImportedMetaclass]
import m

class A(object):
    __metaclass__ = m.M

reveal_type(A.x) # N: Revealed type is "builtins.int"
reveal_type(A.test()) # N: Revealed type is "builtins.str"
[file m.py]
class M(type):
    x = 0
    def test(cls):
        # type: () -> str
        return "test"

[case testDynamicMetaclass]
class C(object):
    __metaclass__ = int()  # E: Dynamic metaclass not supported for "C"

[case testMetaclassDefinedAsClass]
class C(object):
    class __metaclass__: pass # E: Metaclasses defined as inner classes are not supported

[case testErrorInMetaclass]
x = 0
class A(object):
    __metaclass__ = m.M  # E: Name "m" is not defined
class B(object):
    __metaclass__ = M  # E: Name "M" is not defined

[case testMetaclassAndSkippedImportInPython2]
# flags: --ignore-missing-imports
from missing import M
class A(object):
    __metaclass__ = M
    y = 0
reveal_type(A.y) # N: Revealed type is "builtins.int"
A.x # E: "Type[A]" has no attribute "x"

[case testAnyAsBaseOfMetaclass]
from typing import Any, Type
M = None  # type: Any
class MM(M): pass
class A(object):
    __metaclass__ = MM

[case testSelfTypeNotSelfType2]
class A:
    def g(self):
        # type: (None) -> None
        pass
[out]
main:2: error: Invalid type for self, or extra argument type in function annotation
main:2: note: (Hint: typically annotations omit the type for self)

[case testSuper]
class A:
    def f(self): # type: () -> None
        pass
class B(A):
    def g(self): # type: () -> None
        super(B, self).f()
        super().f() # E: Too few arguments for "super"

[case testPartialTypeComments_python2]
def foo(
    a,  # type: str
    b,
    args=None,
):
    # type: (...) -> None
    pass

[case testNoneHasNoBoolInPython2]
none = None
b = none.__bool__() # E: "None" has no attribute "__bool__"

[case testDictWithoutTypeCommentInPython2]
# flags: --py2
d = dict() # E: Need type comment for "d" (hint: "d = ...  \# type: Dict[<type>, <type>]")
[builtins_py2 fixtures/floatdict_python2.pyi]