mercurylang/mercury
1
0
Fork 0
mirror of https://github.com/Mercury-Language/mercury.git synced 2025-12-17 14:57:03 +00:00
Code Issues Projects Releases Wiki Activity
Files
38d9ef3479fd2fdd0a24d3bd3e395bf96086d0c9
mercury/compiler/lambda.m
Mark Brown 38d9ef3479 Package the type_info_varmap and typeclass_info_varmap types into an ADT 
Estimated hours taken: 25
Branches: main

Package the type_info_varmap and typeclass_info_varmap types into an ADT
called rtti_varmaps.  There are two main purposes for this:

	- We wish to extend this set of maps with new maps.  Doing this
	will be a lot easier and less error prone if all of the maps are
	packaged in a single data structure.

	- Any new maps that we add may contain redundant information that
	just makes searching the maps more efficient.  Therefore they must
	be kept consistent with the existing maps.  Having all the maps
	inside an ADT makes it easier to ensure this.

This change also includes two extensions to the maps.  First, the
typeclass_info_map is made reversible so that it is possible to efficiently
look up the constraint for a given typeclass_info variable.  Second, a new
map from prog_vars to types makes it possible to efficiently look up the
type that a given type_info variable is for.  These two changes mean that
it is no longer necessary to consult the argument of type_info/1 or
typeclass_info/1 to find this information.  (We still do put that information
there, though; changing the RTTI is left for a separate change.)

