def get_entity(md=Metadata):
return New(Couple.entity,
node=Self,
info=New(T.entity_info,
md=md,
rebindings=No(EnvRebindings),
from_rebound=False))
def parent_rebindings():
e_info = Var(
New(T.entity_info,
md=Entity.info.md,
rebindings=Entity.info.rebindings.get_parent,
from_rebound=False))
return New(Block.entity, node=Self, info=e_info)
def rebind(from_block=T.Block.entity, to_block=T.Block.entity):
rbdng = Var(
Entity.info.rebindings.append_rebinding(
from_block.params.children_env, to_block.children_env))
e_info = Var(New(T.entity_info, md=Entity.info.md, rebindings=rbdng))
return New(Block.entity, el=Self, info=e_info)
class Def(FooNode):
name = Field(type=T.Name)
ref = Field(type=T.Name)
env_spec = EnvSpec(
add_to_env(mappings=New(T.env_assoc, key=Self.name.sym, val=Self),
metadata=New(Metadata,
node=Self.ref.then(lambda r: r.resolve.node,
default_val=No(
T.FooNode)))))
def rebind(from_node=T.FooNode.entity, to_node=T.FooNode.entity):
rbdng = Var(Entity.info.rebindings.append_rebinding(
from_node.children_env,
to_node.children_env
))
e_info = Var(New(T.entity_info,
md=Entity.info.md,
rebindings=rbdng,
from_rebound=False))
return New(T.FooNode.entity, node=Self, info=e_info)
class Decl(FooNode):
has_plus = Field()
name = Field()
items = Field()
env_spec = EnvSpec(
add_to_env(mappings=New(T.env_assoc, key=Self.name.symbol, val=Self),
metadata=New(Metadata, b=Self.has_plus.as_bool)))
@langkit_property(public=True, return_type=T.Ref.entity.array)
def entity_items():
return Self.as_entity.items.map(lambda i: i)
class SelfDecl(FooNode):
id = Field(type=T.Id)
md_node = Field(type=T.Id)
env_spec = EnvSpec(
add_to_env(
New(T.env_assoc,
key=Self.id.simple_name.symbol,
val=Self.id.resolve(Self.node_env)),
metadata=New(
T.Metadata,
node=Self.md_node.then(lambda n: n.resolve(Self.node_env)))))
class Decl(FooNode):
name = Field()
refs = Field()
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.name.symbol, val=Self)),
add_env())
class Var(DefNode):
name = Field()
value = Field()
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.name.symbol, val=Self)),
)
class Var(FooNode):
name = Field()
expr = Field()
env_spec = EnvSpec(
add_to_env(mappings=New(T.env_assoc, key=Self.name.symbol, val=Self)),
)
class ListDecl(FooNode):
label = Field(type=T.Name)
name_list = Field(type=T.Name.list_type())
to_struct = Property(
New(Names, label=Self.label,
name_list=Self.name_list.map(lambda n: n)))
class Scope(FooNode):
name = Field(type=T.SimpleId)
content = Field()
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.name.symbol, val=Self)),
add_env())
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))
class Block(DefNode):
params = Field(type=T.Params)
name_field = Field(type=T.Name)
vars = Field(type=T.BlockVar.list)
name = Property(Self.name_field.symbol)
@langkit_property(public=True)
def rebind(from_block=T.Block.entity, to_block=T.Block.entity):
rbdng = Var(Entity.info.rebindings.append_rebinding(
from_block.params.children_env,
to_block.children_env
))
e_info = Var(New(T.entity_info,
md=Entity.info.md,
rebindings=rbdng,
from_rebound=False))
return New(Block.entity, node=Self, info=e_info)
env_spec = EnvSpec(
add_to_env(mappings=New(T.env_assoc, key=Self.name, val=Self)),
add_env()
)
def construct_operand(op):
from langkit.expressions import Cast, New
expr = construct(op)
check_source_language(
expr.type == LogicVarType
or expr.type.matches(T.root_node)
or expr.type.matches(T.root_node.env_el()),
"Operands to a logic bind operator should be either "
"a logic variable or an ASTNode, got {}".format(expr.type)
)
if expr.type.matches(T.root_node.env_el()):
if expr.type is not T.root_node.env_el():
expr = Cast.Expr(expr, T.root_node.env_el())
elif expr.type.matches(T.root_node):
# Cast the ast node type if necessary
if expr.type is not T.root_node:
expr = Cast.Expr(expr, T.root_node)
# If the expression is a root node, implicitly construct an
# env_element from it.
expr = New.StructExpr(T.root_node.env_el(), {
Name('El'): expr,
Name('MD'): LiteralExpr('<>', None),
Name('Parents_Bindings'): LiteralExpr('null', None)
})
return expr
class Scope(DefNode):
name = Field()
defs = Field()
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.name.symbol, val=Self)),
add_env(),
)
class Block(FooNode):
name = Field()
decls = Field()
usings = Field()
refs = Field()
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.name.sym, val=Self)), add_env())
class ForeignDecl(FooNode):
id = Field(type=T.Id)
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.id.simple_name.symbol, val=Self),
dest_env=Self.id.match(
lambda simple=T.SimpleId: simple.node_env,
lambda scoped=T.ScopedId: scoped.resolve(Self.node_env).
children_env,
)))
class VarDecl(FooNode):
name = Field()
value = Field()
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.name.symbol, val=Self)))
@langkit_property(public=True)
def eval():
return Self.value.eval
class Scope(Def):
error = Field()
name = Field()
defs = Field()
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.name.symbol, val=Self)),
add_env(),
do(If(Self.error.as_bool, PropertyError(T.FooNode), No(T.FooNode))),
)
class Ref(FooNode):
name = Field()
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.name.symbol, val=Self),
resolver=FooNode.resolve_ref))
@langkit_property(public=True)
def resolve():
return Self.node_env.get(Self.name.symbol).at(0)
def make_as_entity(node_expr,
entity_info=None,
null_check=True,
abstract_expr=None):
"""
Helper for as_entity. Takes a resolved expression instead of an abstract
one.
:param ResolvedExpression node_expr: The AST node expression to wrap as an
entity.
:param ResolvedExpression|None entity_info: Expression to use as the entity
information. If provided, its type must be T.entity_info. Otherwise,
the ambient entity info is used.
"""
from langkit.expressions import If, IsNull, New
entity_type = node_expr.type.entity
# If we use the ambient entity info, make the current property an entity
# one.
if entity_info is None:
p = PropertyDef.get()
p.set_uses_entity_info()
entity_info = construct(p.entity_info_arg)
# Expression tree sharing is forbidden, so if we need to reference the
# result of the input node expression multiple times, create a variable to
# hold the input node.
node_ref = (node_expr.create_result_var('Node_For_Entity')
if null_check else node_expr)
entity_expr = New.StructExpr(
entity_type,
{
names.Name('El'): node_ref,
names.Name('Info'): entity_info
},
result_var_name=names.Name.from_lower('as_entity'),
)
result = If.Expr(
IsNull.construct_static(node_expr),
NullExpr(entity_type),
entity_expr,
entity_type,
abstract_expr=abstract_expr) if null_check else entity_expr
result.abstract_expr = abstract_expr
return result
class Decl(FooNode):
has_plus = Field()
name = Field()
items = Field()
env_spec = EnvSpec(
add_to_env_kv(key=Self.name.symbol,
value=Self,
metadata=New(Metadata, b=Self.has_plus.as_bool)))
@langkit_property(public=True,
return_type=T.Ref.entity.array,
activate_tracing=True)
def entity_items():
return Self.as_entity.items.map(lambda i: i)
class Def(FooNode):
name = Field()
imports = Field()
vars = Field()
expr = Field()
env_spec = EnvSpec(
add_to_env(mappings=New(T.env_assoc, key=Self.name.symbol, val=Self)),
add_env(),
reference(Self.imports.map(lambda i: i.cast(T.FooNode)),
# If PropertyDef rewriting omits the following references,
# env lookup will never reach DerivedRef.referenced_env, so
# resolution will sometimes fail to reach definition.
T.MiddleRef.referenced_env)
)
class Scope(FooNode):
name = Field()
deps = Field()
defs = Field()
@langkit_property()
def initial_env():
return Self.name.match(
lambda p=T.Prefix: p.prefix.referenced_unit.root.children_env,
lambda _: Self.children_env,
)
env_spec = EnvSpec(
set_initial_env(Self.initial_env),
add_to_env(New(T.env_assoc, key=Self.name.suffix_symbol, val=Self)),
add_env(),
)
class Decl(FooNode):
has_plus = Field()
name = Field()
items = Field()
env_spec = EnvSpec(
add_to_env(mappings=New(T.env_assoc, key=Self.name.symbol, val=Self)),
add_env(),
)
@langkit_property(public=True, return_type=T.BoolType)
def test_env(other=T.FooNode.entity):
return Self.children_env.env_orphan == other.children_env.env_orphan
@langkit_property(public=True, return_type=T.BoolType)
def test_struct(other=T.FooNode.entity):
return Self.env_struct == other.env_struct
@langkit_property(public=True, return_type=T.BoolType)
def test_array(other=T.FooNode.entity):
return Self.env_array == other.env_array
class Scope(FooNode):
name = Field()
deps = Field()
defs = Field()
annotations = Annotations(ple_unit_root=True)
@langkit_property()
def initial_env():
return Self.name.match(
lambda p=T.Prefix: p.prefix.referenced_unit.root.cast_or_raise(
T.Scope.list).filter(lambda scope: scope.name.symbols == p.
prefix.symbols).at_or_raise(0).
children_env,
lambda _: Self.children_env,
)
env_spec = EnvSpec(
set_initial_env(Self.initial_env),
add_to_env(New(T.env_assoc, key=Self.name.suffix_symbol, val=Self)),
add_env(),
)
class Block(Def):
params = Field(type=T.Params)
tok = Field(type=T.TokenType)
vars = Field(type=T.BlockVar.list)
name = Property(Self.tok.symbol)
@langkit_property(public=True)
def rebind(from_block=T.Block.entity, to_block=T.Block.entity):
rbdng = Var(
Entity.info.rebindings.append_rebinding(
from_block.params.children_env, to_block.children_env))
e_info = Var(New(T.entity_info, md=Entity.info.md, rebindings=rbdng))
return New(Block.entity, el=Self, info=e_info)
@langkit_property(public=True)
def parent_rebindings():
e_info = Var(
New(T.entity_info,
md=Entity.info.md,
rebindings=Entity.info.rebindings.rebindings_parent))
return New(Block.entity, el=Self, info=e_info)
@langkit_property(public=True)
def new():
return (
Entity.info.rebindings.rebindings_new_env.env_node.as_bare_entity)
@langkit_property(public=True)
def old():
return (
Entity.info.rebindings.rebindings_new_env.env_node.as_bare_entity)
env_spec = EnvSpec(
add_to_env(mappings=New(T.env_assoc, key=Self.name, val=Self)),
add_env())
def env_struct():
return New(EnvStruct, env=Self.children_env.env_orphan)
def get():
return New(SynthNode)
