def compile_SessionStateDecl(
decl: qlast.SessionStateDecl, *,
ctx: context.ContextLevel) -> irast.SessionStateCmd:
aliases = {}
for item in decl.items:
if isinstance(item, qlast.ModuleAliasDecl):
try:
module = ctx.schema.get_module(item.module)
except LookupError:
raise errors.EdgeQLError(
f'module {item.module!r} does not exist',
context=item.context
)
aliases[item.alias] = module
else:
raise errors.EdgeQLError(
f'expression aliases in SET are not supported yet',
context=item.context
)
return irast.SessionStateCmd(
modaliases=aliases
)
def __infer_index(ir, schema):
node_type = infer_type(ir.expr, schema)
index_type = infer_type(ir.index, schema)
str_t = schema.get('std::str')
int_t = schema.get('std::int64')
result = None
if node_type.issubclass(str_t):
if not index_type.issubclass(int_t):
raise ql_errors.EdgeQLError(
f'cannot index string by {index_type.name}, '
f'{int_t.name} was expected',
context=ir.index.context)
result = str_t
elif isinstance(node_type, s_types.Array):
if not index_type.issubclass(int_t):
raise ql_errors.EdgeQLError(
f'cannot index array by {index_type.name}, '
f'{int_t.name} was expected',
context=ir.index.context)
result = node_type.element_type
return result
def _cast_expr(ql_type: qlast.TypeName, ir_expr: irast.Base, *,
source_context: parsing.ParserContext,
ctx: context.ContextLevel) -> irast.Base:
try:
orig_type = irutils.infer_type(ir_expr, ctx.schema)
except errors.EdgeQLError:
# It is possible that the source expression is unresolved
# if the expr is an empty set (or a coalesce of empty sets).
orig_type = None
if isinstance(orig_type, s_types.Tuple):
# For tuple-to-tuple casts we generate a new tuple
# to simplify things on sqlgen side.
new_type = typegen.ql_typeref_to_type(ql_type, ctx=ctx)
if not isinstance(new_type, s_types.Tuple):
raise errors.EdgeQLError(f'cannot cast tuple to {new_type.name}',
context=source_context)
if len(orig_type.element_types) != len(new_type.element_types):
raise errors.EdgeQLError(
f'cannot cast to {new_type.name}: '
f'number of elements is not the same',
context=source_context)
new_names = list(new_type.element_types)
elements = []
for i, n in enumerate(orig_type.element_types):
val = setgen.generated_set(irast.TupleIndirection(expr=ir_expr,
name=n),
ctx=ctx)
val.path_id = irutils.tuple_indirection_path_id(
ir_expr.path_id, n, orig_type.element_types[n])
val_type = irutils.infer_type(val, ctx.schema)
new_el_name = new_names[i]
if val_type != new_type.element_types[new_el_name]:
# Element cast
val = _cast_expr(ql_type.subtypes[i],
val,
ctx=ctx,
source_context=source_context)
elements.append(irast.TupleElement(name=new_el_name, val=val))
return irast.Tuple(named=new_type.named, elements=elements)
elif isinstance(ir_expr, irast.EmptySet):
# For the common case of casting an empty set, we simply
# generate a new EmptySet node of the requested type.
scls = typegen.ql_typeref_to_type(ql_type, ctx=ctx)
return irutils.new_empty_set(ctx.schema,
scls=scls,
alias=ir_expr.path_id.target.name.name)
else:
typ = typegen.ql_typeref_to_ir_typeref(ql_type, ctx=ctx)
return setgen.ensure_set(irast.TypeCast(expr=ir_expr, type=typ),
ctx=ctx)
def _cmd_tree_from_ast(cls, astnode, context, schema):
cmd = super()._cmd_tree_from_ast(astnode, context, schema)
if isinstance(astnode, qlast.CreateConcreteConstraint):
if astnode.args:
args = []
for arg in astnode.args:
arg_expr = s_expr.ExpressionText(
edgeql.generate_source(arg.arg, pretty=False))
args.append(arg_expr)
cmd.add(sd.AlterObjectProperty(property='args',
new_value=args))
elif isinstance(astnode, qlast.CreateConstraint):
if astnode.args:
paramnames, paramdefaults, paramtypes, paramkinds, variadic = \
s_func.parameters_from_ast(
astnode, context.modaliases, schema)
if variadic is not None:
cmd.add(
sd.AlterObjectProperty(property='varparam',
new_value=variadic))
for pname, pdefault, ptype in zip(paramnames, paramdefaults,
paramtypes):
if pname is not None:
raise ql_errors.EdgeQLError(
'constraints do not support named parameters',
context=astnode.context)
if pdefault is not None:
raise ql_errors.EdgeQLError(
'constraints do not support parameters '
'with defaults',
context=astnode.context)
if ptype is None:
raise ql_errors.EdgeQLError('untyped parameter',
context=astnode.context)
cmd.add(
sd.AlterObjectProperty(property='paramtypes',
new_value=paramtypes))
# 'subject' can be present in either astnode type
if astnode.subject:
subjectexpr = s_expr.ExpressionText(
edgeql.generate_source(astnode.subject, pretty=False))
cmd.add(
sd.AlterObjectProperty(property='subjectexpr',
new_value=subjectexpr))
cls._validate_subcommands(astnode)
return cmd
def __infer_array(ir, schema):
if ir.elements:
element_type = _infer_common_type(ir.elements, schema)
if element_type is None:
raise ql_errors.EdgeQLError('could not determine array type',
context=ir.context)
else:
raise ql_errors.EdgeQLError('could not determine type of empty array',
context=ir.context)
return s_types.Array(element_type=element_type)
def compile_UpdateQuery(
expr: qlast.Base, *, ctx: context.ContextLevel) -> irast.Base:
with ctx.subquery() as ictx:
stmt = irast.UpdateStmt()
init_stmt(stmt, expr, ctx=ictx, parent_ctx=ctx)
subject = dispatch.compile(expr.subject, ctx=ictx)
subj_type = irutils.infer_type(subject, ictx.schema)
if not isinstance(subj_type, s_objtypes.ObjectType):
raise errors.EdgeQLError(
f'cannot update non-ObjectType objects',
context=expr.subject.context
)
stmt.subject = compile_query_subject(
subject,
shape=expr.shape,
view_rptr=ctx.view_rptr,
compile_views=True,
result_alias=expr.subject_alias,
is_update=True,
ctx=ictx)
stmt.result = setgen.class_set(
stmt.subject.scls.material_type(),
path_id=stmt.subject.path_id, ctx=ctx)
stmt.where = clauses.compile_where_clause(
expr.where, ctx=ictx)
result = fini_stmt(stmt, expr, ctx=ictx, parent_ctx=ctx)
return result
def enforce_singleton(expr: irast.Base, *, ctx: context.ContextLevel) -> None:
cardinality = infer_cardinality(expr, ctx=ctx)
if cardinality != irast.Cardinality.ONE:
raise errors.EdgeQLError(
'possibly more than one element returned by an expression '
'where only singletons are allowed',
context=expr.context)
def compile_IfElse(expr: qlast.IfElse, *,
ctx: context.ContextLevel) -> irast.Base:
condition = setgen.ensure_set(dispatch.compile(expr.condition, ctx=ctx),
ctx=ctx)
ql_if_expr = expr.if_expr
ql_else_expr = expr.else_expr
with ctx.newscope(fenced=True) as scopectx:
if_expr = dispatch.compile(ql_if_expr, ctx=scopectx)
with ctx.newscope(fenced=True) as scopectx:
else_expr = dispatch.compile(ql_else_expr, ctx=scopectx)
if_expr_type = irutils.infer_type(if_expr, ctx.schema)
else_expr_type = irutils.infer_type(else_expr, ctx.schema)
result = s_utils.get_class_nearest_common_ancestor(
[if_expr_type, else_expr_type])
if result is None:
raise errors.EdgeQLError(
'if/else clauses must be of related types, got: {}/{}'.format(
if_expr_type.name, else_expr_type.name),
context=expr.context)
return setgen.generated_set(irast.IfElseExpr(if_expr=if_expr,
else_expr=else_expr,
condition=condition),
ctx=ctx)
def compile_DeleteQuery(
expr: qlast.Base, *, ctx: context.ContextLevel) -> irast.Base:
with ctx.subquery() as ictx:
stmt = irast.DeleteStmt()
init_stmt(stmt, expr, ctx=ictx, parent_ctx=ctx)
# DELETE Expr is a delete(SET OF X), so we need a scope fence.
with ictx.newscope(fenced=True) as scopectx:
subject = setgen.scoped_set(
dispatch.compile(expr.subject, ctx=scopectx), ctx=scopectx)
subj_type = irutils.infer_type(subject, ictx.schema)
if not isinstance(subj_type, s_objtypes.ObjectType):
raise errors.EdgeQLError(
f'cannot delete non-ObjectType objects',
context=expr.subject.context
)
stmt.subject = compile_query_subject(
subject, shape=None, result_alias=expr.subject_alias, ctx=ictx)
stmt.result = setgen.class_set(
stmt.subject.scls.material_type(),
path_id=stmt.subject.path_id, ctx=ctx)
result = fini_stmt(stmt, expr, ctx=ictx, parent_ctx=ctx)
return result
def __infer_binop(ir, schema):
left_type, right_type = _infer_binop_args(ir.left, ir.right, schema)
if isinstance(ir.op,
(ast.ops.ComparisonOperator, ast.ops.MembershipOperator)):
result = schema.get('std::bool')
else:
result = s_basetypes.TypeRules.get_result(ir.op,
(left_type, right_type),
schema)
if result is None:
result = s_basetypes.TypeRules.get_result(
(ir.op, 'reversed'), (right_type, left_type), schema)
if result is None:
if right_type.implicitly_castable_to(left_type, schema):
right_type = left_type
elif left_type.implicitly_castable_to(right_type, schema):
left_type = right_type
result = s_basetypes.TypeRules.get_result(
(ir.op, 'reversed'), (right_type, left_type), schema)
if result is None:
raise ql_errors.EdgeQLError(
f'binary operator `{ir.op.upper()}` is not defined for types '
f'{left_type.name} and {right_type.name}',
context=ir.left.context)
return result
def __infer_coalesce(ir, schema):
result = _infer_common_type([ir.left, ir.right], schema)
if result is None:
raise ql_errors.EdgeQLError(
'coalescing operator must have operands of related types',
context=ir.context)
return result
def __infer_struct_indirection(ir, schema):
struct_type = infer_type(ir.expr, schema)
result = struct_type.element_types.get(ir.name)
if result is None:
raise ql_errors.EdgeQLError('could not determine struct element type',
context=ir.context)
return result
def get_schema_object(
name: typing.Union[str, qlast.ObjectRef],
module: typing.Optional[str] = None,
*,
item_types: typing.Optional[typing.List[s_obj.ObjectMeta]],
ctx: context.ContextLevel,
srcctx: typing.Optional[parsing.ParserContext] = None) -> s_obj.Object:
if isinstance(name, qlast.ObjectRef):
if srcctx is None:
srcctx = name.context
module = name.module
name = name.name
if module:
name = sn.Name(name=name, module=module)
if not module:
result = ctx.aliased_views.get(name)
if result is not None:
return result
try:
scls = ctx.schema.get(name=name,
module_aliases=ctx.modaliases,
type=item_types)
except s_err.ItemNotFoundError as e:
qlerror = qlerrors.EdgeQLError(e.args[0], context=srcctx)
s_utils.enrich_schema_lookup_error(qlerror,
name,
modaliases=ctx.modaliases,
schema=ctx.schema,
item_types=item_types)
raise qlerror
except s_err.SchemaError as e:
raise qlerrors.EdgeQLError(e.args[0], context=srcctx)
result = ctx.aliased_views.get(scls.name)
if result is None:
result = scls
return result
def compile_Array(expr: qlast.Base, *,
ctx: context.ContextLevel) -> irast.Base:
elements = [dispatch.compile(e, ctx=ctx) for e in expr.elements]
# check that none of the elements are themselves arrays
for el, expr_el in zip(elements, expr.elements):
if isinstance(irutils.infer_type(el, ctx.schema), s_types.Array):
raise errors.EdgeQLError(f'nested arrays are not supported',
context=expr_el.context)
return setgen.generated_set(irast.Array(elements=elements), ctx=ctx)
def compile_FunctionCall(
expr: qlast.Base, *, ctx: context.ContextLevel) -> irast.Base:
with ctx.new() as fctx:
if isinstance(expr.func, str):
funcname = expr.func
else:
funcname = sn.Name(expr.func[1], expr.func[0])
funcs = fctx.schema.get_functions(
funcname, module_aliases=fctx.modaliases)
if funcs is None:
raise errors.EdgeQLError(
f'could not resolve function name {funcname}',
context=expr.context)
fctx.in_func_call = True
args, kwargs, arg_types = process_func_args(expr, funcname, ctx=fctx)
fatal_array_check = len(funcs) == 1
for funcobj in funcs:
if check_function(expr, funcname, funcobj, arg_types,
fatal_array_check=fatal_array_check):
break
else:
raise errors.EdgeQLError(
f'could not find a function variant {funcname}',
context=expr.context)
fixup_param_scope(funcobj, args, kwargs, ctx=fctx)
node = irast.FunctionCall(func=funcobj, args=args, kwargs=kwargs)
if funcobj.initial_value is not None:
rtype = irutils.infer_type(node, fctx.schema)
iv_ql = qlast.TypeCast(
expr=qlparser.parse_fragment(funcobj.initial_value),
type=typegen.type_to_ql_typeref(rtype)
)
node.initial_value = dispatch.compile(iv_ql, ctx=fctx)
ir_set = setgen.ensure_set(node, ctx=ctx)
return ir_set
def compile_TypeFilter(expr: qlast.Base, *,
ctx: context.ContextLevel) -> irast.Base:
# Expr[IS Type] expressions.
with ctx.new() as scopectx:
arg = setgen.ensure_set(dispatch.compile(expr.expr, ctx=scopectx),
ctx=scopectx)
arg_type = irutils.infer_type(arg, ctx.schema)
if not isinstance(arg_type, s_objtypes.ObjectType):
raise errors.EdgeQLError(
f'invalid type filter operand: {arg_type.name} '
f'is not an object type',
context=expr.expr.context)
typ = schemactx.get_schema_type(expr.type.maintype, ctx=ctx)
if not isinstance(typ, s_objtypes.ObjectType):
raise errors.EdgeQLError(
f'invalid type filter operand: {typ.name} is not an object type',
context=expr.type.context)
return setgen.class_indirection_set(arg, typ, optional=False, ctx=ctx)
def infer_type(ir, schema):
try:
return ir._inferred_type_
except AttributeError:
pass
result = _infer_type(ir, schema)
if (result is not None
and not isinstance(result, (s_obj.Object, s_obj.ObjectMeta))):
raise ql_errors.EdgeQLError(
f'infer_type({ir!r}) retured {result!r} instead of a Object',
context=ir.context)
if result is None or result.name == 'std::any':
raise ql_errors.EdgeQLError('could not determine expression type',
context=ir.context)
ir._inferred_type_ = result
return result
def enforce_singleton_now(irexpr: irast.Base, *,
ctx: context.ContextLevel) -> None:
scope = pathctx.get_set_scope(ir_set=irexpr, ctx=ctx)
if scope is None:
scope = ctx.path_scope
cardinality = irinference.infer_cardinality(irexpr,
scope_tree=scope,
schema=ctx.schema)
if cardinality != irast.Cardinality.ONE:
raise errors.EdgeQLError(
'possibly more than one element returned by an expression '
'where only singletons are allowed',
context=irexpr.context)
def _add_to_schema(self, schema):
props = super().get_struct_properties(schema)
fullname = self._get_function_fullname(props['name'],
props.get('paramtypes'))
func = schema.get(fullname, None)
if func:
raise ql_errors.EdgeQLError(
f'Cannot create a function {self.classname}: '
f'a function with the same signature '
f'is already defined',
context=self.source_context)
super()._add_to_schema(schema)
def _add_to_schema(self, schema):
props = super().get_struct_properties(schema)
fullname = self._get_function_fullname(
props['name'], props.get('paramtypes'))
# check that params of type 'any' don't have defaults
for pn, pt, pd in zip(props['paramnames'], props['paramtypes'],
props['paramdefaults']):
if pt.name == 'std::any' and pd is not None:
raise ql_errors.EdgeQLError(
f'Cannot create a function {self.classname}: '
f'polymorphic parameter of type {pt.name} cannot have '
f'a default value', context=self.source_context)
func = schema.get(fullname, None)
if func:
raise ql_errors.EdgeQLError(
f'Cannot create a function {self.classname}: '
f'a function with the same signature '
f'is already defined', context=self.source_context)
super()._add_to_schema(schema)
def _infer_common_type(irs: typing.List[irast.Base], schema):
if not irs:
raise ql_errors.EdgeQLError(
'cannot determine common type of an empty set',
context=irs[0].context)
col_type = None
arg_types = []
empties = []
for i, arg in enumerate(irs):
if isinstance(arg, irast.EmptySet) and arg.scls is None:
empties.append(i)
continue
arg_type = infer_type(arg, schema)
arg_types.append(arg_type)
if isinstance(arg_type, s_types.Collection):
col_type = arg_type
if not arg_types:
raise ql_errors.EdgeQLError(
'cannot determine common type of an empty set',
context=irs[0].context)
if col_type is not None:
if not all(col_type.issubclass(t) for t in arg_types):
raise ql_errors.EdgeQLError(
'cannot determine common type',
context=irs[0].context)
common_type = col_type
else:
common_type = s_utils.get_class_nearest_common_ancestor(arg_types)
for i in empties:
amend_empty_set_type(irs[i], common_type, schema)
return common_type
def __infer_ifelse(ir, schema):
if_expr_type = infer_type(ir.if_expr, schema)
else_expr_type = infer_type(ir.else_expr, schema)
result = s_utils.get_class_nearest_common_ancestor(
[if_expr_type, else_expr_type])
if result is None:
raise ql_errors.EdgeQLError(
'if/else clauses must be of related types, got: {}/{}'.format(
if_expr_type.name, else_expr_type.name),
context=ir.if_expr.context)
return result
def __infer_unaryop(ir, schema):
result = None
operand_type = infer_type(ir.expr, schema)
if ir.op == ast.ops.NOT:
if operand_type.name == 'std::bool':
result = operand_type
else:
if ir.op not in {ast.ops.UPLUS, ast.ops.UMINUS}:
raise ql_errors.EdgeQLError(f'unknown unary operator: {ir.op}',
context=ir.context)
result = s_basetypes.TypeRules.get_result(ir.op, (operand_type, ),
schema)
if result is None:
raise ql_errors.EdgeQLError(
f'unary operator `{ir.op.upper()}` is not defined '
f'for type {operand_type.name}',
context=ir.context)
return result
def process_func_args(
expr: qlast.FunctionCall, funcname: sn.Name, *,
ctx: context.ContextLevel) \
-> typing.Tuple[
typing.List[irast.Base], # args
typing.Dict[str, irast.Base], # kwargs
typing.List[s_types.Type]]: # arg_types
args = []
kwargs = {}
arg_types = []
for ai, a in enumerate(expr.args):
arg_ql = a.arg
if a.sort or a.filter:
arg_ql = astutils.ensure_qlstmt(arg_ql)
if a.filter:
arg_ql.where = astutils.extend_qlbinop(arg_ql.where, a.filter)
if a.sort:
arg_ql.orderby = a.sort + arg_ql.orderby
with ctx.newscope(fenced=True) as fencectx:
# We put on a SET OF fence preemptively in case this is
# a SET OF arg, which we don't know yet due to polymorphic
# matching.
arg = setgen.scoped_set(
dispatch.compile(arg_ql, ctx=fencectx),
ctx=fencectx)
if a.name:
kwargs[a.name] = arg
aname = a.name
else:
args.append(arg)
aname = ai
arg_type = irutils.infer_type(arg, ctx.schema)
if arg_type is None:
raise errors.EdgeQLError(
f'could not resolve the type of argument '
f'${aname} of function {funcname}',
context=a.context)
arg_types.append(arg_type)
return args, kwargs, arg_types
def ensure_set(expr: irast.Base,
*,
typehint: typing.Optional[s_types.Type] = None,
path_id: typing.Optional[irast.PathId] = None,
ctx: context.ContextLevel) -> irast.Set:
if not isinstance(expr, irast.Set):
expr = generated_set(expr, typehint=typehint, path_id=path_id, ctx=ctx)
if (isinstance(expr, irast.EmptySet) and expr.scls is None
and typehint is not None):
irutils.amend_empty_set_type(expr, typehint, schema=ctx.schema)
if typehint is not None and not expr.scls.issubclass(typehint):
raise errors.EdgeQLError(
f'expecting expression of type {typehint.name}, '
f'got {expr.scls.name}',
context=expr.context)
return expr
def _infer_binop_args(left, right, schema):
if not isinstance(left, irast.EmptySet) or left.scls is not None:
left_type = infer_type(left, schema)
else:
left_type = None
if not isinstance(right, irast.EmptySet) or right.scls is not None:
right_type = infer_type(right, schema)
else:
right_type = None
if left_type is None and right_type is None:
raise ql_errors.EdgeQLError(
'cannot determine the type of an empty set', context=left.context)
elif left_type is None:
amend_empty_set_type(left, right_type, schema)
left_type = right_type
elif right_type is None:
amend_empty_set_type(right, left_type, schema)
right_type = left_type
return left_type, right_type
def infer_cardinality(ir, singletons, schema):
try:
return ir._inferred_cardinality_[frozenset(singletons)]
except (AttributeError, KeyError):
pass
result = _infer_cardinality(ir, singletons, schema)
if result not in {ONE, MANY}:
raise ql_errors.EdgeQLError(
'could not determine the cardinality of '
'set produced by expression',
context=ir.context)
try:
cache = ir._inferred_cardinality_
except AttributeError:
cache = ir._inferred_cardinality_ = {}
cache[frozenset(singletons)] = result
return result
def compile_EmptyCollection(expr: qlast.Base, *,
ctx: context.ContextLevel) -> irast.Base:
raise errors.EdgeQLError(f'could not determine type of empty array',
context=expr.context)
def _get_view_expr(cls, astnode):
expr = cls._maybe_get_view_expr(astnode)
if expr is None:
raise ql_errors.EdgeQLError(f'Missing required view expression',
context=astnode.context)
return expr
def compile_path(expr: qlast.Path, *, ctx: context.ContextLevel) -> irast.Set:
"""Create an ir.Set representing the given EdgeQL path expression."""
anchors = ctx.anchors
path_tip = None
if expr.partial:
if ctx.partial_path_prefix is not None:
path_tip = ctx.partial_path_prefix
else:
raise errors.EdgeQLError('could not resolve partial path ',
context=expr.context)
extra_scopes = {}
computables = []
path_sets = []
for i, step in enumerate(expr.steps):
if isinstance(step, qlast.Source):
# 'self' can only appear as the starting path label
# syntactically and is a known anchor
path_tip = anchors[step.__class__]
elif isinstance(step, qlast.Subject):
# '__subject__' can only appear as the starting path label
# syntactically and is a known anchor
path_tip = anchors[step.__class__]
elif isinstance(step, qlast.ObjectRef):
if i > 0:
raise RuntimeError(
'unexpected ObjectRef as a non-first path item')
refnode = None
if not step.module:
# Check if the starting path label is a known anchor
refnode = anchors.get(step.name)
if refnode is not None:
path_tip = copy.copy(refnode)
else:
scls = schemactx.get_schema_type(
step, item_types=(s_objtypes.ObjectType, ), ctx=ctx)
if (scls.view_type is not None
and scls.name not in ctx.view_nodes):
# This is a schema-level view, as opposed to
# a WITH-block or inline alias view.
scls = stmtctx.declare_view_from_schema(scls, ctx=ctx)
path_tip = class_set(scls, ctx=ctx)
view_set = ctx.view_sets.get(scls)
if view_set is not None:
path_tip = new_set_from_set(view_set, ctx=ctx)
path_scope = ctx.path_scope_map.get(view_set)
extra_scopes[path_tip] = path_scope.copy()
view_scls = ctx.class_view_overrides.get(scls.name)
if view_scls is not None:
path_tip.scls = view_scls
elif isinstance(step, qlast.Ptr):
# Pointer traversal step
ptr_expr = step
ptr_target = None
direction = (ptr_expr.direction
or s_pointers.PointerDirection.Outbound)
if ptr_expr.target:
# ... link [IS Target]
ptr_target = schemactx.get_schema_type(
ptr_expr.target.maintype, ctx=ctx)
if not isinstance(ptr_target, s_objtypes.ObjectType):
raise errors.EdgeQLError(
f'invalid type filter operand: {ptr_target.name} '
f'is not an object type',
context=ptr_expr.target.context)
ptr_name = (ptr_expr.ptr.module, ptr_expr.ptr.name)
if ptr_expr.type == 'property':
# Link property reference; the source is the
# link immediately preceding this step in the path.
source = path_tip.rptr.ptrcls
else:
source = path_tip.scls
with ctx.newscope(fenced=True, temporary=True) as subctx:
if isinstance(source, s_types.Tuple):
path_tip = tuple_indirection_set(
path_tip,
source=source,
ptr_name=ptr_name,
source_context=step.context,
ctx=subctx)
else:
path_tip = ptr_step_set(path_tip,
source=source,
ptr_name=ptr_name,
direction=direction,
ptr_target=ptr_target,
ignore_computable=True,
source_context=step.context,
ctx=subctx)
ptrcls = path_tip.rptr.ptrcls
if _is_computable_ptr(ptrcls, ctx=ctx):
computables.append(path_tip)
else:
# Arbitrary expression
if i > 0:
raise RuntimeError(
'unexpected expression as a non-first path item')
with ctx.newscope(fenced=True, temporary=True) as subctx:
path_tip = ensure_set(dispatch.compile(step, ctx=subctx),
ctx=subctx)
if path_tip.path_id.is_type_indirection_path():
scope_set = path_tip.rptr.source
else:
scope_set = path_tip
extra_scopes[scope_set] = subctx.path_scope
mapped = ctx.view_map.get(path_tip.path_id)
if mapped is not None:
path_tip = new_set(path_id=mapped.path_id,
scls=path_tip.scls,
expr=mapped.expr,
ctx=ctx)
path_sets.append(path_tip)
path_tip.context = expr.context
pathctx.register_set_in_scope(path_tip, ctx=ctx)
for ir_set in computables:
scope = ctx.path_scope.find_descendant(ir_set.path_id)
if scope is None:
# The path is already in the scope, no point
# in recompiling the computable expression.
continue
with ctx.new() as subctx:
subctx.path_scope = scope
comp_ir_set = computable_ptr_set(ir_set.rptr, ctx=subctx)
i = path_sets.index(ir_set)
if i != len(path_sets) - 1:
path_sets[i + 1].rptr.source = comp_ir_set
else:
path_tip = comp_ir_set
path_sets[i] = comp_ir_set
for ir_set, scope in extra_scopes.items():
node = ctx.path_scope.find_descendant(ir_set.path_id)
if node is None:
# The path portion not being a descendant means
# that is is already present in the scope above us,
# along with the view scope.
continue
fuse_scope_branch(ir_set, node, scope, ctx=ctx)
if ir_set.path_scope_id is None:
pathctx.assign_set_scope(ir_set, node, ctx=ctx)
return path_tip
