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)