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