def test_type_annotation_properties(self):
m = self.m
fake_span = self.fake_span
number_5 = ast.Number(m, fake_span, '5')
number_2 = ast.Number(m, fake_span, '2')
number_3 = ast.Number(m, fake_span, '3')
bits_token = Token(TokenKind.KEYWORD, value=Keyword.BITS, span=fake_span)
un_token = Token(TokenKind.KEYWORD, value=Keyword.UN, span=fake_span)
u32_token = Token(TokenKind.KEYWORD, value=Keyword.U32, span=fake_span)
type_ = ast_helpers.make_builtin_type_annotation(m, fake_span, bits_token,
(number_5,))
self.assertEqual('bits[5]', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(m, fake_span, bits_token,
(number_5, number_2))
self.assertIsInstance(type_, ast.ArrayTypeAnnotation)
self.assertEqual('bits[5][2]', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(m, fake_span, u32_token,
())
self.assertEqual('u32', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(m, fake_span, u32_token,
(number_3,))
self.assertIsInstance(type_, ast.ArrayTypeAnnotation)
self.assertEqual('u32[3]', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(m, fake_span, un_token,
(number_2,))
self.assertEqual('uN[2]', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(m, fake_span, un_token,
(number_2, number_3))
self.assertIsInstance(type_, ast.ArrayTypeAnnotation)
self.assertEqual('uN[2][3]', str(type_))
# TODO(leary): 2020-08-24 delete bits in favor of uN
# "no-volume" bits array.
type_ = ast_helpers.make_builtin_type_annotation(m, fake_span, bits_token,
())
self.assertEqual('bits', str(type_))
# TypeRef with dims.
name_def = ast.NameDef(m, fake_span, 'MyType')
type_def = ast.TypeDef(m, False, name_def, type_)
type_ref = ast.TypeRef(m, fake_span, 'MyType', type_def=type_def)
type_ = ast_helpers.make_type_ref_type_annotation(m, fake_span, type_ref,
(number_2, number_3))
self.assertIsInstance(type_, ast.ArrayTypeAnnotation)
self.assertEqual('MyType[2][3]', str(type_))
type_ = ast.TupleTypeAnnotation(
m, fake_span,
(ast_helpers.make_builtin_type_annotation(m, fake_span, bits_token,
(number_5,)),
ast_helpers.make_builtin_type_annotation(m, fake_span, bits_token,
(number_2,))))
self.assertIsInstance(type_, ast.TupleTypeAnnotation)
self.assertEqual('(bits[5], bits[2])', str(type_))
def test_stringify_type(self):
fake_span = self.fake_span
m = self.m
number_5 = ast.Number(m, fake_span, '5')
number_2 = ast.Number(m, fake_span, '2')
number_3 = ast.Number(m, fake_span, '3')
bits_token = Token(TokenKind.KEYWORD, value=Keyword.BITS, span=fake_span)
type_ = ast_helpers.make_builtin_type_annotation(m, fake_span, bits_token,
(number_5,))
self.assertEqual('bits[5]', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span,
Token(TokenKind.KEYWORD, value=Keyword.U32,
span=fake_span), (number_5,))
self.assertEqual('u32[5]', str(type_))
# "no-volume" bits array.
# TODO(leary): 2020-08-24 delete bits in favor of uN
type_ = ast_helpers.make_builtin_type_annotation(m, fake_span, bits_token,
())
self.assertEqual('bits', str(type_))
# TypeRef with dims.
my_type_tok = Token(TokenKind.IDENTIFIER, value='MyType', span=fake_span)
name_def = ast.NameDef(m, fake_span, 'MyType')
type_def = ast.TypeDef(m, False, name_def, type_)
type_ref = ast.TypeRef(m, fake_span, my_type_tok.value, type_def=type_def)
type_ = ast_helpers.make_type_ref_type_annotation(m, fake_span, type_ref,
(number_2, number_3))
self.assertEqual('MyType[2][3]', str(type_))
def concrete_type_from_dims(primitive: Token,
dims: Tuple[int, ...]) -> 'ConcreteType':
"""Creates a concrete type from the primitive type token and dims.
Args:
primitive: The token holding the primitive type as a keyword.
dims: Dimensions to apply to the primitive type; e.g. () is scalar, (5) is
1-D array of 5 elements having the primitive type.
Returns:
A concrete type object.
Raises:
ValueError: If the primitive keyword is unrecognized or dims are empty.
"""
if primitive.is_keyword(Keyword.BITS) or primitive.is_keyword(Keyword.UN):
base_type = BitsType(signed=False, size=dims[-1])
elif primitive.is_keyword(Keyword.SN):
base_type = BitsType(signed=True, size=dims[-1])
else:
assert primitive.kind == TokenKind.KEYWORD
signedness, bits = TYPE_KEYWORDS_TO_SIGNEDNESS_AND_BITS[
primitive.value]
element_type = BitsType(signedness, bits)
while dims:
dims, minor = dims[:-1], dims[-1]
element_type = ArrayType(element_type, minor)
return element_type
result = concrete_type_from_element_type_and_dims(base_type, dims[:-1])
logging.vlog(4, '%r %r => %r', primitive, dims, result)
return result
def test_format_binop(self):
m = ast.Module('test')
fake_pos = self.fake_pos
fake_span = Span(fake_pos, fake_pos)
le = ast.Binop(m, Token(TokenKind.OANGLE_EQUALS, span=fake_span), self.five,
self.five)
self.assertEqual('(5) <= (5)', str(le))
def __init__(self, operator: Token, lhs: Expr, rhs: Expr):
super(Binop, self).__init__(operator.span)
self.operator = operator
assert operator.is_kind_or_keyword(self.ALL_KINDS), \
'Unknown operator for binop AST: {}'.format(operator.kind)
self.lhs = lhs
self.rhs = rhs
def test_visit_unop(self):
fake_span = self.fake_span
i_def = ast.NameDef(fake_span, 'i')
i_ref = ast.NameRef(fake_span, 'i', i_def)
negated = ast.Unop(Token(TokenKind.MINUS, fake_span), i_ref)
c = _Collector()
negated.accept(c)
self.assertEqual(c.collected, [i_ref, negated])
def test_visit_type(self):
fake_span = self.fake_span
five = self.five
# Make a uN[5] type node.
t = ast_helpers.make_builtin_type_annotation(
self.m,
fake_span,
Token(TokenKind.KEYWORD, value=Keyword.BITS, span=fake_span),
dims=(five,))
assert isinstance(t, ast.ArrayTypeAnnotation), t
c = _Collector()
t.accept(c)
self.assertEqual(c.collected, [five, t])
def tok_to_builtin_type(tok: scanner.Token) -> ast.BuiltinType: assert tok.is_keyword_in(scanner.TYPE_KEYWORDS) bt = getattr(ast.BuiltinType, tok.value.value.upper()) assert isinstance(bt, ast.BuiltinType), repr(bt) return bt
def __init__(self, operator: Token, operand: Expr): assert operator.is_kind_or_keyword(self.OPERATORS), operator super(Unop, self).__init__(operator.span) self.operator = operator self.operand = operand
def __init__(self, owner: AstNodeOwner, operator: Token, operand: Expr):
assert operator.is_kind_or_keyword(self.OPERATORS), operator
super().__init__(owner, operator.span)
self.operator = operator
self.operand = operand
def __init__(self, span: Span, tok: Token): super().__init__(span) assert isinstance(tok, Token), tok assert tok.is_keyword_in(TYPE_KEYWORDS), tok self.tok = tok
