#!/usr/bin/env python

from __future__ import absolute_import, division, print_function, unicode_literals

# pylint: disable=deprecated-method,useless-suppression

import datetime

import textwrap

import unittest

from stone.frontend.ast import (

AstNamespace,

AstAlias,

AstVoidField,

AstTagRef,

)

from stone.frontend.exception import InvalidSpec

from stone.frontend.frontend import specs_to_ir

from stone.frontend.parser import ParserFactory

from stone.ir import (

Alias,

is_boolean_type,

is_integer_type,

is_void_type,

Nullable,

RedactedBlot,

RedactedHash,

String,

Map

)

class TestStone(unittest.TestCase):

"""

Tests the Stone format.

"""

def setUp(self):

self.parser_factory = ParserFactory(debug=False)

def test_namespace_decl(self):

text = textwrap.dedent("""\

namespace files

""")

out = self.parser_factory.get_parser().parse(text)

self.assertIsInstance(out[0], AstNamespace)

self.assertEqual(out[0].name, 'files')

# test starting with newlines

text = textwrap.dedent("""\

namespace files

""")

out = self.parser_factory.get_parser().parse(text)

self.assertIsInstance(out[0], AstNamespace)

self.assertEqual(out[0].name, 'files')

def test_comments(self):

text = textwrap.dedent("""\

# comment at top

namespace files

# another full line comment

alias Rev = String # partial line comment

struct S # comment before INDENT

"Doc"

# inner comment

f1 UInt64 # partial line comment

# f2 UInt64

# trailing comment

struct S2 # struct def following comment

# start with comment

f1 String # end with partial-line comment

# footer comment

""")

out = self.parser_factory.get_parser().parse(text)

self.assertIsInstance(out[0], AstNamespace)

self.assertIsInstance(out[1], AstAlias)

self.assertEqual(out[2].name, 'S')

self.assertEqual(out[3].name, 'S2')

def test_line_continuations(self):

line_continuation_err = 'Line continuation must increment indent by 1.'

# Test continuation in various contexts

text = textwrap.dedent("""\

namespace test

alias U64 = UInt64(

min_value=0, max_value=10)

struct S

val UInt64(

min_value=0,

max_value=10)

val2 UInt64(

# this

# is

# a

min_value=0

# stress

# test

)

route r(

S,

S,

S

)

"Test route."

""")

specs_to_ir([('test.stone', text)])

# Try over indenting

