예제 #1
0
def can_parse_signature_comment_with_one_formal_type_parameter():
    expected_signature = nodes.signature(
        type_params=[nodes.formal_type_parameter("T")],
        args=[nodes.signature_arg(nodes.ref("T"))],
        returns=nodes.ref("T")
    )
    assert_equal(expected_signature, parse_explicit_type("T => T -> T"))
예제 #2
0
def exception_handler_targets_cannot_be_accessed_from_nested_function():
    target_node = nodes.ref("error")
    ref_node = nodes.ref("error")
    body = [nodes.ret(ref_node)]
    func_node = nodes.func("f", nodes.arguments([]), body, type=None)
    try_node = nodes.try_(
        [],
        handlers=[
            nodes.except_(nodes.none(), target_node, [func_node])
        ],
    )
    
    declaration = name_declaration.ExceptionHandlerTargetNode("error")
    references = References([
        (target_node, declaration),
        (ref_node, declaration),
        (func_node, name_declaration.VariableDeclarationNode("f")),
    ])
    
    try:
        _updated_bindings(try_node, references=references)
        assert False, "Expected error"
    except errors.UnboundLocalError as error:
        assert_equal(ref_node, error.node)
        assert_is("error", error.name)
예제 #3
0
def test_parse_call_with_keyword_arguments():
    expected = nodes.call(
        nodes.ref("f"),
        [],
        {"person": nodes.ref("bob"), "hat": nodes.ref("fedora")},
    )
    _assert_expression_parse(expected, "f(person=bob, hat=fedora)")
예제 #4
0
def test_parse_if_else_statement():
    expected = nodes.if_(
        nodes.ref("b"),
        [nodes.ret(nodes.ref("x"))],
        [nodes.ret(nodes.ref("y"))],
    )
    _assert_statement_parse(expected, "if b:\n  return x\nelse:\n  return y")
예제 #5
0
def test_parse_with_statement_single_context_manager_with_target():
    expected_node = nodes.with_(
        nodes.ref("x"),
        nodes.ref("x2"),
        [nodes.ret(nodes.ref("y"))],
    )
    _assert_statement_parse(expected_node, "with x as x2:\n  return y")
예제 #6
0
def test_parse_try_finally():
    expected = nodes.try_(
        [nodes.expression_statement(nodes.ref("x"))],
        finally_body=[nodes.expression_statement(nodes.ref("y"))],
    )
    
    _assert_statement_parse(expected, "try:\n  x\nfinally:\n  y")
예제 #7
0
def type_of_add_method_argument_allows_super_type():
    cls = types.class_type("Addable", {})
    cls.attrs.add("__add__", types.func([types.object_type], cls))
    
    type_bindings = {"x": cls, "y": cls}
    addition = nodes.add(nodes.ref("x"), nodes.ref("y"))
    assert_equal(cls, infer(addition, type_bindings=type_bindings))
예제 #8
0
def return_type_of_add_can_differ_from_original_type():
    cls = types.class_type("Addable", {})
    cls.attrs.add("__add__", types.func([types.object_type], types.object_type))
    
    type_bindings = {"x": cls, "y": cls}
    addition = nodes.add(nodes.ref("x"), nodes.ref("y"))
    assert_equal(types.object_type, infer(addition, type_bindings=type_bindings))
예제 #9
0
def type_parameters_of_function_are_definitely_bound():
    param = nodes.formal_type_parameter("T")
    arg_ref = nodes.ref("T")
    returns_ref = nodes.ref("T")
    explicit_type = nodes.signature(type_params=[param], args=[nodes.signature_arg(arg_ref)], returns=returns_ref)
    func_node = nodes.func("f", nodes.arguments([]), [], type=explicit_type)
    
    _updated_bindings(func_node)
예제 #10
0
def list_comprehension_target_is_definitely_bound():
    node = nodes.list_comprehension(
        nodes.ref("x"),
        nodes.ref("x"),
        nodes.list_literal([]),
    )
    
    _updated_bindings(node)
