mercury/compiler/unique_modes.m

%-----------------------------------------------------------------------------%
% Copyright (C) 1996-1999 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: unique_modes.m
% main author: fjh

% This module checks that variables with a unique mode (as opposed to
% a mostly-unique mode) really are unique, and not nondet live - i.e.,
% that they cannot be referenced on backtracking.
% (Actually the term "nondet live" is a bit of a misnomer, because
% really we are just interested in whether something can be referenced
% on backtracking, and this can occur after backtracking in semidet
% code too, not just in nondet code.)

% Basically we just traverse each goal, keeping track of which variables
% are nondet live.  At each procedure call, we check that any arguments
% whose initial insts are required to be unique are not nondet live.
% If they are, we first try selecting a different mode of the same
% predicate, and if that fails, then we report an error message.

% Variables can become nondet live in several places:
% in negations, in the conditions of if-then-elses,
% in disjunctions, and at nondet calls.
% These are the only places at which we can resume execution
% after backtracking.

% XXX we currently make the conservative assumption that
% any non-local variable in a disjunction or nondet call
% is nondet-live - and stays nondet-live.

%-----------------------------------------------------------------------------%

:- module unique_modes.
:- interface. 
:- import_module hlds_module, hlds_pred, hlds_goal, mode_info.
:- import_module io, bool.

	% check every predicate in a module
:- pred unique_modes__check_module(module_info, module_info,
					io__state, io__state).
:- mode unique_modes__check_module(in, out, di, uo) is det.

	% just check a single procedure
:- pred unique_modes__check_proc(proc_id, pred_id, module_info,
				module_info, bool, io__state, io__state).
:- mode unique_modes__check_proc(in, in, in, out, out, di, uo) is det.

	% just check a single goal
:- pred unique_modes__check_goal(hlds_goal, hlds_goal, mode_info, mode_info).
:- mode unique_modes__check_goal(in, out, mode_info_di, mode_info_uo) is det.

%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%

:- implementation.

:- import_module hlds_data, mode_debug, modecheck_unify, modecheck_call.
:- import_module mode_util, prog_out, hlds_out, mercury_to_mercury, passes_aux.
:- import_module modes, prog_data, mode_errors, llds, unify_proc.
:- import_module (inst), instmap, inst_match, inst_util.
:- import_module term, varset.
:- import_module int, list, map, set, std_util, require, assoc_list.

%-----------------------------------------------------------------------------%

unique_modes__check_module(ModuleInfo0, ModuleInfo) -->
	check_pred_modes(check_unique_modes, may_change_called_proc,
			ModuleInfo0, ModuleInfo, _UnsafeToContinue).

unique_modes__check_proc(ProcId, PredId, ModuleInfo0, ModuleInfo, Changed) -->
	modecheck_proc(ProcId, PredId,
		check_unique_modes, may_change_called_proc,
		ModuleInfo0, ModuleInfo, NumErrors, Changed),
	( { NumErrors \= 0 } ->
		io__set_exit_status(1)
	;
		[]
	).

	% XXX we currently make the conservative assumption that
	% any non-local variable in a disjunction or nondet call
	% is nondet-live - and stays nondet-live.

unique_modes__check_goal(Goal0, Goal, ModeInfo0, ModeInfo) :-
	%
	% store the current context in the mode_info
	%
	Goal0 = GoalExpr0 - GoalInfo0,
	goal_info_get_context(GoalInfo0, Context),
	term__context_init(EmptyContext),
	( Context = EmptyContext ->
		ModeInfo1 = ModeInfo0
	;
		mode_info_set_context(Context, ModeInfo0, ModeInfo1)
	),

	%
	% Grab the original instmap
	%
	mode_info_get_instmap(ModeInfo1, InstMap0),

	% 
	% Grab the original bag of nondet-live vars
	%
	mode_info_get_nondet_live_vars(ModeInfo1, NondetLiveVars0),

	% 
	% If the goal is not nondet, then nothing is nondet-live,
	% so reset the bag of nondet-live vars to be empty.
	%
	goal_info_get_code_model(GoalInfo0, CodeModel),
	( CodeModel = model_non ->
		ModeInfo2 = ModeInfo1
	;
		mode_info_set_nondet_live_vars([], ModeInfo1, ModeInfo2)
	),

	%
	% Modecheck the goal
	%
	unique_modes__check_goal_2(GoalExpr0, GoalInfo0, GoalExpr,
		ModeInfo2, ModeInfo3),

	% 
	% Restore the original bag of nondet-live vars
	%
	mode_info_set_nondet_live_vars(NondetLiveVars0, ModeInfo3, ModeInfo),

	%
	% Grab the final instmap, compute the change in insts
	% over this goal, and save that instmap_delta in the goal_info.
	%
	mode_info_get_instmap(ModeInfo, InstMap),
	goal_info_get_nonlocals(GoalInfo0, NonLocals),
	compute_instmap_delta(InstMap0, InstMap, NonLocals, DeltaInstMap),
	goal_info_set_instmap_delta(GoalInfo0, DeltaInstMap, GoalInfo),

	Goal = GoalExpr - GoalInfo.

	% Make all nondet-live variables whose current inst
	% is `unique' become `mostly_unique'.
	%
