def get_value(self, logic_var):
"""
Extract the value out of a logic variable. The returned type is always the
root entity type. If the variable is not defined, return a null entity.
:param AbstractExpression logic_var: The logic var from which we want to
extract the value.
"""
from langkit.expressions import If
PropertyDef.get()._gets_logic_var_value = True
rtype = T.root_node.entity
logic_var_expr = construct(logic_var, T.LogicVarType)
logic_var_ref = logic_var_expr.create_result_var('Logic_Var_Value')
return If.Expr(cond=CallExpr('Is_Logic_Var_Defined',
'Eq_Node.Refs.Is_Defined', T.BoolType,
[logic_var_expr]),
then=CallExpr('Eq_Solution', 'Eq_Node.Refs.Get_Value',
rtype, [logic_var_ref]),
else_then=NullExpr(T.root_node.entity),
rtype=rtype,
abstract_expr=self)
def construct(self):
from langkit.expressions import If, IsNull, EmptyArray
expr = construct(self.expr)
ret = CollectionSingleton.Expr(expr)
if self.coerce_null:
return If.Expr(IsNull.construct_static(expr),
EmptyArray.construct_static(expr.type.array_type()),
ret, ret.type)
else:
return ret
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
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