text = textwrap.dedent("""\

namespace test

struct S

val UInt64(

# comment to throw it off

min_value=0)

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertEqual(line_continuation_err, cm.exception.msg)

self.assertEqual(cm.exception.lineno, 6)

# Try under indenting

text = textwrap.dedent("""\

namespace test

struct S

val UInt64(

# comment to throw it off

# x2

min_value=0)

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertEqual(line_continuation_err, cm.exception.msg)

self.assertEqual(cm.exception.lineno, 7)

def test_type_args(self):

text = textwrap.dedent("""\

namespace test

alias T = String(min_length=3)

alias F = Float64(max_value=3.2e1)

alias Numbers = List(UInt64)

""")

out = self.parser_factory.get_parser().parse(text)

self.assertIsInstance(out[1], AstAlias)

self.assertEqual(out[1].name, 'T')

self.assertEqual(out[1].type_ref.name, 'String')

self.assertEqual(out[1].type_ref.args[1]['min_length'], 3)

self.assertIsInstance(out[2], AstAlias)

self.assertEqual(out[2].name, 'F')

self.assertEqual(out[2].type_ref.name, 'Float64')

self.assertEqual(out[2].type_ref.args[1]['max_value'], 3.2e1)

self.assertIsInstance(out[3], AstAlias)

self.assertEqual(out[3].name, 'Numbers')

self.assertEqual(out[3].type_ref.name, 'List')

self.assertEqual(out[3].type_ref.args[0][0].name, 'UInt64')

def test_struct_decl(self):

# test struct decl with no docs

text = textwrap.dedent("""\

namespace files

struct QuotaInfo

quota UInt64

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'QuotaInfo')

self.assertEqual(out[1].fields[0].name, 'quota')

self.assertEqual(out[1].fields[0].type_ref.name, 'UInt64')

# test struct with only a top-level doc

text = textwrap.dedent("""\

namespace files

struct QuotaInfo

"The space quota info for a user."

quota UInt64

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'QuotaInfo')

self.assertEqual(out[1].doc, 'The space quota info for a user.')

self.assertEqual(out[1].fields[0].name, 'quota')

self.assertEqual(out[1].fields[0].type_ref.name, 'UInt64')

# test struct with field doc

text = textwrap.dedent("""\

namespace files

struct QuotaInfo

"The space quota info for a user."

quota UInt64

"The user's total quota allocation (bytes)."

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'QuotaInfo')

self.assertEqual(out[1].doc, 'The space quota info for a user.')

self.assertEqual(out[1].fields[0].name, 'quota')

self.assertEqual(out[1].fields[0].type_ref.name, 'UInt64')

self.assertEqual(out[1].fields[0].doc, "The user's total quota allocation (bytes).")

# test without newline after field doc

text = textwrap.dedent("""\

namespace files

struct QuotaInfo

"The space quota info for a user."

quota UInt64

"The user's total quota allocation (bytes)."

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'QuotaInfo')

self.assertEqual(out[1].doc, 'The space quota info for a user.')

self.assertEqual(out[1].fields[0].name, 'quota')

self.assertEqual(out[1].fields[0].type_ref.name, 'UInt64')

self.assertEqual(out[1].fields[0].doc, "The user's total quota allocation (bytes).")

# test with example

text = textwrap.dedent("""\

namespace files

struct QuotaInfo

"The space quota info for a user."

quota UInt64

"The user's total quota allocation (bytes)."

example default

quota=64000

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'QuotaInfo')

self.assertIn('default', out[1].examples)

# test with multiple examples

text = textwrap.dedent("""\

namespace files

struct QuotaInfo

"The space quota info for a user."

quota UInt64

"The user's total quota allocation (bytes)."

example default

quota=2000000000

example pro

quota=100000000000

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'QuotaInfo')

self.assertIn('default', out[1].examples)

self.assertIn('pro', out[1].examples)

# test with inheritance

text = textwrap.dedent("""\

namespace test

struct S1

f1 UInt64

struct S2 extends S1

f2 String

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'S1')

self.assertEqual(out[2].name, 'S2')

self.assertEqual(out[2].extends.name, 'S1')

# test with defaults

text = textwrap.dedent("""\

namespace ns

struct S

n1 Int32 = -5

n2 Int32 = 5

f1 Float64 = -1.

f2 Float64 = -4.2

f3 Float64 = -5e-3

f4 Float64 = -5.1e-3

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'S')

self.assertEqual(out[1].fields[0].name, 'n1')

self.assertTrue(out[1].fields[0].has_default)

self.assertEqual(out[1].fields[0].default, -5)

self.assertEqual(out[1].fields[1].default, 5)

self.assertEqual(out[1].fields[2].default, -1)

self.assertEqual(out[1].fields[3].default, -4.2)

self.assertEqual(out[1].fields[4].default, -5e-3)

self.assertEqual(out[1].fields[5].default, -5.1e-3)

# Try extending nullable type

text = textwrap.dedent("""\

namespace test

struct S

f1 String

struct S2 extends S?

f2 String

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertEqual("Reference cannot be nullable.", cm.exception.msg)

self.assertEqual(cm.exception.lineno, 6)

def test_struct_patch_decl(self):

# test struct patch decl with no docs

text = textwrap.dedent("""\

namespace files

patch struct QuotaInfo

quota UInt64

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'QuotaInfo')

self.assertEqual(out[1].fields[0].name, 'quota')

self.assertEqual(out[1].fields[0].type_ref.name, 'UInt64')

# test struct patch with a top-level doc

text = textwrap.dedent("""\

namespace files

patch struct QuotaInfo

"The space quota info for a user."

quota UInt64

""")

out = self.parser_factory.get_parser().parse(text)

msg, lineno, _ = self.parser_factory.get_parser().errors[0]

# Can't parse patch with doc-string.

self.assertEqual(msg, "Unexpected STRING with value 'The " +

"space quota info for a user.'.")

self.assertEqual(lineno, 3)

# test struct patch with field doc

text = textwrap.dedent("""\

namespace files

patch struct QuotaInfo

quota UInt64

"The user's total quota allocation (bytes)."

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'QuotaInfo')

self.assertEqual(out[1].fields[0].name, 'quota')

self.assertEqual(out[1].fields[0].type_ref.name, 'UInt64')

self.assertEqual(out[1].fields[0].doc, "The user's total quota allocation (bytes).")

# test with example

text = textwrap.dedent("""\

namespace files

patch struct QuotaInfo

quota UInt64

"The user's total quota allocation (bytes)."

example default

quota=64000

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'QuotaInfo')

self.assertIn('default', out[1].examples)

# test with multiple examples

text = textwrap.dedent("""\

namespace files

patch struct QuotaInfo

quota UInt64

"The user's total quota allocation (bytes)."

example default

quota=2000000000

example pro

quota=100000000000

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'QuotaInfo')

self.assertIn('default', out[1].examples)

self.assertIn('pro', out[1].examples)

# test with defaults

text = textwrap.dedent("""\

namespace ns

patch struct S

n1 Int32 = -5

n2 Int32 = 5

f1 Float64 = -1.

f2 Float64 = -4.2

f3 Float64 = -5e-3

f4 Float64 = -5.1e-3

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'S')

self.assertEqual(out[1].fields[0].name, 'n1')

self.assertTrue(out[1].fields[0].has_default)

self.assertEqual(out[1].fields[0].default, -5)

self.assertEqual(out[1].fields[1].default, 5)

self.assertEqual(out[1].fields[2].default, -1)

self.assertEqual(out[1].fields[3].default, -4.2)

self.assertEqual(out[1].fields[4].default, -5e-3)

self.assertEqual(out[1].fields[5].default, -5.1e-3)

# test no patching enumerated subtype

text = textwrap.dedent("""\

namespace test

struct Resource

union

file File

folder Folder

struct File extends Resource

size UInt64

struct Folder extends Resource

icon String

struct Deleted extends Resource

is_folder Boolean

patch struct Resource

union

deleted Deleted

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertEqual("Unexpected UNION with value 'union'.", cm.exception.msg)

self.assertEqual(cm.exception.lineno, 18)

def test_union_decl(self):

# test union with only symbols

text = textwrap.dedent("""\

namespace files

union Role

"The role a user may have in a shared folder."

owner

"Owner of a file."

viewer

"Read only permission."

editor

"Read and write permission."

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'Role')

self.assertEqual(out[1].doc, 'The role a user may have in a shared folder.')

self.assertIsInstance(out[1].fields[0], AstVoidField)

self.assertEqual(out[1].fields[0].name, 'owner')

self.assertIsInstance(out[1].fields[1], AstVoidField)

self.assertEqual(out[1].fields[1].name, 'viewer')

self.assertIsInstance(out[1].fields[2], AstVoidField)

self.assertEqual(out[1].fields[2].name, 'editor')

# TODO: Test a union that includes a struct.

text = textwrap.dedent("""\

namespace files

union Error

A

"Variant A"

B

"Variant B"

""")

self.parser_factory.get_parser().parse(text)

# test with inheritance

text = textwrap.dedent("""\

namespace test

union U1

t1 UInt64

union U2 extends U1

t2 String

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'U1')

self.assertEqual(out[2].name, 'U2')

self.assertEqual(out[2].extends.name, 'U1')

def test_union_patch_decl(self):

# test union with only symbols

text = textwrap.dedent("""\

namespace files

patch union Role

owner

"Owner of a file."

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'Role')

self.assertIsInstance(out[1].fields[0], AstVoidField)

self.assertEqual(out[1].fields[0].name, 'owner')

# test struct patch with a top-level doc

text = textwrap.dedent("""\

namespace files

patch union Role

"The role a user may have in a shared folder."

owner

"Owner of a file."

""")

out = self.parser_factory.get_parser().parse(text)

msg, lineno, _ = self.parser_factory.get_parser().errors[0]

# Can't parse patch with doc-string.

self.assertEqual(msg, "Unexpected STRING with value 'The " +

"role a user may have in a shared folder.'.")

self.assertEqual(lineno, 3)

text = textwrap.dedent("""\

namespace files

patch union Error

A

"Variant A"

""")

self.parser_factory.get_parser().parse(text)

def test_composition(self):

text = textwrap.dedent("""\

namespace files

union UploadMode

add

overwrite

struct Upload

path String

mode UploadMode = add

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[2].name, 'Upload')

self.assertIsInstance(out[2].fields[1].default, AstTagRef)

self.assertEqual(out[2].fields[1].default.tag, 'add')

def test_route_decl(self):

# Test route definition with no docstring

text = textwrap.dedent("""\

namespace users

route GetAccountInfo(Void, Void, Void)

""")

self.parser_factory.get_parser().parse(text)

text = textwrap.dedent("""\

namespace users

struct AccountInfo

email String

route GetAccountInfo(AccountInfo, Void, Void)

"Gets the account info for a user"

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].name, 'AccountInfo')