:- pred make_all_nondet_live_vars_mostly_uniq(mode_info, mode_info).
:- mode make_all_nondet_live_vars_mostly_uniq(mode_info_di, mode_info_uo)
	is det.

make_all_nondet_live_vars_mostly_uniq(ModeInfo0, ModeInfo) :-
	mode_info_get_instmap(ModeInfo0, FullInstMap0),
	( instmap__is_reachable(FullInstMap0) ->
		instmap__vars_list(FullInstMap0, AllVars),
		select_nondet_live_vars(AllVars, ModeInfo0, NondetLiveVars),
		make_var_list_mostly_uniq(NondetLiveVars, ModeInfo0, ModeInfo)
	;
		ModeInfo = ModeInfo0
	).

:- pred select_live_vars(list(prog_var), mode_info, list(prog_var)).
:- mode select_live_vars(in, mode_info_ui, out) is det.

select_live_vars([], _, []).
select_live_vars([Var|Vars], ModeInfo, LiveVars) :-
	( mode_info_var_is_live(ModeInfo, Var, live) ->
		LiveVars = [Var | LiveVars1],
		select_live_vars(Vars, ModeInfo, LiveVars1)
	;
		select_live_vars(Vars, ModeInfo, LiveVars)
	).

:- pred select_nondet_live_vars(list(prog_var), mode_info, list(prog_var)).
:- mode select_nondet_live_vars(in, mode_info_ui, out) is det.

select_nondet_live_vars([], _, []).
select_nondet_live_vars([Var|Vars], ModeInfo, NondetLiveVars) :-
	( mode_info_var_is_nondet_live(ModeInfo, Var, live) ->
		NondetLiveVars = [Var | NondetLiveVars1],
		select_nondet_live_vars(Vars, ModeInfo, NondetLiveVars1)
	;
		select_nondet_live_vars(Vars, ModeInfo, NondetLiveVars)
	).

	% Given a list of variables, a delta instmap, and a mode_info,
	% select all the variables whose inst changed in the delta instmap
	% (other than changes which just add information,
	% e.g. `ground -> bound(42)'.)
	%
:- pred select_changed_inst_vars(list(prog_var), instmap_delta, mode_info,
		list(prog_var)).
:- mode select_changed_inst_vars(in, in, mode_info_ui, out) is det.

select_changed_inst_vars([], _DeltaInstMap, _ModeInfo, []).
select_changed_inst_vars([Var | Vars], DeltaInstMap, ModeInfo, ChangedVars) :-
	mode_info_get_module_info(ModeInfo, ModuleInfo),
	mode_info_get_instmap(ModeInfo, InstMap0),
	instmap__lookup_var(InstMap0, Var, Inst0),
	(
		instmap_delta_is_reachable(DeltaInstMap),
		instmap_delta_search_var(DeltaInstMap, Var, Inst),
		\+ inst_matches_final(Inst, Inst0, ModuleInfo)
	->
		ChangedVars = [Var | ChangedVars1],
		select_changed_inst_vars(Vars, DeltaInstMap, ModeInfo,
			ChangedVars1)
	;
		select_changed_inst_vars(Vars, DeltaInstMap, ModeInfo,
			ChangedVars)
	).

:- pred make_var_list_mostly_uniq(list(prog_var), mode_info, mode_info).
:- mode make_var_list_mostly_uniq(in, mode_info_di, mode_info_uo) is det.

make_var_list_mostly_uniq([], ModeInfo, ModeInfo).
make_var_list_mostly_uniq([Var | Vars], ModeInfo0, ModeInfo) :-
	make_var_mostly_uniq(Var, ModeInfo0, ModeInfo1),
	make_var_list_mostly_uniq(Vars, ModeInfo1, ModeInfo).

:- pred make_var_mostly_uniq(prog_var, mode_info, mode_info).
:- mode make_var_mostly_uniq(in, mode_info_di, mode_info_uo) is det.

make_var_mostly_uniq(Var, ModeInfo0, ModeInfo) :-
	mode_info_get_instmap(ModeInfo0, InstMap0),
	mode_info_get_module_info(ModeInfo0, ModuleInfo0),
	(
		%
		% only variables which are `unique' need to be changed
		%
		instmap__is_reachable(InstMap0),
		instmap__vars_list(InstMap0, Vars),
		list__member(Var, Vars),
		instmap__lookup_var(InstMap0, Var, Inst0),
		inst_expand(ModuleInfo0, Inst0, Inst1),
		( Inst1 = ground(unique, _)
		; Inst1 = bound(unique, _)
		; Inst1 = any(unique)
		)
	->
		make_mostly_uniq_inst(Inst0, ModuleInfo0, Inst, ModuleInfo),
		mode_info_set_module_info(ModeInfo0, ModuleInfo, ModeInfo1),
		instmap__set(InstMap0, Var, Inst, InstMap),
		mode_info_set_instmap(InstMap, ModeInfo1, ModeInfo)
	;
		ModeInfo = ModeInfo0
	).