예제 #11
0
def attributes_with_function_type_defined_in_class_definition_body_are_not_present_on_meta_type():
    node = nodes.class_("User", [
        nodes.assign([nodes.ref("is_person")], nodes.ref("true_func")),
    ])
    meta_type = _infer_meta_type(node, ["is_person"], type_bindings={
        "true_func": types.func([types.object_type], types.none_type)
    })
    assert "is_person" not in meta_type.attrs
예제 #12
0
def type_name_is_definitely_bound_after_type_definition():
    int_ref = nodes.ref("int")
    str_ref = nodes.ref("str")
    
    node = nodes.type_definition("Identifier", nodes.type_union([int_ref, str_ref]))
    
    bindings = _updated_bindings(node, is_definitely_bound=["int", "str"])
    assert_equal(True, bindings.is_definitely_bound(node))
예제 #13
0
def operands_of_sub_operation_must_support_sub():
    type_bindings = {"x": types.none_type, "y": types.none_type}
    subtraction = nodes.sub(nodes.ref("x"), nodes.ref("y"))
    try:
        infer(subtraction, type_bindings=type_bindings)
        assert False, "Expected error"
    except errors.NoSuchAttributeError as error:
        assert_equal(nodes.attr(subtraction.left, "__sub__"), error.node)
예제 #14
0
def for_statement_target_can_be_supertype_of_iterable_element_type():
    ref_node = nodes.ref("xs")
    node = nodes.for_(nodes.subscript(nodes.ref("ys"), nodes.int_literal(0)), ref_node, [])
    
    update_context(node, type_bindings={
        "xs": types.list_type(types.int_type),
        "ys": types.list_type(types.object_type),
    })
예제 #15
0
def function_definitions_in_statement_lists_can_be_mutually_recursive():
    f = nodes.func("f", type=None, args=nodes.Arguments([]), body=[
        nodes.ret(nodes.call(nodes.ref("g"), []))
    ])
    g = nodes.func("g", type=None, args=nodes.Arguments([]), body=[
        nodes.ret(nodes.call(nodes.ref("f"), []))
    ])
    _update_context([f, g])
예제 #16
0
def test_parse_chained_boolean_operators():
    _assert_expression_parse(
        nodes.bool_and(
            nodes.bool_and(nodes.ref("a"), nodes.ref("b")),
            nodes.ref("c"),
        ),
        "a and b and c"
    )
예제 #17
0
def test_parse_for_loop_with_else_body():
    expected = nodes.for_(
        nodes.ref("x"), nodes.ref("xs"),
        [],
        [nodes.ret(nodes.ref("x"))],
    )
    
    _assert_statement_parse(expected, "for x in xs:\n  pass\nelse:\n  return x")
예제 #18
0
 def test_transform_setitem_subscript(self):
     _assert_transform(
         nodes.assign([nodes.subscript(nodes.ref("x"), nodes.ref("y"))], nodes.ref("z")),
         """
             var __nope_u_tmp0 = z
             x.__setitem__(y, __nope_u_tmp0)
         """
     )
예제 #19
0
def test_parse_single_comparison():
    x = nodes.ref("x")
    y = nodes.ref("y")
    _assert_expression_parse(nodes.eq(x, y), "x == y")
    _assert_expression_parse(nodes.ne(x, y), "x != y")
    _assert_expression_parse(nodes.lt(x, y), "x < y")
    _assert_expression_parse(nodes.le(x, y), "x <= y")
    _assert_expression_parse(nodes.gt(x, y), "x > y")
    _assert_expression_parse(nodes.ge(x, y), "x >= y")
예제 #20
0
 def test_transform_boolean_or(self):
     _assert_transform(
         nodes.bool_or(nodes.ref("x"), nodes.ref("y")),
         cc.ternary_conditional(
             cc.call(cc.builtin("bool"), [cc.ref("x")]),
             cc.ref("x"),
             cc.ref("y")
         ),
     )
