Python formal_type_parameter Examples

Example #1

File: typing_tests.py Project: mwilliamson/nope

def generic_specifiers_can_define_multiple_formal_type_parameters():
    source = """
#:generic T1, T2, R
class A:
    pass
"""
    note = _parse_generic_note(source)
    expected = [
        nodes.formal_type_parameter("T1"),
        nodes.formal_type_parameter("T2"),
        nodes.formal_type_parameter("R"),
    ]
    assert_equal(expected, note)

Example #2

File: typing_tests.py Project: mwilliamson/nope

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"))

Example #3

File: name_binding_tests.py Project: mwilliamson/nope

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)

Example #4

File: typing_tests.py Project: mwilliamson/nope

def generic_specifiers_use_generic_keyword():
    source = """
#:generic T
class A:
    pass
"""
    note = _parse_generic_note(source)
    assert_equal([nodes.formal_type_parameter("T")], note)

Example #5

File: name_declaration_tests.py Project: mwilliamson/nope

def names_in_function_signature_are_not_declared_in_outer_scope():
    explicit_type = nodes.signature(
        type_params=[nodes.formal_type_parameter("T")],
        args=[],
        returns=nodes.ref("T"),
    )
    node = nodes.func("f", nodes.arguments([]), [], type=explicit_type)
    
    declarations = find_declarations(node)
    assert not declarations.is_declared("T")

Example #6

File: function_definition_tests.py Project: mwilliamson/nope

def can_type_check_generic_function_with_type_parameters():
    signature = nodes.signature(
        type_params=[nodes.formal_type_parameter("T")],
        args=[
            nodes.signature_arg(nodes.ref("T")),
        ],
        returns=nodes.ref("T"),
    )
    args = nodes.arguments([
        nodes.argument("value"),
    ])
    node = nodes.func("f", args=args, body=[nodes.ret(nodes.ref("value"))], type=signature)
    assert_equal(types.func([types.int_type], types.int_type), _infer_func_type(node).instantiate([types.int_type]))

Example #7

File: function_signature_tests.py Project: mwilliamson/nope

def type_of_generic_function_signature_is_metatype_of_function():
    node = nodes.signature(
        type_params=[nodes.formal_type_parameter("T")],
        args=[nodes.signature_arg(nodes.ref("T"))],
        returns=nodes.ref("T")
    )
    inferred_type = infer(node)
    assert types.is_meta_type(inferred_type)
    assert types.is_generic_func(inferred_type.type)
    formal_type_param, = inferred_type.type.formal_type_params
    assert_equal(
        types.func([formal_type_param], formal_type_param),
        inferred_type.type.instantiate([formal_type_param]),
    )

Example #8

File: desugar_tests.py Project: mwilliamson/nope

 def test_does_not_redeclare_variables_with_same_name_as_type_parameter(self):
     _assert_transform(
         nodes.func(
             name="f",
             args=nodes.args([]),
             body=[],
             type=nodes.signature(
                 type_params=[nodes.formal_type_parameter("T")],
                 args=[],
                 returns=nodes.ref("T"),
             ),
         ),
         cc.func("f", [], [
             cc.ret(cc.none),
         ])
     )

Example #9

File: name_resolution_tests.py Project: mwilliamson/nope

def generic_function_definition_signature_has_names_resolved():
    param = nodes.formal_type_parameter("T")
    arg_ref = nodes.ref("T")
    return_ref = nodes.ref("T")
    
    signature = nodes.signature(
        type_params=[param],
        args=[nodes.signature_arg(arg_ref)],
        returns=return_ref,
    )
    node = nodes.func("f", nodes.arguments([]), [], type=signature)
    
    declarations = _create_declarations(["f"])
    references = resolve(node, declarations)
    assert not declarations.is_declared("T")
    assert_is(references.referenced_declaration(param), references.referenced_declaration(arg_ref))
    assert_is(references.referenced_declaration(param), references.referenced_declaration(return_ref))

Example #10

File: name_resolution_tests.py Project: mwilliamson/nope

def formal_type_parameter_is_resolved_to_type_declaration():
    node = nodes.formal_type_parameter("T")
    
    declarations = _create_declarations(["T"])
    references = resolve(node, declarations)
    assert_is(declarations.declaration("T"), references.referenced_declaration(node))

Example #11

File: parser_tests.py Project: mwilliamson/nope

def test_parse_class_with_generics():
    expected_node = nodes.class_("Option", [], type_params=[nodes.formal_type_parameter("T")])
    _assert_statement_parse(expected_node, "#:generic T\nclass Option:\n  pass")

Example #12

File: name_declaration_tests.py Project: mwilliamson/nope

def declarations_in_class_include_formal_type_parameters():
    node = nodes.class_("Option", [], type_params=[nodes.formal_type_parameter("T")])
    
    declarations = _declarations_in(node)
    assert isinstance(declarations.declaration("T"), name_declaration.TypeDeclarationNode)

Example #13

File: name_declaration_tests.py Project: mwilliamson/nope

def declarations_in_function_include_type_parameter_declarations():
    explicit_type = nodes.signature(type_params=[nodes.formal_type_parameter("T")], args=[], returns=nodes.ref("none"))
    node = nodes.func("f", nodes.arguments([]), [], type=explicit_type)
    
    declarations = _declarations_in(node)
    assert isinstance(declarations.declaration("T"), name_declaration.TypeDeclarationNode)

Example #14

File: name_declaration_tests.py Project: mwilliamson/nope

def formal_type_parameter_is_declared():
    node = nodes.formal_type_parameter("T")
    
    declarations = find_declarations(node)
    assert_equal("T", declarations.declaration("T").name)
    assert isinstance(declarations.declaration("T"), name_declaration.TypeDeclarationNode)

Example #15

File: class_definition_tests.py Project: mwilliamson/nope

def name_of_instantiation_of_generic_class_includes_type_parameters():
    node = nodes.class_("Option", [], type_params=[nodes.formal_type_parameter("T")])
    class_type = _infer_class_type(node, [])
    assert_equal("Option[int]", class_type(types.int_type).name)