compiler/hlds_pred.m:
	Move items relating to type_infos and typeclass_infos into a section
	of their own.

	Add a type `rtti_var_info' to hold information about the contents
	of a type_info or typeclass_info variable.

	Define the rtti_varmaps abstract data type.  This data structure
	consists of the type_info_varmap and the typeclass_info_varmap.
	Add a new map, type_info_type_map, which is like the inverse
	to the type_info_varmap.  The difference is that the latter can
	point to locations that are inside a typeclass_info variable,
	whereas the former only refers to type_info variables.  Note that
	the combined maps do not form a bijection, or even an injection,
	since it is possible for two different type variables to point to
	the same location (that is, if they are aliased).

	Make the typeclass_info_varmap reversible, by using the new module
	injection.m.  Unlike the type_info_varmap, this map is always
	injective since the same typeclass_info cannot be used for two
	different constraints.

	The predicates rtti_det_insert_type_info_locn and set_type_info_locn,
	which update the type_info_varmap, contain sanity checks to ensure
	that only type variables that have already been registered with
	the type_info_type_map are used, and that the information in both
	maps is consistent.

	Use the rtti_varmaps structure in proc_info and clauses_info, in
	place of type_info_varmap and typeclass_info_varmap.

compiler/polymorphism.m:
	Remove polymorphism__type_info_or_ctor_type/2 and
	polymorphism__typeclass_info_class_constraint/2, to ensure that
	nobody tries to use the information in the type argument.  Replace
	them with two similar predicates that test if a type is type_info
	or typeclass_info, but that don't return the argument.

	Ensure that the new type_info_type_map in the rtti_varmaps is kept
	up to date by threading the rtti_varmaps through a few more places.
	Some of these places are exported, so this part of the change
	affects other modules as well.

	Fix a comment that referred to a non-existent predicate.

compiler/type_util.m:
	Remove the predicates apply_substitutions_to_var_map/5 and
	apply_substitutions_to_typeclass_var_map/5.  The functionality
	is now provided by the new ADT.

compiler/cse_detection.m:
	Rewrite update_existential_data_structures/4 to use the interface
	provided by rtti_varmaps.  The algorithm for doing this has changed
	in the following ways:

		- The first pass, which builds a map from changed locations
		in the first branch to the tvars concerned, is modified
		slightly to traverse over the keys instead of over key-value
		pairs.

		- The second pass, which previously calculated the induced
		type substitution and reconstructed the type_info_varmap
		now only does the former.

		- Applying the prog_var transformation and the induced type
		substitution is done at the end, using the interface to
		rtti_varmaps.

compiler/goal_util.m:
	Rewrite goal_util__extra_nonlocal_typeinfos/6 to avoid the need
	for using map__member/3 on the typeclass_info_varmap (about which
	the existing comments say "this is probably not very efficient..."),
	and to be more efficient in general.

	Previously, we nondeterministically generated non-local type vars
	and then tested each constraint to see if it had the type var in it.
	Now, we go through each constraint one at a time and check if any of
	the type variables in it are non-local.  This is more efficient
	because we only need to find one non-local type in order to include
	the typeclass_info in the non-locals -- the remaining (duplicate)
	solutions are pruned away.

compiler/higher_order.m:
	Use the new maps instead of looking at the arguments of type_info/1
	and typeclass_info/1 types.  We plan to remove this information
	from type_info and typeclass_info types in future.

	Previously, this module used the type argument in order to update
	the varmaps when the curried arguments of a higher order call are
	added as arguments to the procedure in which the call occurs.
	We now look up this information at the point where the curried arg
	variables are known, and store this information in higher_order_arg
	alongside the types where it used to be stored.  This structure is
	threaded through to the place where the information is needed.

	Fix a cut and paste bug in higher_order_arg_depth/1.  It was
	previously calling higher_order_args_size/1 in the recursive
	call, instead of calling higher_order_args_depth/1.

compiler/inlining.m:
	In inlining__do_inline_call, apply the substitutions to the entire
	rtti_varmaps structure, not just to the type_info_varmap.  (XXX Is
	there a good reason why the substitution should _not_ be applied
	to the typeclass_info varmap?)

compiler/magic_util.m:
	Avoid using polymorphism__type_info_or_ctor_type/2 and
	polymorphism__typeclass_info_class_constraint/2, as these are
	no longer supported.

compiler/*.m:
	Straightforward changes to use the new ADT.

library/injection.m:
	New library module.  This provides an `injection' type which is
	similar to the existing `bimap' type in that it implements
	back-to-back maps, but doesn't have such stringent invariants
	imposed.  In particular, the reverse map is not required to be
	injective.

	This type is used to model the relationship between prog_constraints
	and program variables that hold typeclass_infos for them.  Namely,
	the typeclass_info for a constraint can be held in two different
	variables, but one variable can never hold the typeclass_info for
	two distinct constraints.

library/library.m:
	Add the new library module.

library/list.m:
	Add list__foldl_corresponding and list__foldl2_corresponding, which
	traverse two lists in parallel, which one or two accumulators, and
	abort if there is a length mismatch.

NEWS:
	Mention the changes to the standard library.
2005-07-22 12:32:07 +00:00

620 lines
22 KiB
Mathematica
Raw Blame History

%-----------------------------------------------------------------------------%
% Copyright (C) 1995-2005 The University of Melbourne.
% This file may only be copied under the terms of the GNU General
% Public License - see the file COPYING in the Mercury distribution.
%-----------------------------------------------------------------------------%
% file: lambda.m
% main author: fjh
% This module is a pass over the HLDS to deal with lambda expressions.
%
% Lambda expressions are converted into separate predicates, so for
% example we translate
%
% :- pred p(int::in) is det.
% p(X) :-
% V__1 = lambda([Y::out] is nondet, q(Y, X))),
% solutions(V__1, List),
% ...
% :- pred q(int::out, int::in) is nondet.
%
% into
%
% p(X) :-
% V__1 = '__LambdaGoal__1'(X)
% solutions(V__1, List),
% ...
%
% :- pred '__LambdaGoal__1'(int::in, int::out) is nondet.
% '__LambdaGoal__1'(X, Y) :- q(Y, X).
%
%
% Note that the mode checker requires that a lambda expression
% not bind any of the non-local variables such as `X' in the above
% example.
%
% Similarly, a lambda expression may not bind any of the type_infos for
% those variables; that is, none of the non-local variables
% should be existentially typed (from the perspective of the lambda goal).
% Now that we run the polymorphism.m pass before mode checking, this is
% also checked by mode analysis.
%
% It might be OK to allow the parameters of the lambda goal to be
% existentially typed, but currently that is not supported.
% One difficulty is that it's hard to determine here which type variables
% should be existentially quantified. The information is readily
% available during type inference, and really type inference should save
% that information in a field in the lambda_goal struct, but currently it
% doesn't; it saves the head_type_params field in the pred_info, which
% tells us which type variables where produced by the body, but for
% any given lambda goal we don't know whether the type variable was
% produced by something outside the lambda goal or by something inside
% the lambda goal (only in the latter case should it be existentially
% quantified).
% The other difficulty is that taking the address of a predicate with an
% existential type would require second-order polymorphism: for a predicate
% declared as `:- some [T] pred p(int, T)', the expression `p' must have
% type `some [T] pred(int, T)', which is quite a different thing to saying
% that there is some type `T' for which `p' has type `pred(int, T)' --
% we don't know what `T' is until the predicate is called, and it might
% be different for each call.
% Currently we don't support second-order polymorphism, so we
% don't support existentially typed lambda expressions either.
%
%-----------------------------------------------------------------------------%
:- module transform_hlds__lambda.
:- interface.
:- import_module hlds__hlds_module.
:- import_module hlds__hlds_pred.
:- pred lambda__process_module(module_info::in, module_info::out) is det.
:- pred lambda__process_pred(pred_id::in, module_info::in, module_info::out)
is det.
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
:- implementation.
% Parse tree modules
:- import_module parse_tree__prog_data.
:- import_module parse_tree__prog_mode.
:- import_module parse_tree__prog_util.
:- import_module parse_tree__prog_type.
% HLDS modules
:- import_module check_hlds__inst_match.
:- import_module check_hlds__mode_util.
:- import_module check_hlds__type_util.
:- import_module hlds__code_model.
:- import_module hlds__goal_util.
:- import_module hlds__hlds_data.
:- import_module hlds__hlds_goal.
:- import_module hlds__quantification.
% Misc
:- import_module libs__globals.
:- import_module libs__options.
:- import_module mdbcomp__prim_data.
% Standard library modules
:- import_module bool.
:- import_module list.
:- import_module map.
:- import_module require.
:- import_module set.
:- import_module std_util.
:- import_module string.
:- import_module term.
:- import_module varset.
:- type lambda_info --->
lambda_info(
prog_varset, % from the proc_info
map(prog_var, type), % from the proc_info
prog_constraints, % from the pred_info
tvarset, % from the proc_info
inst_varset, % from the proc_info
rtti_varmaps, % from the proc_info
pred_markers, % from the pred_info
pred_or_func,
string, % pred/func name
aditi_owner,
module_info,
bool % true iff we need to recompute the nonlocals
).
%-----------------------------------------------------------------------------%
% This whole section just traverses the module structure.
lambda__process_module(ModuleInfo0, ModuleInfo) :-
module_info_predids(ModuleInfo0, PredIds),
lambda__process_preds(PredIds, ModuleInfo0, ModuleInfo1),
% Need update the dependency graph to include the lambda predicates.
module_info_clobber_dependency_info(ModuleInfo1, ModuleInfo).
:- pred lambda__process_preds(list(pred_id)::in,
module_info::in, module_info::out) is det.
lambda__process_preds([], ModuleInfo, ModuleInfo).
lambda__process_preds([PredId | PredIds], ModuleInfo0, ModuleInfo) :-
lambda__process_pred(PredId, ModuleInfo0, ModuleInfo1),
lambda__process_preds(PredIds, ModuleInfo1, ModuleInfo).
lambda__process_pred(PredId, ModuleInfo0, ModuleInfo) :-
module_info_pred_info(ModuleInfo0, PredId, PredInfo),
ProcIds = pred_info_procids(PredInfo),
lambda__process_procs(PredId, ProcIds, ModuleInfo0, ModuleInfo).
:- pred lambda__process_procs(pred_id::in, list(proc_id)::in,
module_info::in, module_info::out) is det.
lambda__process_procs(_PredId, [], ModuleInfo, ModuleInfo).
lambda__process_procs(PredId, [ProcId | ProcIds], ModuleInfo0, ModuleInfo) :-
lambda__process_proc(PredId, ProcId, ModuleInfo0, ModuleInfo1),
lambda__process_procs(PredId, ProcIds, ModuleInfo1, ModuleInfo).
:- pred lambda__process_proc(pred_id::in, proc_id::in,
module_info::in, module_info::out) is det.
lambda__process_proc(PredId, ProcId, !ModuleInfo) :-
module_info_preds(!.ModuleInfo, PredTable0),
map__lookup(PredTable0, PredId, PredInfo0),
pred_info_procedures(PredInfo0, ProcTable0),
map__lookup(ProcTable0, ProcId, ProcInfo0),
lambda__process_proc_2(ProcInfo0, ProcInfo, PredInfo0, PredInfo1,
!ModuleInfo),
pred_info_procedures(PredInfo1, ProcTable1),
map__det_update(ProcTable1, ProcId, ProcInfo, ProcTable),
pred_info_set_procedures(ProcTable, PredInfo1, PredInfo),
module_info_preds(!.ModuleInfo, PredTable1),
map__det_update(PredTable1, PredId, PredInfo, PredTable),
module_info_set_preds(PredTable, !ModuleInfo).
:- pred lambda__process_proc_2(proc_info::in, proc_info::out,
pred_info::in, pred_info::out, module_info::in, module_info::out)
is det.
lambda__process_proc_2(!ProcInfo, !PredInfo, !ModuleInfo) :-
% grab the appropriate fields from the pred_info and proc_info
PredName = pred_info_name(!.PredInfo),
PredOrFunc = pred_info_is_pred_or_func(!.PredInfo),
pred_info_typevarset(!.PredInfo, TypeVarSet0),
pred_info_get_markers(!.PredInfo, Markers),
pred_info_get_class_context(!.PredInfo, Constraints0),
pred_info_get_aditi_owner(!.PredInfo, Owner),
proc_info_headvars(!.ProcInfo, HeadVars),
proc_info_varset(!.ProcInfo, VarSet0),
proc_info_vartypes(!.ProcInfo, VarTypes0),
proc_info_goal(!.ProcInfo, Goal0),
proc_info_rtti_varmaps(!.ProcInfo, RttiVarMaps0),
proc_info_inst_varset(!.ProcInfo, InstVarSet0),
MustRecomputeNonLocals0 = no,
% process the goal
Info0 = lambda_info(VarSet0, VarTypes0, Constraints0, TypeVarSet0,
InstVarSet0, RttiVarMaps0, Markers, PredOrFunc,
PredName, Owner, !.ModuleInfo, MustRecomputeNonLocals0),
lambda__process_goal(Goal0, Goal1, Info0, Info1),
Info1 = lambda_info(VarSet1, VarTypes1, Constraints, TypeVarSet,
_, RttiVarMaps, _, _, _, _, !:ModuleInfo,
MustRecomputeNonLocals),
% check if we need to requantify
( MustRecomputeNonLocals = yes ->
implicitly_quantify_clause_body(HeadVars, _Warnings,
Goal1, Goal, VarSet1, VarSet, VarTypes1, VarTypes)
;
Goal = Goal1,
VarSet = VarSet1,
VarTypes = VarTypes1
),
% set the new values of the fields in proc_info and pred_info
proc_info_set_goal(Goal, !ProcInfo),
proc_info_set_varset(VarSet, !ProcInfo),
proc_info_set_vartypes(VarTypes, !ProcInfo),
proc_info_set_rtti_varmaps(RttiVarMaps, !ProcInfo),
pred_info_set_typevarset(TypeVarSet, !PredInfo),
pred_info_set_class_context(Constraints, !PredInfo).
:- pred lambda__process_goal(hlds_goal::in, hlds_goal::out,
lambda_info::in, lambda_info::out) is det.
lambda__process_goal(Goal0 - GoalInfo0, Goal, !Info) :-
lambda__process_goal_2(Goal0, GoalInfo0, Goal, !Info).
:- pred lambda__process_goal_2(hlds_goal_expr::in, hlds_goal_info::in,
hlds_goal::out, lambda_info::in, lambda_info::out) is det.
lambda__process_goal_2(unify(XVar, Y, Mode, Unification, Context), GoalInfo,
Unify - GoalInfo, !Info) :-
(
Y = lambda_goal(Purity, PredOrFunc, EvalMethod, _,
NonLocalVars, Vars, Modes, Det, LambdaGoal0)
->
% first, process the lambda goal recursively, in case it
% contains some nested lambda expressions.
lambda__process_goal(LambdaGoal0, LambdaGoal1, !Info),
% then, convert the lambda expression into a new predicate
lambda__process_lambda(Purity, PredOrFunc, EvalMethod, Vars,
Modes, Det, NonLocalVars, LambdaGoal1,
Unification, Y1, Unification1, !Info),
Unify = unify(XVar, Y1, Mode, Unification1, Context)
;
% ordinary unifications are left unchanged
Unify = unify(XVar, Y, Mode, Unification, Context)
).
% the rest of the clauses just process goals recursively
lambda__process_goal_2(conj(Goals0), GoalInfo, conj(Goals) - GoalInfo,
!Info) :-
lambda__process_goal_list(Goals0, Goals, !Info).
lambda__process_goal_2(par_conj(Goals0), GoalInfo,
par_conj(Goals) - GoalInfo, !Info) :-
lambda__process_goal_list(Goals0, Goals, !Info).
lambda__process_goal_2(disj(Goals0), GoalInfo, disj(Goals) - GoalInfo,
!Info) :-
lambda__process_goal_list(Goals0, Goals, !Info).
lambda__process_goal_2(not(Goal0), GoalInfo, not(Goal) - GoalInfo, !Info) :-
lambda__process_goal(Goal0, Goal, !Info).
lambda__process_goal_2(switch(Var, CanFail, Cases0), GoalInfo,
switch(Var, CanFail, Cases) - GoalInfo, !Info) :-
lambda__process_cases(Cases0, Cases, !Info).
lambda__process_goal_2(scope(Reason, Goal0), GoalInfo,
scope(Reason, Goal) - GoalInfo, !Info) :-
lambda__process_goal(Goal0, Goal, !Info).
lambda__process_goal_2(if_then_else(Vars, Cond0, Then0, Else0), GoalInfo,
if_then_else(Vars, Cond, Then, Else) - GoalInfo, !Info) :-
lambda__process_goal(Cond0, Cond, !Info),
lambda__process_goal(Then0, Then, !Info),
lambda__process_goal(Else0, Else, !Info).
lambda__process_goal_2(Goal @ generic_call(_, _, _, _), GoalInfo,
Goal - GoalInfo, !Info).
lambda__process_goal_2(Goal @ call(_, _, _, _, _, _), GoalInfo,
Goal - GoalInfo, !Info).
lambda__process_goal_2(Goal @ foreign_proc(_, _, _, _, _, _), GoalInfo,
Goal - GoalInfo, !Info).
lambda__process_goal_2(shorthand(_), _, _, !Info) :-
% these should have been expanded out by now
error("lambda__process_goal_2: unexpected shorthand").
:- pred lambda__process_goal_list(list(hlds_goal)::in, list(hlds_goal)::out,
lambda_info::in, lambda_info::out) is det.
lambda__process_goal_list([], [], !Info).
lambda__process_goal_list([Goal0 | Goals0], [Goal | Goals], !Info) :-
lambda__process_goal(Goal0, Goal, !Info),
lambda__process_goal_list(Goals0, Goals, !Info).
:- pred lambda__process_cases(list(case)::in, list(case)::out,
lambda_info::in, lambda_info::out) is det.
lambda__process_cases([], [], !Info).
lambda__process_cases([case(ConsId, Goal0) | Cases0],
[case(ConsId, Goal) | Cases], !Info) :-
lambda__process_goal(Goal0, Goal, !Info),
lambda__process_cases(Cases0, Cases, !Info).
:- pred lambda__process_lambda(purity::in, pred_or_func::in,
lambda_eval_method::in, list(prog_var)::in, list(mode)::in,
determinism::in, list(prog_var)::in, hlds_goal::in, unification::in,
unify_rhs::out, unification::out, lambda_info::in, lambda_info::out)
is det.
lambda__process_lambda(Purity, PredOrFunc, EvalMethod, Vars, Modes, Detism,
OrigNonLocals0, LambdaGoal, Unification0, Functor,
Unification, LambdaInfo0, LambdaInfo) :-
LambdaInfo0 = lambda_info(VarSet, VarTypes, _PredConstraints, TVarSet,
InstVarSet, RttiVarMaps, Markers, POF, OrigPredName,
Owner, ModuleInfo0, MustRecomputeNonLocals0),
% Calculate the constraints which apply to this lambda
% expression.
% Note currently we only allow lambda expressions
% to have universally quantified constraints.
rtti_varmaps_constraints(RttiVarMaps, AllConstraints),
map__apply_to_list(Vars, VarTypes, LambdaVarTypes),
list__map(prog_type__vars, LambdaVarTypes, LambdaTypeVarsList),
list__condense(LambdaTypeVarsList, LambdaTypeVars),
list__filter(lambda__constraint_contains_vars(LambdaTypeVars),
AllConstraints, UnivConstraints),
Constraints = constraints(UnivConstraints, []),
% existentially typed lambda expressions are not yet supported
% (see the documentation at top of this file)
ExistQVars = [],
LambdaGoal = _ - LambdaGoalInfo,
goal_info_get_nonlocals(LambdaGoalInfo, LambdaGoalNonLocals),
set__insert_list(LambdaGoalNonLocals, Vars, LambdaNonLocals),
goal_util__extra_nonlocal_typeinfos(RttiVarMaps, VarTypes, ExistQVars,
LambdaNonLocals, ExtraTypeInfos),
OrigVars = OrigNonLocals0,
(
Unification0 = construct(Var0, _, _, UniModes0, _, _, _)
->
Var = Var0,
UniModes1 = UniModes0
;
error("lambda__transform_lambda: weird unification")
),
set__delete_list(LambdaGoalNonLocals, Vars, NonLocals1),
% We need all the typeinfos, including the ones that are not used,
% for the layout structure describing the closure.
NewTypeInfos = ExtraTypeInfos `set__difference` NonLocals1,
NonLocals = NonLocals1 `set__union` NewTypeInfos,
% If we added variables to the nonlocals of the lambda goal,
% then we need to recompute the nonlocals for the procedure
% that contains it.
( \+ set__empty(NewTypeInfos) ->
MustRecomputeNonLocals = yes
;
MustRecomputeNonLocals = MustRecomputeNonLocals0
),
set__to_sorted_list(NonLocals, ArgVars1),
(
% Optimize a special case: replace
% `lambda([Y1, Y2, ...] is Detism,
% p(X1, X2, ..., Y1, Y2, ...))'
% where `p' has determinism `Detism' with
% `p(X1, X2, ...)'
%
% This optimization is only valid if the modes of the Xi are
% input, since only input arguments can be curried.
% It's also only valid if all the inputs in the Yi precede the
% outputs. It's also not valid if any of the Xi are in the Yi.
LambdaGoal = call(PredId0, ProcId0, CallVars, _, _, _) - _,
module_info_pred_proc_info(ModuleInfo0, PredId0, ProcId0,
Call_PredInfo, Call_ProcInfo),
(
EvalMethod = (aditi_bottom_up),
pred_info_get_markers(Call_PredInfo, Call_Markers),
check_marker(Call_Markers, aditi)
;
EvalMethod = normal
),
list__remove_suffix(CallVars, Vars, InitialVars),
% check that none of the variables that we're trying to
% use as curried arguments are lambda-bound variables
\+ (
list__member(InitialVar, InitialVars),
list__member(InitialVar, Vars)
),
% Check that the code models are compatible.
% Note that det is not compatible with semidet,
% and semidet is not compatible with nondet,
% since the calling conventions are different.
% If we're using the LLDS back-end
% (i.e. not --high-level-code),
% det is compatible with nondet.
% If we're using the MLDS back-end,
% then predicates and functions have different
% calling conventions.
proc_info_interface_code_model(Call_ProcInfo, Call_CodeModel),
determinism_to_code_model(Detism, CodeModel),
module_info_globals(ModuleInfo0, Globals),
globals__lookup_bool_option(Globals, highlevel_code,
HighLevelCode),
(
HighLevelCode = no,
( CodeModel = Call_CodeModel
; CodeModel = model_non, Call_CodeModel = model_det
)
;
HighLevelCode = yes,
Call_PredOrFunc =
pred_info_is_pred_or_func(Call_PredInfo),
PredOrFunc = Call_PredOrFunc,
CodeModel = Call_CodeModel
),
% check that the curried arguments are all input
proc_info_argmodes(Call_ProcInfo, Call_ArgModes),
list__length(InitialVars, NumInitialVars),
list__take(NumInitialVars, Call_ArgModes, CurriedArgModes),
\+ ( list__member(Mode, CurriedArgModes),
\+ mode_is_input(ModuleInfo0, Mode)
)
->
ArgVars = InitialVars,
PredId = PredId0,
ProcId = ProcId0,
mode_util__modes_to_uni_modes(CurriedArgModes, CurriedArgModes,
ModuleInfo0, UniModes),
%
% we need to mark the procedure as having had its
% address taken
%
proc_info_set_address_taken(address_is_taken,
Call_ProcInfo, Call_NewProcInfo),
module_info_set_pred_proc_info(PredId, ProcId,
Call_PredInfo, Call_NewProcInfo,
ModuleInfo0, ModuleInfo)
;
% Prepare to create a new predicate for the lambda
% expression: work out the arguments, module name, predicate
% name, arity, arg types, determinism,
% context, status, etc. for the new predicate.
ArgVars = put_typeinfo_vars_first(ArgVars1, VarTypes),
list__append(ArgVars, Vars, AllArgVars),
module_info_name(ModuleInfo0, ModuleName),
goal_info_get_context(LambdaGoalInfo, OrigContext),
term__context_file(OrigContext, OrigFile),
term__context_line(OrigContext, OrigLine),
module_info_next_lambda_count(OrigContext, LambdaCount,
ModuleInfo0, ModuleInfo1),
make_pred_name_with_context(ModuleName, "IntroducedFrom",
PredOrFunc, OrigPredName, OrigLine,
LambdaCount, PredName),
goal_info_get_context(LambdaGoalInfo, LambdaContext),
% The TVarSet is a superset of what it really ought be,
% but that shouldn't matter.
% Existentially typed lambda expressions are not
% yet supported (see the documentation at top of this file)
ExistQVars = [],
lambda__uni_modes_to_modes(UniModes1, OrigArgModes),
% We have to jump through hoops to work out the mode
% of the lambda predicate. For introduced
% type_info arguments, we use the mode "in". For the original
% non-local vars, we use the modes from `UniModes1'.
% For the lambda var arguments at the end,
% we use the mode in the lambda expression.
list__length(ArgVars, NumArgVars),
in_mode(In),
list__duplicate(NumArgVars, In, InModes),
map__from_corresponding_lists(ArgVars, InModes,
ArgModesMap),
map__from_corresponding_lists(OrigVars, OrigArgModes,
OrigArgModesMap),
map__overlay(ArgModesMap, OrigArgModesMap, ArgModesMap1),
map__apply_to_list(ArgVars, ArgModesMap1, ArgModes1),
% Recompute the uni_modes.
mode_util__modes_to_uni_modes(ArgModes1, ArgModes1,
ModuleInfo1, UniModes),
list__append(ArgModes1, Modes, AllArgModes),
map__apply_to_list(AllArgVars, VarTypes, ArgTypes),
purity_to_markers(Purity, LambdaMarkers0),
(
% Pass through the aditi markers for
% aggregate query closures.
% XXX we should differentiate between normal
% top-down closures and aggregate query closures,
% possibly by using a different type for aggregate
% queries. Currently all nondet lambda expressions
% within Aditi predicates are treated as aggregate
% inputs.
% EvalMethod = (aditi_bottom_up),
determinism_components(Detism, _, at_most_many),
check_marker(Markers, aditi)
->
markers_to_marker_list(Markers, MarkerList0),
list__filter(
(pred(Marker::in) is semidet :-
% Pass through only Aditi markers.
% Don't pass through `context' markers, since
% they are useless for non-recursive predicates
% such as the created predicate.
( Marker = aditi
; Marker = dnf
; Marker = psn
; Marker = naive
; Marker = supp_magic
; Marker = aditi_memo
; Marker = aditi_no_memo
)),
MarkerList0, MarkerList),
list__foldl(add_marker, MarkerList,
LambdaMarkers0, LambdaMarkers)
;
EvalMethod = (aditi_bottom_up)
->
add_marker(aditi, LambdaMarkers0, LambdaMarkers)
;
LambdaMarkers = LambdaMarkers0
),
% Now construct the proc_info and pred_info for the new
% single-mode predicate, using the information computed above
proc_info_create(LambdaContext, VarSet, VarTypes,
AllArgVars, InstVarSet, AllArgModes, Detism,
LambdaGoal, RttiVarMaps, address_is_taken, ProcInfo0),
% The debugger ignores unnamed variables.
ensure_all_headvars_are_named(ProcInfo0, ProcInfo1),
% If we previously already needed to recompute the nonlocals,
% then we'd better to that recomputation for the procedure
% that we just created.
(
MustRecomputeNonLocals0 = yes,
requantify_proc(ProcInfo1, ProcInfo)
;
MustRecomputeNonLocals0 = no,
ProcInfo = ProcInfo1
),
set__init(Assertions),
pred_info_create(ModuleName, PredName, PredOrFunc,
LambdaContext, lambda(OrigFile, OrigLine, LambdaCount),
local, LambdaMarkers, ArgTypes, TVarSet, ExistQVars,
Constraints, Assertions, Owner, ProcInfo, ProcId,
PredInfo),
% save the new predicate in the predicate table
module_info_get_predicate_table(ModuleInfo1, PredicateTable0),
predicate_table_insert(PredInfo, PredId,
PredicateTable0, PredicateTable),
module_info_set_predicate_table(PredicateTable,
ModuleInfo1, ModuleInfo)
),
ShroudedPredProcId = shroud_pred_proc_id(proc(PredId, ProcId)),
ConsId = pred_const(ShroudedPredProcId, EvalMethod),
Functor = functor(ConsId, no, ArgVars),
Unification = construct(Var, ConsId, ArgVars, UniModes,
construct_dynamically, cell_is_unique, no),
LambdaInfo = lambda_info(VarSet, VarTypes, Constraints, TVarSet,
InstVarSet, RttiVarMaps, Markers, POF, OrigPredName, Owner,
ModuleInfo, MustRecomputeNonLocals).
:- pred lambda__constraint_contains_vars(list(tvar)::in, prog_constraint::in)
is semidet.
lambda__constraint_contains_vars(LambdaVars, ClassConstraint) :-
ClassConstraint = constraint(_, ConstraintTypes),
list__map(prog_type__vars, ConstraintTypes, ConstraintVarsList),
list__condense(ConstraintVarsList, ConstraintVars),
% Probably not the most efficient way of doing it, but I
% wouldn't think that it matters.
set__list_to_set(LambdaVars, LambdaVarsSet),
set__list_to_set(ConstraintVars, ConstraintVarsSet),
set__subset(ConstraintVarsSet, LambdaVarsSet).
:- pred lambda__uni_modes_to_modes(list(uni_mode)::in, list(mode)::out)
is det.
% This predicate works out the modes of the original non-local
% variables of a lambda expression based on the list of uni_mode
% in the unify_info for the lambda unification.
lambda__uni_modes_to_modes([], []).
lambda__uni_modes_to_modes([UniMode | UniModes], [Mode | Modes]) :-
UniMode = ((_Initial0 - Initial1) -> (_Final0 - _Final1)),
Mode = (Initial1 -> Initial1),
lambda__uni_modes_to_modes(UniModes, Modes).
%---------------------------------------------------------------------------%
%---------------------------------------------------------------------------%
Reference in New Issue View Git Blame Copy Permalink