예제 #21
0
def type_of_type_union_is_metatype_of_unioned_types():
    type_bindings = {
        "str": types.meta_type(types.str_type),
        "int": types.meta_type(types.int_type),
    }
    node = nodes.type_union([nodes.ref("str"), nodes.ref("int")])
    inferred_type = infer(node, type_bindings=type_bindings)
    assert types.is_meta_type(inferred_type)
    assert_equal(types.union(types.str_type, types.int_type), inferred_type.type)
예제 #22
0
def operands_of_add_operation_must_support_add():
    type_bindings = {"x": types.none_type, "y": types.none_type}
    addition = nodes.add(nodes.ref("x"), nodes.ref("y"))
    try:
        infer(addition, type_bindings=type_bindings)
        assert False, "Expected error"
    except errors.NoSuchAttributeError as error:
        assert_equal(nodes.attr(addition.left, "__add__"), error.node)
        assert_equal(addition.left, ephemeral.root_node(error.node))
예제 #23
0
def list_comprehension_generator_is_not_in_same_scope_as_element():
    target = nodes.ref("target")
    ref = nodes.ref("target")
    iterable = nodes.ref("target")
    node = nodes.list_comprehension(target, ref, iterable)
    
    declarations = _create_declarations(["target"])
    references = resolve(node, declarations)
    assert_is_not(references.referenced_declaration(target), references.referenced_declaration(iterable))
예제 #24
0
def list_comprehension_adds_target_names_to_body_context():
    target = nodes.ref("target")
    ref = nodes.ref("target")
    node = nodes.list_comprehension(target, ref, nodes.none())
    
    declarations = _create_declarations([])
    references = resolve(node, declarations)
    assert not declarations.is_declared("target")
    assert_is(references.referenced_declaration(target), references.referenced_declaration(ref))
예제 #25
0
def function_adds_arguments_to_context():
    signature = nodes.signature(
        args=[nodes.signature_arg(nodes.ref("int"))],
        returns=nodes.ref("int")
    )
    args = nodes.arguments([nodes.argument("x")])
    body = [nodes.ret(nodes.ref("x"))]
    node = nodes.func("f", args, body, type=signature)
    assert_equal(types.func([types.int_type], types.int_type), _infer_func_type(node))
예제 #26
0
def can_parse_signature_with_multiple_args():
    expected_signature = nodes.signature(
        args=[
            nodes.signature_arg(nodes.ref("int")),
            nodes.signature_arg(nodes.ref("str"))
        ],
        returns=nodes.ref("str")
    )
    assert_equal(expected_signature, parse_explicit_type("int, str -> str"))
예제 #27
0
def assignment_to_tuple_declares_variables_in_tuple():
    first_definition_node = nodes.ref("x")
    second_definition_node = nodes.ref("y")
    node = nodes.assign([nodes.tuple_literal([first_definition_node, second_definition_node])], nodes.none())
    declarations = find_declarations(node)
    assert_equal("x", declarations.declaration("x").name)
    assert_equal("y", declarations.declaration("y").name)
    assert isinstance(declarations.declaration("x"), name_declaration.VariableDeclarationNode)
    assert isinstance(declarations.declaration("y"), name_declaration.VariableDeclarationNode)
예제 #28
0
def test_parse_generator_expression():
    _assert_expression_parse(
        nodes.generator_expression(
            nodes.call(nodes.ref("f"), [nodes.ref("x")]),
            nodes.ref("x"),
            nodes.ref("xs"),
        ),
        "(f(x) for x in xs)"
    )
예제 #29
0
def test_parse_single_list_comprehension():
    _assert_expression_parse(
        nodes.list_comprehension(
            nodes.call(nodes.ref("f"), [nodes.ref("x")]),
            nodes.ref("x"),
            nodes.ref("xs"),
        ),
        "[f(x) for x in xs]"
    )
예제 #30
0
def function_definitions_can_be_mutually_recursive():
    f = nodes.func("f", type=None, args=nodes.Arguments([]), body=[
        nodes.ret(nodes.call(nodes.ref("g"), []))
    ])
    g = nodes.func("g", type=None, args=nodes.Arguments([]), body=[
        nodes.ret(nodes.call(nodes.ref("f"), []))
    ])
    
    _updated_bindings(nodes.module([f, g]))