Johan B.W. de Vries c8009403c4 Separates out TypeVariable and constraints

They look a lot like placeholders, but they exist before
the typing system takes place. And there's a (much smaller)
context to deal with.

For now, removes Placeholders in user function definitions
as they were not implemented.

Adds signature to function to try to get them closer to
type class methods. Already seeing some benefit in the
constraint generator.

Stricter zipping for safety.

2025-04-27 15:28:08 +02:00

7.3 KiB

Raw Blame History

runtime_extract_value_literal

As a developer I want to extract a $TYPE value In order get the result I calculated with my phasm code

@exported
def testEntry() -> $TYPE:
    return $VAL0

expect(VAL0)

runtime_extract_value_round_trip

As a developer I want to extract a $TYPE value that I've input In order let the code select a value that I've predefined

@exported
def testEntry(x: $TYPE) -> $TYPE:
    return x

expect(VAL0, given=[VAL0])

module_constant_def_ok

As a developer I want to define $TYPE module constants In order to make hardcoded values more visible and to make it easier to change hardcoded values

CONSTANT: $TYPE = $VAL0

@exported
def testEntry() -> i32:
    return 9

expect(9)

module_constant_def_bad

As a developer I want to receive a type error on an invalid assignment on a $TYPE module constant In order to make debugging easier

CONSTANT: (u32, ) = $VAL0

if TYPE_NAME.startswith('tuple_') or TYPE_NAME.startswith('static_array_'):
    expect_type_error(
        'Tuple element count mismatch',
        'The given literal must fit the expected type',
    )
else:
    expect_type_error(
        'Must be tuple',
        'The given literal must fit the expected type',
    )

function_result_is_literal_ok

As a developer I want to use return a literal from a function In order to define constants in a more dynamic way

def drop_arg_return_9(x: $TYPE) -> i32:
    return 9

def constant() -> $TYPE:
    return $VAL0

@exported
def testEntry() -> i32:
    return drop_arg_return_9(constant())

expect(9)

function_result_is_literal_bad

As a developer I want to receive a type error when returning a $TYPE literal for a function that doesn't return that type In order to make debugging easier

def drop_arg_return_9(x: (u32, )) -> i32:
    return 9

def constant() -> (u32, ):
    return $VAL0

@exported
def testEntry() -> i32:
    return drop_arg_return_9(constant())

if TYPE_NAME.startswith('tuple_') or TYPE_NAME.startswith('static_array_'):
    expect_type_error(
        'Mismatch between applied types argument count',
        'The type of a tuple is a combination of its members',
    )
elif TYPE_NAME.startswith('struct_'):
    expect_type_error(
        TYPE + ' must be (u32, ) instead',
        'The type of the value returned from function constant should match its return type',
    )
else:
    expect_type_error(
        'Must be tuple',
        'The given literal must fit the expected type',
    )

function_result_is_module_constant_ok

As a developer I want to use return a $TYPE module constant from a function In order to use my module constants in return statements

CONSTANT: $TYPE = $VAL0

def helper(x: $TYPE) -> i32:
    return 9

def constant() -> $TYPE:
    return CONSTANT

@exported
def testEntry() -> i32:
    return helper(constant())

expect(9)

function_result_is_module_constant_bad

As a developer I want to receive a type error when returning a $TYPE module constant for a function that doesn't return that type In order to make debugging easier

CONSTANT: $TYPE = $VAL0

def drop_arg_return_9(x: (u32, )) -> i32:
    return 9

def constant() -> (u32, ):
    return CONSTANT

@exported
def testEntry() -> i32:
    return drop_arg_return_9(constant())

if TYPE_NAME.startswith('tuple_') or TYPE_NAME.startswith('static_array_') or TYPE_NAME.startswith('struct_'):
    expect_type_error(
        TYPE + ' must be (u32, ) instead',
        'The type of the value returned from function constant should match its return type',
    )
else:
    expect_type_error(
        TYPE_NAME + ' must be (u32, ) instead',
        'The type of the value returned from function constant should match its return type',
    )

function_result_is_arg_ok

As a developer I want to use return a $TYPE function argument In order to make it possible to select a value using a function

CONSTANT: $TYPE = $VAL0

def drop_arg_return_9(x: $TYPE) -> i32:
    return 9

def select(x: $TYPE) -> $TYPE:
    return x

@exported
def testEntry() -> i32:
    return drop_arg_return_9(select(CONSTANT))

expect(9)

function_result_is_arg_bad

As a developer I want to receive a type error when returning a $TYPE argument for a function that doesn't return that type In order to make debugging easier

def drop_arg_return_9(x: (u32, )) -> i32:
    return 9

def select(x: $TYPE) -> (u32, ):
    return x

if TYPE_NAME.startswith('tuple_') or TYPE_NAME.startswith('static_array_') or TYPE_NAME.startswith('struct_'):
    expect_type_error(
        TYPE + ' must be (u32, ) instead',
        'The type of the value returned from function select should match its return type',
    )
else:
    expect_type_error(
        TYPE_NAME + ' must be (u32, ) instead',
        'The type of the value returned from function select should match its return type',
    )

function_arg_literal_ok

As a developer I want to use a $TYPE literal by passing it to a function In order to use a pre-existing function with the values I specify

def helper(x: $TYPE) -> i32:
    return 9

@exported
def testEntry() -> i32:
    return helper($VAL0)

expect(9)

function_arg_literal_bad

As a developer I want to receive a type error when passing a $TYPE literal to a function that does not accept it In order to make debugging easier

def helper(x: (u32, )) -> i32:
    return 9

@exported
def testEntry() -> i32:
    return helper($VAL0)

if TYPE_NAME.startswith('tuple_') or TYPE_NAME.startswith('static_array_'):
    expect_type_error(
        'Mismatch between applied types argument count',
        # FIXME: Shouldn't this be the same as for the else statement?
        'The type of a tuple is a combination of its members',
    )
elif TYPE_NAME.startswith('struct_'):
    expect_type_error(
        TYPE + ' must be (u32, ) instead',
        'The type of the value passed to argument x of function helper should match the type of that argument',
    )
else:
    expect_type_error(
        'Must be tuple',
        'The given literal must fit the expected type',
    )

function_arg_module_constant_def_ok

As a developer I want to use a $TYPE module constant by passing it to a function In order to use my defined value with a pre-existing function

CONSTANT: $TYPE = $VAL0

def helper(x: $TYPE) -> i32:
    return 9

@exported
def testEntry() -> i32:
    return helper(CONSTANT)

expect(9)

function_arg_module_constant_def_bad

As a developer I want to receive a type error when passing a $TYPE module constant to a function that does not accept it In order to make debugging easier

CONSTANT: $TYPE = $VAL0

def helper(x: (u32, )) -> i32:
    return 9

@exported
def testEntry() -> i32:
    return helper(CONSTANT)

if TYPE_NAME.startswith('tuple_') or TYPE_NAME.startswith('static_array_') or TYPE_NAME.startswith('struct_'):
    expect_type_error(
        TYPE + ' must be (u32, ) instead',
        'The type of the value passed to argument 0 of function helper should match the type of that argument',
    )
else:
    expect_type_error(
        TYPE_NAME + ' must be (u32, ) instead',
        'The type of the value passed to argument 0 of function helper should match the type of that argument',
    )

7.3 KiB Raw Blame History