self.assertEqual(out[2].name, 'GetAccountInfo')

self.assertEqual(out[2].arg_type_ref.name, 'AccountInfo')

self.assertEqual(out[2].result_type_ref.name, 'Void')

self.assertEqual(out[2].error_type_ref.name, 'Void')

# Test raw documentation

text = textwrap.dedent("""\

namespace users

route GetAccountInfo(Void, Void, Void)

"0

1

2

3

"

""")

out = self.parser_factory.get_parser().parse(text)

self.assertEqual(out[1].doc, '0\n\n1\n\n2\n\n3\n')

# Test deprecation

text = textwrap.dedent("""\

namespace test

route old_route (Void, Void, Void) deprecated

""")

api = specs_to_ir([('test.stone', text)])

r = api.namespaces['test'].route_by_name['old_route']

self.assertIsNotNone(r.deprecated)

self.assertIsNone(r.deprecated.by)

# Test deprecation with target route

text = textwrap.dedent("""\

namespace test

route old_route (Void, Void, Void) deprecated by new_route

route new_route (Void, Void, Void)

""")

api = specs_to_ir([('test.stone', text)])

r_old = api.namespaces['test'].route_by_name['old_route']

r_new = api.namespaces['test'].route_by_name['new_route']

self.assertIsNotNone(r.deprecated)