:- pred unique_modes__check_goal_2(hlds_goal_expr, hlds_goal_info,
		hlds_goal_expr, mode_info, mode_info).
:- mode unique_modes__check_goal_2(in, in, out, mode_info_di, mode_info_uo)
		is det.

unique_modes__check_goal_2(conj(List0), _GoalInfo0, conj(List)) -->
	mode_checkpoint(enter, "conj"),
	( { List0 = [] } ->	% for efficiency, optimize common case
		{ List = [] }
	;
		mode_info_add_goals_live_vars(List0),
		unique_modes__check_conj(List0, List)
	),
	mode_checkpoint(exit, "conj").

unique_modes__check_goal_2(par_conj(List0, SM), GoalInfo0,
		par_conj(List, SM)) -->
	mode_checkpoint(enter, "par_conj"),
	{ goal_info_get_nonlocals(GoalInfo0, NonLocals) },
	mode_info_add_live_vars(NonLocals),
	unique_modes__check_par_conj(List0, List, InstMapList),
	instmap__unify(NonLocals, InstMapList),
	mode_info_remove_live_vars(NonLocals),
	mode_checkpoint(exit, "par_conj").

unique_modes__check_goal_2(disj(List0, SM), GoalInfo0, disj(List, SM)) -->
	mode_checkpoint(enter, "disj"),
	( { List0 = [] } ->
		{ List = [] },
		{ instmap__init_unreachable(InstMap) },
		mode_info_set_instmap(InstMap)
	;
		%
		% Mark all the variables which are nondet-live at the
		% start of the disjunction and whose inst is `unique'
		% as instead being only `mostly_unique'.
		%
		{ goal_info_get_nonlocals(GoalInfo0, NonLocals) },
		mode_info_add_live_vars(NonLocals),
		make_all_nondet_live_vars_mostly_uniq,
		mode_info_remove_live_vars(NonLocals),

		%
		% Now just modecheck each disjunct in turn, and then
		% merge the resulting instmaps.
		%
		unique_modes__check_disj(List0, List, InstMapList),
		instmap__merge(NonLocals, InstMapList, disj)
	),
	mode_checkpoint(exit, "disj").

