def _generate_unbiased_argument(concrete_type: ConcreteType,
rng: Random) -> Value:
if isinstance(concrete_type, BitsType):
bit_count = concrete_type.get_total_bit_count()
return _generate_bit_value(bit_count, rng, concrete_type.get_signedness())
else:
raise NotImplementedError(
'Generate argument for type: {}'.format(concrete_type))
def concrete_type_to_annotation(
concrete_type: concrete_type_mod.ConcreteType) -> ast.TypeAnnotation:
if isinstance(concrete_type, concrete_type_mod.BitsType):
keyword = SN_KEYWORD if concrete_type.get_signedness() else UN_KEYWORD
num_tok = scanner.Token(scanner.TokenKind.NUMBER, FAKE_SPAN,
concrete_type.get_total_bit_count())
return ast.make_builtin_type_annotation(
FAKE_SPAN, keyword, dims=(ast.Number(num_tok),))
raise NotImplementedError(concrete_type)
def _value_compatible_with_type(type_: ConcreteType, value: Value) -> bool:
"""Returns whether value is compatible with type_ (recursively)."""
assert isinstance(value, Value), value
if isinstance(type_, TupleType) and value.is_tuple():
return all(
_value_compatible_with_type(ct, m)
for ct, m in zip(type_.get_unnamed_members(), value.tuple_members))
if isinstance(type_, ArrayType) and value.is_array():
et = type_.get_element_type()
return all(
_value_compatible_with_type(et, m)
for m in value.array_payload.elements)
if isinstance(type_, EnumType) and value.tag == Tag.ENUM:
return type_.nominal_type == value.type_
if isinstance(type_,
BitsType) and not type_.signed and value.tag == Tag.UBITS:
return value.bits_payload.bit_count == type_.get_total_bit_count()
if isinstance(type_, BitsType) and type_.signed and value.tag == Tag.SBITS:
return value.bits_payload.bit_count == type_.get_total_bit_count()
if value.tag == Tag.ENUM and isinstance(type_, BitsType):
return (value.type_.get_signedness() == type_.get_signedness() and
value.bits_payload.bit_count == type_.get_total_bit_count())
if value.tag == Tag.ARRAY and is_ubits(type_):
flat_bit_count = value.array_payload.flatten().bits_payload.bit_count
return flat_bit_count == type_.get_total_bit_count()
if isinstance(type_, EnumType) and value.is_bits():
return (type_.get_signedness() == (value.tag == Tag.SBITS)
and type_.get_total_bit_count() == value.get_bit_count())
raise NotImplementedError(type_, value)
def generate_argument(arg_type: ConcreteType, rng: Random,
prior: Sequence[Value]) -> Value:
"""Generates an argument value of the same type as the concrete type."""
if isinstance(arg_type, TupleType):
return Value.make_tuple(
tuple(
generate_argument(t, rng, prior)
for t in arg_type.get_unnamed_members()))
elif isinstance(arg_type, ArrayType):
return Value.make_array(
tuple(
generate_argument(arg_type.get_element_type(), rng, prior)
for _ in range(arg_type.size)))
else:
assert isinstance(arg_type, BitsType)
if not prior or rng.random() < 0.5:
return _generate_unbiased_argument(arg_type, rng)
to_mutate = rng.choice(prior)
bit_count = arg_type.get_total_bit_count()
if bit_count > to_mutate.get_bit_count():
to_mutate = to_mutate.bits_payload.concat(
_generate_bit_value(bit_count - to_mutate.get_bit_count(),
rng,
signed=False).bits_payload)
else:
to_mutate = to_mutate.bits_payload.slice(0, bit_count, lsb_is_0=False)
assert to_mutate.bit_count == bit_count
value = to_mutate.value
mutation_count = randrange_biased_towards_zero(bit_count, rng)
for _ in range(mutation_count):
# Pick a random bit and flip it.
bitno = rng.randrange(bit_count)
value ^= 1 << bitno
signed = arg_type.get_signedness()
constructor = Value.make_sbits if signed else Value.make_ubits
return constructor(value=value, bit_count=bit_count)
def ir_value_to_interpreter_value(value: ir_value.Value,
dslx_type: ConcreteType) -> dslx_value.Value:
"""Converts an IR Value to an interpreter Value."""
if value.is_bits():
assert isinstance(dslx_type, BitsType), dslx_type
ir_bits_val = value.get_bits()
if dslx_type.get_signedness():
return dslx_value.Value.make_sbits(
ir_bits_val.bit_count(), bits_to_int(ir_bits_val, signed=True))
return dslx_value.Value.make_ubits(
ir_bits_val.bit_count(), bits_to_int(ir_bits_val, signed=False))
elif value.is_array():
assert isinstance(dslx_type, ArrayType), dslx_type
return dslx_value.Value.make_array(
tuple(
ir_value_to_interpreter_value(e, dslx_type.element_type)
for e in value.get_elements()))
else:
assert value.is_tuple()
assert isinstance(dslx_type, TupleType), dslx_type
return dslx_value.Value.make_tuple(
tuple(
ir_value_to_interpreter_value(e, t) for e, t in zip(
value.get_elements(), t.get_unnamed_members())))