self.assertEqual(r_old.deprecated.by, r_new)

# Test deprecation with target route (more complex route names)

text = textwrap.dedent("""\

namespace test

route test/old_route (Void, Void, Void) deprecated by test/new_route

route test/new_route (Void, Void, Void)

""")

api = specs_to_ir([('test.stone', text)])

r_old = api.namespaces['test'].route_by_name['test/old_route']

r_new = api.namespaces['test'].route_by_name['test/new_route']

self.assertIsNotNone(r.deprecated)

self.assertEqual(r_old.deprecated.by, r_new)

# Try deprecation by undefined route

text = textwrap.dedent("""\

namespace test

route old_route (Void, Void, Void) deprecated by unk_route

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertEqual("Undefined route 'unk_route'.", cm.exception.msg)

self.assertEqual(cm.exception.lineno, 3)

# Try deprecation by struct

text = textwrap.dedent("""\

namespace test

route old_route (Void, Void, Void) deprecated by S

struct S

f String

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertEqual("'S' must be a route.", cm.exception.msg)

self.assertEqual(cm.exception.lineno, 3)

def test_alphabetizing(self):

text1 = textwrap.dedent("""\

namespace ns_b

struct z

f UInt64

union x

a

b

struct y

f UInt64

route b(Void, Void, Void)

route a(Void, Void, Void)

route c(Void, Void, Void)

""")

text2 = textwrap.dedent("""\

namespace ns_a

route d (Void, Void, Void)

""")

api = specs_to_ir([('test1.stone', text1), ('test2.stone', text2)])

assert ['ns_a', 'ns_b'] == list(api.namespaces.keys())

ns_b = api.namespaces['ns_b']

assert [dt.name for dt in ns_b.data_types] == ['x', 'y', 'z']

assert [dt.name for dt in ns_b.routes] == ['a', 'b', 'c']

def test_lexing_errors(self):

text = textwrap.dedent("""\

namespace users

%

# testing line numbers

%

struct AccountInfo

email String

""")

parser = self.parser_factory.get_parser()

out = parser.parse(text)

msg, lineno = parser.lexer.errors[0]

self.assertEqual(msg, "Illegal character '%'.")

self.assertEqual(lineno, 4)

msg, lineno = parser.lexer.errors[1]

self.assertEqual(msg, "Illegal character '%'.")

self.assertEqual(lineno, 8)

# Check that despite lexing errors, parser marched on successfully.

self.assertEqual(out[1].name, 'AccountInfo')

text = textwrap.dedent("""\

namespace test

struct S

# Indent below is only 3 spaces

f String

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn("Indent is not divisible by 4.", cm.exception.msg)

def test_parsing_errors(self):

text = textwrap.dedent("""\

namespace users

strct AccountInfo

email String

""")

parser = self.parser_factory.get_parser()

parser.parse(text)

msg, lineno, _ = parser.errors[0]

self.assertEqual(msg, "Unexpected ID with value 'strct'.")

self.assertEqual(lineno, 4)

text = textwrap.dedent("""\

namespace users

route test_route(Blah, Blah, Blah)

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn("Symbol 'Blah' is undefined", cm.exception.msg)

def test_name_clash(self):

# namespace / type clash

text = textwrap.dedent("""\

namespace test_namespace_test

struct TestNamespaceTest

str String

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn("Name of user-defined type 'TestNamespaceTest' conflicts "

"with name of namespace 'test_namespace_test'", cm.exception.msg)

# namespace / route clash

text = textwrap.dedent("""\

namespace test_namespace_test

route test_namespace_test(Void, Void, Void)

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn("Name of route 'test_namespace_test' conflicts "

"with name of namespace 'test_namespace_test'", cm.exception.msg)

# namespace / alias clash

text = textwrap.dedent("""\

namespace test_namespace_test

alias TestNamespaceTest = String

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn("Name of alias 'TestNamespaceTest' conflicts "

"with name of namespace 'test_namespace_test'", cm.exception.msg)

# route / type clash

text = textwrap.dedent("""\

namespace test_namespace

struct TestStructTest

str String

route test_struct_test(Void, Void, Void)

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn("Name of route 'test_struct_test' conflicts "

"with name of user-defined type 'TestStructTest'", cm.exception.msg)

# alias / route clash

text = textwrap.dedent("""\

namespace test_namespace

alias TestAliasTest = String

route test_alias_test(Void, Void, Void)

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn("Name of route 'test_alias_test' conflicts "

"with name of alias 'TestAliasTest'", cm.exception.msg)

def test_docstrings(self):

text = textwrap.dedent("""\

namespace test

# No docstrings at all

struct E

f String

struct S

"Only type doc"

f String

struct T

f String

"Only field doc"

union U

"Only type doc"

f String

union V

f String

"Only field doc"

# Check for inherited doc

struct W extends T

g String

""")

api = specs_to_ir([('test.stone', text)])

E_dt = api.namespaces['test'].data_type_by_name['E']

self.assertFalse(E_dt.has_documented_type_or_fields())

self.assertFalse(E_dt.has_documented_fields())

S_dt = api.namespaces['test'].data_type_by_name['S']

self.assertTrue(S_dt.has_documented_type_or_fields())

self.assertFalse(S_dt.has_documented_fields())

T_dt = api.namespaces['test'].data_type_by_name['T']

self.assertTrue(T_dt.has_documented_type_or_fields())

self.assertTrue(T_dt.has_documented_fields())

U_dt = api.namespaces['test'].data_type_by_name['U']

self.assertTrue(U_dt.has_documented_type_or_fields())

self.assertFalse(U_dt.has_documented_fields())

V_dt = api.namespaces['test'].data_type_by_name['V']

self.assertTrue(V_dt.has_documented_type_or_fields())

self.assertTrue(V_dt.has_documented_fields())

W_dt = api.namespaces['test'].data_type_by_name['W']

self.assertFalse(W_dt.has_documented_type_or_fields())

self.assertFalse(W_dt.has_documented_fields())

self.assertFalse(W_dt.has_documented_type_or_fields(), True)

self.assertFalse(W_dt.has_documented_fields(), True)

def test_alias(self):

# Test aliasing to primitive

text = textwrap.dedent("""\

namespace test

alias R = String

"This is a test

of docstrings"

""")

api = specs_to_ir([('test.stone', text)])

test_ns = api.namespaces['test']

self.assertIsInstance(test_ns.aliases[0], Alias)

self.assertEqual(test_ns.aliases[0].name, 'R')

self.assertIsInstance(test_ns.aliases[0].data_type, String)

self.assertEqual(

test_ns.aliases[0].doc, 'This is a test of docstrings')

# Test aliasing to primitive with additional attributes and nullable

text = textwrap.dedent("""\

namespace test

alias R = String(min_length=1)?

""")

api = specs_to_ir([('test.stone', text)])

test_ns = api.namespaces['test']

self.assertIsInstance(test_ns.aliases[0], Alias)

self.assertEqual(test_ns.aliases[0].name, 'R')

self.assertIsInstance(test_ns.aliases[0].data_type, Nullable)

self.assertIsInstance(test_ns.aliases[0].data_type.data_type, String)

# Test aliasing to alias

text = textwrap.dedent("""\

namespace test

alias T = String

alias R = T

""")

api = specs_to_ir([('test.stone', text)])

test_ns = api.namespaces['test']

self.assertIsInstance(test_ns.alias_by_name['T'], Alias)

self.assertIsInstance(test_ns.alias_by_name['R'], Alias)

self.assertIsInstance(test_ns.alias_by_name['R'].data_type, Alias)

self.assertEqual(test_ns.alias_by_name['R'].data_type.name, 'T')

# Test order invariance

text = textwrap.dedent("""\

namespace test

alias R = T

alias T = String

""")

api = specs_to_ir([('test.stone', text)])

# Try re-definition

text = textwrap.dedent("""\

namespace test

alias A = String

alias A = UInt64

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn("Symbol 'A' already defined (test.stone:3).",

cm.exception.msg)

# Try cyclical reference

text = textwrap.dedent("""\

namespace test

alias A = B

alias B = C

alias C = A

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn("Alias 'C' is part of a cycle.",

cm.exception.msg)

# Try aliasing to alias with attributes already set.

text = textwrap.dedent("""\

namespace test

alias T = String(min_length=1)

alias R = T(min_length=1)

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn('Attributes cannot be specified for instantiated type',

cm.exception.msg)

# Test aliasing to composite and making it nullable

text = textwrap.dedent("""\

namespace test

struct S

f String

alias R = S?

""")

api = specs_to_ir([('test.stone', text)])

test_ns = api.namespaces['test']

S_dt = test_ns.data_type_by_name['S']

self.assertIsInstance(test_ns.alias_by_name['R'].data_type, Nullable)

self.assertEqual(test_ns.alias_by_name['R'].data_type.data_type, S_dt)

# Test aliasing to composite with attributes

text = textwrap.dedent("""\

namespace test

struct S

f String

alias R = S(min_length=1)

""")

with self.assertRaises(InvalidSpec) as cm:

specs_to_ir([('test.stone', text)])

self.assertIn('Attributes cannot be specified for instantiated type',

cm.exception.msg)

# Test aliasing from another namespace

text1 = textwrap.dedent("""\

namespace test1

struct S

f String

""")

text2 = textwrap.dedent("""\

namespace test2

import test1

alias S = test1.S

""")

api = specs_to_ir([('test1.stone', text1), ('test2.stone', text2)])

test1_ns = api.namespaces['test1']

S_dt = test1_ns.data_type_by_name['S']

test2_ns = api.namespaces['test2']

self.assertEqual(test2_ns.alias_by_name['S'].data_type, S_dt)

# Try extending an alias-ed struct

text1 = textwrap.dedent("""\

namespace test1

alias Z = S

struct S

f1 String