unique_modes__check_goal_2(if_then_else(Vs, A0, B0, C0, SM), GoalInfo0, Goal)
		-->
	mode_checkpoint(enter, "if-then-else"),
	{ goal_info_get_nonlocals(GoalInfo0, NonLocals) },
	{ unique_modes__goal_get_nonlocals(A0, A_Vars) },
	{ unique_modes__goal_get_nonlocals(B0, B_Vars) },
	{ unique_modes__goal_get_nonlocals(C0, C_Vars) },
	mode_info_dcg_get_instmap(InstMap0),
	mode_info_lock_vars(if_then_else, NonLocals),

	%
	% At this point, we should set the inst of any `unique'
	% variables which occur in the condition and which
	% are live to `mostly_unique'.  However, if a variable's
	% inst was unchanged over the condition (i.e. it remains
	% `unique' on exit from the condition), then it is
	% safe to leave it as `unique' on entry to the condition.
	% The only case we need to set it to `mostly_unique' is
	% if the condition would clobber it.
	%
	% XXX actually that is not true; the code below does
	% the wrong thing for examples such as this one:
	%
	% :- mode p(di).
	% p(Var) :-
	%	(if 
	%		(if semidet_succeed then
	%			clobber(Var), fail
	%		else
	%			true
	%		)
	%	then
	%		blah
	%	else
	%		use(Var)
	%	).
	%
	mode_info_add_live_vars(C_Vars),
	=(ModeInfo),
	{ set__to_sorted_list(A_Vars, A_Vars_List) },
	{ select_live_vars(A_Vars_List, ModeInfo, A_Live_Vars) },
	{ A0 = _ - A0_GoalInfo },
	{ goal_info_get_instmap_delta(A0_GoalInfo, A0_DeltaInstMap) },
	{ select_changed_inst_vars(A_Live_Vars, A0_DeltaInstMap, ModeInfo,
				ChangedVars) },
	make_var_list_mostly_uniq(ChangedVars),
	mode_info_remove_live_vars(C_Vars),

	mode_info_add_live_vars(B_Vars),
	unique_modes__check_goal(A0, A),
	mode_info_remove_live_vars(B_Vars),
	mode_info_unlock_vars(if_then_else, NonLocals),
	% mode_info_dcg_get_instmap(InstMapA),
	unique_modes__check_goal(B0, B),
	mode_info_dcg_get_instmap(InstMapB),
	mode_info_set_instmap(InstMap0),
	unique_modes__check_goal(C0, C),
	mode_info_dcg_get_instmap(InstMapC),
	mode_info_set_instmap(InstMap0),
	instmap__merge(NonLocals, [InstMapB, InstMapC], if_then_else),
	{ Goal = if_then_else(Vs, A, B, C, SM) },
	mode_checkpoint(exit, "if-then-else").

unique_modes__check_goal_2(not(A0), GoalInfo0, not(A)) -->
	mode_checkpoint(enter, "not"),
	{ goal_info_get_nonlocals(GoalInfo0, NonLocals) },
	mode_info_dcg_get_instmap(InstMap0),
	{ set__to_sorted_list(NonLocals, NonLocalsList) },
	=(ModeInfo),
	{ select_live_vars(NonLocalsList, ModeInfo, LiveNonLocals) },
	make_var_list_mostly_uniq(LiveNonLocals),
	mode_info_lock_vars(negation, NonLocals),
	unique_modes__check_goal(A0, A),
	mode_info_unlock_vars(negation, NonLocals),
	mode_info_set_instmap(InstMap0),
	mode_checkpoint(exit, "not").

unique_modes__check_goal_2(some(Vs, G0), _, some(Vs, G)) -->
	mode_checkpoint(enter, "some"),
	unique_modes__check_goal(G0, G),
	mode_checkpoint(exit, "some").

unique_modes__check_goal_2(higher_order_call(PredVar, Args, Types, Modes, Det,
		PredOrFunc), _GoalInfo0, Goal) -->
	mode_checkpoint(enter, "higher-order call"),
	mode_info_set_call_context(higher_order_call(PredOrFunc)),
	{ determinism_components(Det, _, at_most_zero) ->
		NeverSucceeds = yes
	;
		NeverSucceeds = no
	},
	{ determinism_to_code_model(Det, CodeModel) },
	unique_modes__check_call_modes(Args, Modes, CodeModel, NeverSucceeds),
	{ Goal = higher_order_call(PredVar, Args, Types, Modes, Det,
			PredOrFunc) },
	mode_info_unset_call_context,
	mode_checkpoint(exit, "higher-order call").

unique_modes__check_goal_2(class_method_call(TCVar, Num, Args, Types, Modes,
		Det), _GoalInfo0, Goal) -->
	mode_checkpoint(enter, "class method call"),
		% Setting the context to `higher_order_call(...)' is a little
		% white lie.  However, since there can't really be a unique 
		% mode error in a class_method_call, this lie will never be
		% used. There can't be an error because the class_method_call 
		% is introduced by the compiler as the body of a class method.
	mode_info_set_call_context(higher_order_call(predicate)),
	{ determinism_components(Det, _, at_most_zero) ->
		NeverSucceeds = yes
	;
		NeverSucceeds = no
	},
	{ determinism_to_code_model(Det, CodeModel) },
	unique_modes__check_call_modes(Args, Modes, CodeModel, NeverSucceeds),
	{ Goal = class_method_call(TCVar, Num, Args, Types, Modes, Det) },
	mode_info_unset_call_context,
	mode_checkpoint(exit, "class method call").

unique_modes__check_goal_2(call(PredId, ProcId0, Args, Builtin, CallContext,
		PredName), _GoalInfo0, Goal) -->
	mode_checkpoint(enter, "call"),
	mode_info_set_call_context(call(PredId)),
	unique_modes__check_call(PredId, ProcId0, Args, ProcId),
	{ Goal = call(PredId, ProcId, Args, Builtin, CallContext, PredName) },
	mode_info_unset_call_context,
	mode_checkpoint(exit, "call").

unique_modes__check_goal_2(unify(A0, B0, _, UnifyInfo0, UnifyContext),
		GoalInfo0, Goal) -->
	mode_checkpoint(enter, "unify"),
	mode_info_set_call_context(unify(UnifyContext)),

	modecheck_unification(A0, B0, UnifyInfo0, UnifyContext, GoalInfo0,
		Goal),

	mode_info_unset_call_context,
	mode_checkpoint(exit, "unify").

unique_modes__check_goal_2(switch(Var, CanFail, Cases0, SM), GoalInfo0,
		switch(Var, CanFail, Cases, SM)) -->
	mode_checkpoint(enter, "switch"),
	( { Cases0 = [] } ->
		{ Cases = [] },
		{ instmap__init_unreachable(InstMap) },
		mode_info_set_instmap(InstMap)
	;
		{ goal_info_get_nonlocals(GoalInfo0, NonLocals) },
		unique_modes__check_case_list(Cases0, Var, Cases, InstMapList),
		instmap__merge(NonLocals, InstMapList, disj)
	),
	mode_checkpoint(exit, "switch").

	% to modecheck a pragma_c_code, we just modecheck the proc for 
	% which it is the goal.
unique_modes__check_goal_2(pragma_c_code(IsRecursive, PredId, ProcId0,
		Args, ArgNameMap, OrigArgTypes, PragmaCode),
		_GoalInfo, Goal) -->
	mode_checkpoint(enter, "pragma_c_code"),
	mode_info_set_call_context(call(PredId)),
	unique_modes__check_call(PredId, ProcId0, Args, ProcId),
	{ Goal = pragma_c_code(IsRecursive, PredId, ProcId, Args,
			ArgNameMap, OrigArgTypes, PragmaCode) },
	mode_info_unset_call_context,
	mode_checkpoint(exit, "pragma_c_code").

:- pred unique_modes__check_call(pred_id, proc_id, list(prog_var), proc_id, 
			mode_info, mode_info).
:- mode unique_modes__check_call(in, in, in, out,
			mode_info_di, mode_info_uo) is det.

unique_modes__check_call(PredId, ProcId0, ArgVars, ProcId,
		ModeInfo0, ModeInfo) :-
	%
	% set the error list to empty for use below
	% (saving the old error list and instmap in variables)
	%
	mode_info_get_errors(ModeInfo0, OldErrors),
	mode_info_get_instmap(ModeInfo0, InstMap0),
	mode_info_set_errors([], ModeInfo0, ModeInfo1),

	%
	% first off, try using the existing mode
	%
	mode_info_get_module_info(ModeInfo0, ModuleInfo),
	module_info_pred_proc_info(ModuleInfo, PredId, ProcId0, _, ProcInfo),
	proc_info_argmodes(ProcInfo, ProcArgModes0),
	proc_info_interface_code_model(ProcInfo, CodeModel),
	proc_info_never_succeeds(ProcInfo, NeverSucceeds),
	unique_modes__check_call_modes(ArgVars, ProcArgModes0, CodeModel,
				NeverSucceeds, ModeInfo1, ModeInfo2),

	%
	% see whether or not that worked
	% (and restore the old error list)
	%
	mode_info_get_errors(ModeInfo2, Errors),
	mode_info_set_errors(OldErrors, ModeInfo2, ModeInfo3),
	mode_info_get_may_change_called_proc(ModeInfo3, MayChangeCalledProc),
	( Errors = [] ->
		ProcId = ProcId0,
		ModeInfo = ModeInfo3
	; MayChangeCalledProc = may_not_change_called_proc ->
		% We're not allowed to try a different procedure
		% here, so just return all the errors.
		ProcId = ProcId0,
		list__append(OldErrors, Errors, AllErrors),
		mode_info_set_errors(AllErrors, ModeInfo3, ModeInfo)
	;
		%
		% If it didn't work, restore the original instmap,
		% and then call modecheck_call_pred.
		% That will try all the modes, and will infer
		% new ones if necessary. 
		%
		% We set the declared determinism for newly inferred
		% modes to be the same as the determinism inferred for
		% the existing mode selected by ordinary (non-unique)
		% mode analysis.  This means that determinism analysis
		% will report an error if the determinism changes
		% as a result of unique mode analysis.  That is OK,
		% because uniqueness should not affect determinism.
		%
		mode_info_set_instmap(InstMap0, ModeInfo3, ModeInfo4),
		proc_info_inferred_determinism(ProcInfo, Determinism),
		modecheck_call_pred(PredId, ProcId0, ArgVars, yes(Determinism),
			ProcId, NewArgVars, ExtraGoals, ModeInfo4, ModeInfo),
		
		( NewArgVars = ArgVars, ExtraGoals = no_extra_goals ->
			true
		;
			% this shouldn't happen, since modes.m should do
			% all the handling of implied modes
			% XXX it might happen, though, if the user
			% XXX writes strange code; we should report
			% XXX a proper error here
			error("unique_modes.m: call to implied mode?")
		)
	).

	% to check a call, we just look up the required initial insts
	% for the arguments of the call, and then check for each
	% argument if the variable is nondet-live and the required initial
	% inst was unique.

:- pred unique_modes__check_call_modes(list(prog_var), list(mode), code_model,
		bool, mode_info, mode_info).
:- mode unique_modes__check_call_modes(in, in, in, in,
			mode_info_di, mode_info_uo) is det.

unique_modes__check_call_modes(ArgVars, ProcArgModes, CodeModel, NeverSucceeds,
			ModeInfo0, ModeInfo) :-
	mode_info_get_module_info(ModeInfo0, ModuleInfo),
	mode_list_get_initial_insts(ProcArgModes, ModuleInfo,
				InitialInsts),
	modecheck_var_has_inst_list(ArgVars, InitialInsts, 0,
				ModeInfo0, ModeInfo1),
	mode_list_get_final_insts(ProcArgModes, ModuleInfo, FinalInsts),
	modecheck_set_var_inst_list(ArgVars, InitialInsts, FinalInsts,
		NewArgVars, ExtraGoals, ModeInfo1, ModeInfo2),
	( NewArgVars = ArgVars, ExtraGoals = no_extra_goals ->
		true
	;	
		% this shouldn't happen, since modes.m should do
		% all the handling of implied modes
		error("unique_modes.m: call to implied mode?")
	),
	( NeverSucceeds = yes ->
		instmap__init_unreachable(InstMap),
		mode_info_set_instmap(InstMap, ModeInfo2, ModeInfo)
	;
		%
		% Check whether we are at a call to a nondet predicate.
		% If so, mark all the currently nondet-live variables
		% whose inst is `unique' as instead being only `mostly_unique'.
		%
		( CodeModel = model_non ->
			make_all_nondet_live_vars_mostly_uniq(ModeInfo2,
				ModeInfo)
		;
			ModeInfo = ModeInfo2
		)
	).

%-----------------------------------------------------------------------------%

:- pred unique_modes__check_conj(list(hlds_goal), list(hlds_goal),
		mode_info, mode_info).
:- mode unique_modes__check_conj(in, out, mode_info_di, mode_info_uo) is det.

	% Just process each conjunct in turn.
	% Note that we don't do any reordering of conjuncts here.

unique_modes__check_conj([], []) --> [].
unique_modes__check_conj([Goal0 | Goals0], [Goal | Goals]) -->
	{ unique_modes__goal_get_nonlocals(Goal0, NonLocals) },
	mode_info_remove_live_vars(NonLocals),
	unique_modes__check_goal(Goal0, Goal),
	unique_modes__check_conj(Goals0, Goals).

%-----------------------------------------------------------------------------%

:- pred unique_modes__check_par_conj(list(hlds_goal), list(hlds_goal),
		list(pair(instmap, set(prog_var))), mode_info, mode_info).
:- mode unique_modes__check_par_conj(in, out, out,
		mode_info_di, mode_info_uo) is det.

	% Just process each conjunct in turn.
	% Because we have already done modechecking, we know that
	% there are no attempts to bind a variable in multiple
	% parallel conjuncts, so we don't need to lock/unlock variables.

unique_modes__check_par_conj([], [], []) --> [].
unique_modes__check_par_conj([Goal0 | Goals0], [Goal | Goals],
		[InstMap - NonLocals|InstMaps]) -->
	{ unique_modes__goal_get_nonlocals(Goal0, NonLocals) },
	mode_info_dcg_get_instmap(InstMap0),
	unique_modes__check_goal(Goal0, Goal),
	mode_info_dcg_get_instmap(InstMap),
	mode_info_set_instmap(InstMap0),
	unique_modes__check_par_conj(Goals0, Goals, InstMaps).

%-----------------------------------------------------------------------------%

	% Process each of the disjunctions in turn, making sure to restore
	% the original instmap before processing the next one.
	% Collect up a list of the resulting instmaps.

:- pred unique_modes__check_disj(list(hlds_goal), list(hlds_goal),
		list(instmap), mode_info, mode_info).
:- mode unique_modes__check_disj(in, out, out, mode_info_di, mode_info_uo)
		is det.

unique_modes__check_disj([], [], []) --> [].
unique_modes__check_disj([Goal0 | Goals0], [Goal | Goals],
		[InstMap | InstMaps]) -->
	mode_info_dcg_get_instmap(InstMap0),
	unique_modes__check_goal(Goal0, Goal),
	mode_info_dcg_get_instmap(InstMap),
	mode_info_set_instmap(InstMap0),
	unique_modes__check_disj(Goals0, Goals, InstMaps).

%-----------------------------------------------------------------------------%

:- pred unique_modes__check_case_list(list(case), prog_var, list(case),
		list(instmap), mode_info, mode_info).
:- mode unique_modes__check_case_list(in, in, out, out,
		mode_info_di, mode_info_uo) is det.

unique_modes__check_case_list([], _Var, [], []) --> [].
unique_modes__check_case_list([Case0 | Cases0], Var,
			[Case | Cases], [InstMap | InstMaps]) -->
	{ Case0 = case(ConsId, Goal0) },
	{ Case = case(ConsId, Goal) },
	mode_info_dcg_get_instmap(InstMap0),

		% record the fact that Var was bound to ConsId in the
		% instmap before processing this case
	{ cons_id_arity(ConsId, Arity) },
	{ list__duplicate(Arity, free, ArgInsts) },
	modecheck_set_var_inst(Var,
		bound(unique, [functor(ConsId, ArgInsts)])),

	unique_modes__check_goal(Goal0, Goal1),
	mode_info_dcg_get_instmap(InstMap),
	{ fixup_switch_var(Var, InstMap0, InstMap, Goal1, Goal) },
	mode_info_set_instmap(InstMap0),
	unique_modes__check_case_list(Cases0, Var, Cases, InstMaps).

%-----------------------------------------------------------------------------%

:- pred unique_modes__goal_get_nonlocals(hlds_goal, set(prog_var)).
:- mode unique_modes__goal_get_nonlocals(in, out) is det.

unique_modes__goal_get_nonlocals(_Goal - GoalInfo, NonLocals) :-
	goal_info_get_nonlocals(GoalInfo, NonLocals).

%-----------------------------------------------------------------------------%