def construct(self):
"""
Construct a resolved expression for this.
:rtype: IfExpr
"""
from langkit.expressions import Cast
then = construct(self._then)
else_then = construct(self.else_then)
rtype = then.type.unify(
else_then.type,
'Mismatching types in If expression: {self} and {other}')
# If then/else_then have actually subtypes of the unified result type,
# we need to perform a conversion for the Ada code generation.
if then.type != rtype:
then = Cast.Expr(then, rtype)
if else_then.type != rtype:
else_then = Cast.Expr(else_then, rtype)
return If.Expr(construct(self.cond, T.BoolType),
then,
else_then,
rtype,
abstract_expr=self)
def construct(self):
"""
Construct a resolved expression for this.
:rtype: EqExpr
"""
from langkit.expressions.structs import Cast
lhs = construct(self.lhs)
rhs = construct(self.rhs)
# Don't use CompiledType.matches since in the generated code, we need
# both operands to be *exactly* the same types, so handle specifically
# each case.
if issubclass(lhs.type, ASTNode):
# Handle checks between two subclasses without explicit casts. In
# order to help users to detect dubious checks, forbid operands
# that can never be equal because they have no subclass in common.
if issubclass(lhs.type, rhs.type):
lhs = Cast.Expr(lhs, assert_type(rhs.type, ASTNode))
elif issubclass(rhs.type, lhs.type):
rhs = Cast.Expr(rhs, assert_type(lhs.type, ASTNode))
else:
check_source_language(
False, '{} and {} values are never equal'.format(
lhs.type.name().camel,
rhs.type.name().camel))
else:
check_source_language(
lhs.type == rhs.type,
'Incompatible types for equality: {} and {}'.format(
lhs.type.name().camel,
rhs.type.name().camel))
return self.make_expr(lhs, rhs)
def make_expr_for_entities(lhs, rhs, abstract_expr=None):
from langkit.expressions.structs import Cast
if lhs.type != T.entity:
lhs = Cast.Expr(lhs, T.entity)
if rhs.type != T.entity:
rhs = Cast.Expr(rhs, T.entity)
return CallExpr('Is_Equiv', 'Equivalent', T.Bool, [lhs, rhs],
abstract_expr=abstract_expr)
def construct(self):
"""
Construct a resolved expression for this.
:rtype: EqExpr
"""
from langkit.expressions.structs import Cast
lhs = construct(self.lhs)
rhs = construct(self.rhs)
def check_type_compatibility(is_valid):
check_source_language(
is_valid,
'Incompatible types for equality: {} and {}'.format(
lhs.type.dsl_name, rhs.type.dsl_name
)
)
def check_never_equal(can_be_equal):
check_source_language(
can_be_equal,
'{} and {} values are never equal'.format(
lhs.type.dsl_name, rhs.type.dsl_name
)
)
# Don't use CompiledType.matches since in the generated code, we need
# both operands to be *exactly* the same types, so handle specifically
# each case.
if lhs.type.is_ast_node:
check_type_compatibility(rhs.type.is_ast_node)
# Handle checks between two subclasses without explicit casts. In
# order to help users to detect dubious checks, forbid operands
# that can never be equal because they have no subclass in common.
if lhs.type.matches(rhs.type):
lhs = Cast.Expr(lhs, rhs.type)
elif rhs.type.matches(lhs.type):
rhs = Cast.Expr(rhs, lhs.type)
else:
check_never_equal(False)
# Likewise for entities. Moreover, we need to use a special comparison
# predicate for them.
elif lhs.type.is_entity_type:
check_type_compatibility(rhs.type.is_entity_type)
check_never_equal(
lhs.type.element_type.matches(rhs.type.element_type)
or rhs.type.element_type.matches(lhs.type.element_type)
)
return self.make_expr_for_entities(lhs, rhs, self)
else:
check_type_compatibility(lhs.type == rhs.type)
return self.make_expr(lhs, rhs, self)
def cast_if_needed(expr):
return expr if expr.type == rtype else Cast.Expr(expr, rtype)