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