class ErrorUseClause(FooNode):
@langkit_property()
def resolve():
return PropertyError(T.LexicalEnv, "unconditionally raised")
env_spec = EnvSpec(
handle_children(),
reference(Self.cast(T.FooNode).singleton, T.ErrorUseClause.resolve))
class RefClause(FooNode):
ref_id = Field(type=T.Id)
env_spec = EnvSpec(
reference(
nodes=[Self.ref_id.cast(T.FooNode)],
through=T.FooNode.children_env,
dest_env=(Self.ref_id.resolve(
Self.parent.children_env).children_env),
))
class UseClause(FooNode):
name = Field(type=T.Id)
@langkit_property()
def resolve():
return Self.name.resolve().map(lambda n: n.children_env).env_group()
env_spec = EnvSpec(
handle_children(),
reference(Self.cast(T.FooNode).singleton, T.UseClause.resolve))
class Example(FooNode):
token_node = True
@langkit_property()
def resolve():
return PropertyError(T.LexicalEnv)
env_spec = EnvSpec(
add_env(),
reference([Self.cast(FooNode), Self.cast(FooNode)], T.Example.resolve),
)
class Open(Item):
name = Field(type=T.Identifier)
env_spec = EnvSpec(
reference(nodes=[Self.cast(T.FooNode)], through=T.Open.resolve),
)
@langkit_property(return_type=T.LexicalEnv)
def resolve():
n = Var(Self.name.resolve())
return n.then(lambda n: n.children_env, No(T.LexicalEnv))
class Example(FooNode):
token_node = True
env_spec = EnvSpec(
add_env(),
reference([Self.parent.cast(Def).cat1.cast(T.FooNode)],
T.FooNode.children_env,
category='cat1'),
reference([Self.parent.cast(Def).cat2.cast(T.FooNode)],
T.FooNode.children_env,
category='cat2'))
@langkit_property(public=True)
def lookup_all(name=T.Symbol):
return Self.children_env.get(name)
@langkit_property(public=True)
def lookup_1(name=T.Symbol):
return Self.children_env.get(name, categories=RefCategories(cat1=True))
@langkit_property(public=True)
def lookup_2(name=T.Symbol):
return Self.children_env.get(name, categories=RefCategories(cat2=True))
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 UseClause(Decl):
name = Field()
env_spec = EnvSpec(
reference(Self.name.cast(FooNode)._.singleton,
through=Name.designated_env,
kind=RefKind.transitive))
class PackageBody(FooNode):
name = Field(type=T.Name)
decls = Field(type=T.DeclarativePart)
@langkit_property(return_type=T.Name)
def self_name():
return Self.name
@langkit_property(return_type=T.LexicalEnv)
def body_decl_scope():
"""
Assuming this PackageBody is not in the top-level list, return the
environment of its PackageDecl that it should reference.
"""
pkg_decl = Var(Self.lookup_decl_part)
return If(
pkg_decl.private_part.is_null,
pkg_decl.children_env,
pkg_decl.private_part.children_env
)
@langkit_property(return_type=T.PackageDecl)
def lookup_decl_part():
"""
Assuming this PackageBody is not in the top-level list, return the
the corresponding package declaration.
"""
return (
Self.parent.children_env.get_first(Self.name.base_name.to_symbol)
.cast(T.PackageDecl).node
)
env_spec = EnvSpec(
# The initial environment for package bodies is the private part of the
# corresponding package specs (or the public part if there is no
# private part).
set_initial_env_by_name(
If(
Self.is_toplevel,
Self.suffixed_full_name(String('__privatepart')).to_symbol,
No(T.Symbol),
),
Self.parent.children_env,
),
add_to_env_by_name(
'__nextpart',
Self,
If(Self.can_have_name,
Self.suffixed_full_name(String('__privatepart')).to_symbol,
No(T.Symbol)),
Self.body_decl_scope,
),
add_env(names=[Self.suffixed_full_name(String('__body')).to_symbol]),
reference(
Self.cast(FooNode).singleton,
through=T.PackageBody.body_decl_scope,
cond=Not(Self.is_toplevel),
kind=RefKind.prioritary,
),
)
@langkit_property(return_type=T.PackageDecl.entity, public=True)
def decl_part():
"""
Return the PackageDecl node corresponding to this PackageBody.
"""
env = Var(Self.parent.children_env)
return Self.name.resolve(env).cast(T.PackageDecl)
class Using(FooNode):
name = Field()
env_spec = EnvSpec(
reference(Self.name.cast(FooNode)._.singleton,
through=Name.designated_env)
)
