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