def test_struct_iterator():
val = Var(TestStruct.new(
count=2,
nodes=[No(Example.entity), Entity],
))
itr = Var(
ArrayLiteral([val, val], element_type=TestStruct).to_iterator)
return ArrayLiteral([itr, itr],
element_type=T.TestStruct.iterator).to_iterator
def test_envs():
null = Var(No(T.LexicalEnv))
primary = Var(Self.children_env)
orphan = Var(primary.env_orphan)
group = Var(ArrayLiteral([primary, null]).env_group())
rebound = Var(primary.rebind_env(Self.get_rebindings(False)))
arr = Var(ArrayLiteral([
null,
primary,
orphan,
group,
rebound,
]))
return arr.length # BREAK:test_envs
def test_arrays():
empty = Var(No(T.Example.array))
single = Var(ArrayLiteral([Self.cast(Example)]))
complete = Var(Self.parent.cast(T.Example.list).as_array)
arr = Var(empty.concat(single).concat(complete))
return arr.length # BREAK:test_arrays
def get_struct():
return New(MyStruct,
entity_field=Self,
array_field=ArrayLiteral([
Self.cast(T.FooNode).as_bare_entity,
Self.parent.as_bare_entity]),
bigint_field=BigIntLiteral(10**100))
def test_dotexpr_lhs():
"""
Test various valid dotexpr's LHS.
"""
a = Var(ArrayLiteral([1]).find(lambda v: v == 1))
b = Var(Let(lambda b=[1, 2]: b).find(lambda v: v == 1))
c = Var(String("hello").find(lambda c: c == Char('h')))
ignore(b)
ignore(c)
return a
class Example(BaseExample):
fld_2 = NullField()
fld_1 = Field()
@langkit_property()
def to_public(p=T.PrivatePoint):
return Point.new(label=String("from private"), x=p.x, y=p.y)
@langkit_property(public=True)
def prop(p=T.Point):
return Self.to_public(PrivatePoint.new(x=p.x, y=p.y))
@langkit_property(public=True)
def result():
return T.NodeResult.new(n=Self, e=Entity)
# Test for primitive types
id_bool = Property(lambda id=T.Bool: id, public=True)
id_int = Property(lambda id=T.Int: id, public=True)
id_bigint = Property(lambda id=T.BigInt: id, public=True)
id_char = Property(lambda id=T.Character: id, public=True)
id_token = Property(lambda id=T.Token: id, public=True)
id_sym = Property(lambda id=T.Symbol: id, public=True)
id_unit = Property(lambda id=T.AnalysisUnit: id, public=True)
id_root_node = Property(lambda id=T.FooNode: id, public=True)
id_name = Property(lambda id=T.Name: id, public=True)
# Test for enums
id_unit_kind = Property(lambda id=T.AnalysisUnitKind: id, public=True)
# Test for arrays
id_node_array = Property(lambda id=T.FooNode.entity.array: id, public=True)
id_expr_array = Property(lambda id=T.Expr.entity.array: id, public=True)
id_bigint_array = Property(lambda id=T.BigInt.array: id, public=True)
id_unit_array = Property(lambda id=T.AnalysisUnit.array: id, public=True)
# Test for iterators
create_bigint_iterator = Property(
ArrayLiteral([BigIntLiteral(1), BigIntLiteral(2), BigIntLiteral(3)])
.to_iterator,
public=True
)
id_bigint_iterator = Property(lambda id=T.BigInt.iterator: id, public=True)
# Test for default values
id_dflt_bool = Property(lambda id=(T.Bool, True): id, public=True)
id_dflt_int = Property(lambda id=(T.Int, 42): id, public=True)
id_dflt_char = Property(
lambda id=(T.Character, CharacterLiteral('\x00')): id,
public=True)
id_dflt_root_node = Property(lambda id=(T.FooNode, No(T.FooNode)): id,
public=True)
def test_rebindings():
null = Var(No(T.EnvRebindings))
r1 = Var(Self.get_rebindings(False))
r2 = Var(Self.get_rebindings(True))
concat = Var(r1.concat_rebindings(r2))
arr = Var(ArrayLiteral([
null,
r1,
r2,
concat,
]))
return arr.length # BREAK:test_rebindings
def construct(self):
from langkit.expressions import If, IsNull, ArrayLiteral
expr = construct(self.expr)
expr_var = expr.create_result_var('To_Array_Prefix')
# Use "expr" only for first evaluation, and then use expr_var to refer
# to the result. We do this to avoid resolved expression sharing in the
# expression tree.
ret = CollectionSingleton.Expr(expr_var if self.coerce_null else expr)
if self.coerce_null:
return If.Expr(IsNull.construct_static(expr),
ArrayLiteral.construct_static([], expr.type.array),
ret, ret.type)
else:
return ret
def test_strings():
empty = Var(String(""))
foo = Var(String("foo"))
s_quote = Var(String("'"))
d_quote = Var(String('"'))
quote_mix = Var(String("\"'"))
lf = Var(String("\n"))
nul = Var(String("\x00"))
arr = Var(
ArrayLiteral([
empty,
foo,
s_quote,
d_quote,
quote_mix,
lf,
nul,
]))
return arr.length # BREAK:test_strings
def test_entities():
null_root = Var(No(T.FooNode.entity))
null_example = Var(No(T.Example.entity))
ent_root = Var(Entity) # BREAK:test_state
ent_example = Var(ent_root.cast(T.Example))
rebound = Var(
T.FooNode.entity.new(
node=Self,
info=T.EntityInfo.new(
md=No(T.Metadata),
rebindings=Self.get_rebindings(False),
from_rebound=False,
),
))
arr = Var(
ArrayLiteral([
null_root,
null_example.cast(T.FooNode),
ent_root,
ent_example.cast(T.FooNode),
rebound,
]))
return arr.length # BREAK:test_entities
def values_array():
return ArrayLiteral([1, 2, 3], element_type=T.Int)
def double(c=T.Character):
return ArrayLiteral([c, c], T.Character)
def iter_int():
return ArrayLiteral([1, 2, 3]).to_iterator
def get_array():
return ArrayLiteral([1, 2])
def test_tokens():
null = Var(No(T.Token))
first = Var(Self.token_start)
arr = Var(ArrayLiteral([null, first]))
return arr.length # BREAK:test_tokens
def entities_iterator():
return ArrayLiteral([Entity, Entity, Entity],
element_type=Example.entity).to_iterator
from langkit.parsers import Grammar
from utils import emit_and_print_errors
def run(name, expr):
"""
Emit and print the errors we get for the below grammar with "expr" as
a property in Example.
"""
print('== {} =='.format(name))
class FooNode(ASTNode):
pass
class Example(FooNode):
p = Property(expr)
grammar = Grammar('main_rule')
grammar.add_rules(main_rule=Example('example'), )
emit_and_print_errors(grammar)
print('')
run('Empty: missing type', [])
run('Empty: ok', ArrayLiteral([], T.Bool))
run('Single: ok', [True])
run('Multiple: heterogeneous types', [True, Self])
print('Done')
def entities_array():
return ArrayLiteral([Entity, Entity, Entity],
element_type=Example.entity)
