def _generate_cast_bits_to_array( self, env: Env) -> Tuple[ast.Cast, ast.TypeAnnotation]: """Generates a cast from bits to array type.""" # Get a random bits-typed element from the environment. make_arg, arg_type = self._choose_env_value(env, self._is_builtin_unsigned) # Next, find factors of the bit count and select one pair. bit_count = builtin_type_to_bits(arg_type) factors = [] for i in range(1, bit_count + 1): if bit_count % i == 0: factors.append((i, bit_count // i)) element_size, array_size = self.rng.choice(factors) element_type = ast_helpers.make_builtin_type_annotation( self.m, self.fake_span, scanner.Token(value=scanner.Keyword.UN, span=self.fake_span), (self._make_number(element_size, None), )) outer_array_type = self._make_array_type(element_type, array_size) return (ast.Cast(self.m, self.fake_span, outer_array_type, make_arg()), outer_array_type)
def _make_type_annotation(self, signed: bool, width: int) -> ast.TypeAnnotation: assert width > 0, width if width <= 64: return ast.BuiltinTypeAnnotation( self.m, self.fake_span, ast_helpers.get_builtin_type(signed, width)) else: token = scanner.Token(self.fake_span, scanner.KeywordFromString('sN' if signed else 'uN')) return ast_helpers.make_builtin_type_annotation( self.m, self.fake_span, token, dims=(self._make_number(width, None),))
def _make_identifier_token(self, identifier: Text) -> scanner.Token: return scanner.Token(scanner.TokenKind.IDENTIFIER, self.fake_span, identifier)
def _generate_type_primitive(self) -> scanner.Token: """Generates a primitive type token for use in building a type.""" kw_identifier = self.rng.choice(self._kw_identifiers) return scanner.Token(self.fake_span, scanner.KeywordFromString(kw_identifier))
from xls.dslx import parser_helpers from xls.dslx import span from xls.dslx import typecheck from xls.dslx import xls_type_error from xls.dslx.interpreter import interpreter as interpreter_mod from xls.dslx.interpreter import value as value_mod from xls.dslx.python import cpp_concrete_type as concrete_type_mod from xls.dslx.python import cpp_parser as parser from xls.dslx.python import cpp_pos from xls.dslx.python import cpp_scanner as scanner FLAGS = flags.FLAGS FILENAME = '/fake/repl.x' FAKE_POS = cpp_pos.Pos(FILENAME, 0, 0) FAKE_SPAN = cpp_pos.Span(FAKE_POS, FAKE_POS) UN_KEYWORD = scanner.Token(FAKE_SPAN, scanner.Keyword.UN) SN_KEYWORD = scanner.Token(FAKE_SPAN, scanner.Keyword.SN) def handle_line(line: str, stmt_index: int): """Runs a single user-provided line as a REPL input.""" fn_name = f'repl_{stmt_index}' module_text = f""" import std fn {fn_name}() -> () {{ {line} }} """ # For error reporting we use a helper that puts this into a fake filesystem # location.
def test_types(self): g = ast_generator.AstGenerator(random.Random(0), ast_generator.AstGeneratorOptions()) _, m = g.generate_function_in_module('main', 'test') u1 = g._make_type_annotation(signed=False, width=1) self.assertEqual(g._get_type_bit_count(u1), 1) self.assertTrue(g._is_bit_vector(u1)) self.assertTrue(g._is_unsigned_bit_vector(u1)) self.assertFalse(g._is_array(u1)) self.assertFalse(g._is_tuple(u1)) s1 = g._make_type_annotation(signed=True, width=1) self.assertTrue(g._is_bit_vector(s1)) self.assertFalse(g._is_unsigned_bit_vector(s1)) self.assertEqual(g._get_type_bit_count(s1), 1) self.assertFalse(g._is_array(s1)) self.assertFalse(g._is_tuple(s1)) u42 = g._make_type_annotation(signed=False, width=42) self.assertEqual(g._get_type_bit_count(u42), 42) self.assertTrue(g._is_bit_vector(u42)) self.assertTrue(g._is_unsigned_bit_vector(u42)) self.assertFalse(g._is_array(u42)) self.assertFalse(g._is_tuple(u42)) empty_tuple = g._make_tuple_type(()) self.assertEqual(g._get_type_bit_count(empty_tuple), 0) self.assertFalse(g._is_bit_vector(empty_tuple)) self.assertFalse(g._is_unsigned_bit_vector(empty_tuple)) self.assertFalse(g._is_array(empty_tuple)) self.assertTrue(g._is_tuple(empty_tuple)) tple = g._make_tuple_type((empty_tuple, s1, u1, u42, u42)) self.assertEqual(g._get_type_bit_count(tple), 86) self.assertFalse(g._is_bit_vector(tple)) self.assertFalse(g._is_unsigned_bit_vector(tple)) self.assertFalse(g._is_array(tple)) self.assertTrue(g._is_tuple(tple)) nested_tuple = g._make_tuple_type((tple, u42, tple)) self.assertEqual(g._get_type_bit_count(nested_tuple), 214) self.assertFalse(g._is_bit_vector(nested_tuple)) self.assertFalse(g._is_unsigned_bit_vector(nested_tuple)) self.assertFalse(g._is_array(nested_tuple)) self.assertTrue(g._is_tuple(nested_tuple)) array_of_u42 = g._make_array_type(u42, 100) self.assertEqual(g._get_type_bit_count(array_of_u42), 4200) self.assertFalse(g._is_bit_vector(array_of_u42)) self.assertFalse(g._is_unsigned_bit_vector(array_of_u42)) self.assertEqual(g._get_array_size(array_of_u42), 100) self.assertTrue(g._is_array(array_of_u42)) self.assertFalse(g._is_tuple(array_of_u42)) array_of_tuple = g._make_array_type(nested_tuple, 10) self.assertEqual(g._get_type_bit_count(array_of_tuple), 2140) self.assertFalse(g._is_bit_vector(array_of_tuple)) self.assertFalse(g._is_unsigned_bit_vector(array_of_tuple)) self.assertEqual(g._get_array_size(array_of_tuple), 10) self.assertTrue(g._is_array(array_of_tuple)) self.assertFalse(g._is_tuple(array_of_tuple)) u11_token = scanner.Token(g.fake_span, scanner.KeywordFromString('u11')) u11 = ast_helpers.make_builtin_type_annotation(m, g.fake_span, u11_token, dims=()) self.assertEqual(g._get_type_bit_count(u11), 11) self.assertTrue(g._is_bit_vector(u11)) self.assertTrue(g._is_unsigned_bit_vector(u11)) self.assertFalse(g._is_array(u11)) self.assertFalse(g._is_tuple(u11)) un_token = scanner.Token(g.fake_span, scanner.KeywordFromString('uN')) un1234 = ast_helpers.make_builtin_type_annotation(m, g.fake_span, un_token, dims=(g._make_number( 1234, None), )) self.assertEqual(g._get_type_bit_count(un1234), 1234) self.assertTrue(g._is_bit_vector(un1234)) self.assertTrue(g._is_unsigned_bit_vector(un1234)) self.assertFalse(g._is_array(un1234)) self.assertFalse(g._is_tuple(un1234)) sn_token = scanner.Token(g.fake_span, scanner.KeywordFromString('sN')) sn1234 = ast_helpers.make_builtin_type_annotation(m, g.fake_span, sn_token, dims=(g._make_number( 1234, None), )) self.assertEqual(g._get_type_bit_count(sn1234), 1234) self.assertTrue(g._is_bit_vector(sn1234)) self.assertFalse(g._is_unsigned_bit_vector(sn1234)) self.assertFalse(g._is_array(sn1234)) self.assertFalse(g._is_tuple(sn1234)) bits_token = scanner.Token(g.fake_span, scanner.KeywordFromString('bits')) bits1234 = ast_helpers.make_builtin_type_annotation( m, g.fake_span, bits_token, dims=(g._make_number(1234, None), )) self.assertEqual(g._get_type_bit_count(bits1234), 1234) self.assertTrue(g._is_bit_vector(bits1234)) self.assertTrue(g._is_unsigned_bit_vector(bits1234)) self.assertFalse(g._is_array(bits1234)) self.assertFalse(g._is_tuple(bits1234)) un1234_10 = ast_helpers.make_builtin_type_annotation( m, g.fake_span, un_token, dims=(g._make_number(1234, None), g._make_number(10, None))) self.assertEqual(g._get_type_bit_count(un1234_10), 12340) self.assertFalse(g._is_bit_vector(un1234_10)) self.assertFalse(g._is_unsigned_bit_vector(un1234_10)) self.assertTrue(g._is_array(un1234_10)) self.assertFalse(g._is_tuple(un1234_10))