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

:- module inlining.
% Main author: conway.

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

:- interface.
:- import_module hlds, llds.

:- pred inlining(module_info, module_info).
:- mode inlining(in, out) is det.

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

:- implementation.
:- import_module list, map, set, std_util.
:- import_module mode_util, term, require.
:- import_module varset, code_aux, prog_io.

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

	% Traverse the module structure, calling `inlining__do_inlining'
	% for each procedure body.

inlining(ModuleInfo0, ModuleInfo1) :-
	module_info_predids(ModuleInfo0, PredIds),
	inlining_in_preds(PredIds, ModuleInfo0, ModuleInfo1).

:- pred inlining_in_preds(list(pred_id), module_info, module_info).
:- mode inlining_in_preds(in, in, out) is det.

inlining_in_preds([], ModuleInfo, ModuleInfo).
inlining_in_preds([PredId | PredIds], ModuleInfo0, ModuleInfo) :-
	module_info_preds(ModuleInfo0, PredTable),
	map__lookup(PredTable, PredId, PredInfo),
	( pred_info_is_imported(PredInfo) ->
		ModuleInfo1 = ModuleInfo0
	;
		pred_info_procids(PredInfo, ProcIds),
		inlining_in_procs(ProcIds, PredId, ModuleInfo0,
			ModuleInfo1)
	),
	inlining_in_preds(PredIds, ModuleInfo1, ModuleInfo).

:- pred inlining_in_procs(list(proc_id), pred_id, module_info,
					module_info).
:- mode inlining_in_procs(in, in, in, out) is det.

inlining_in_procs([], _PredId, ModuleInfo, ModuleInfo).
inlining_in_procs([ProcId | ProcIds], PredId, ModuleInfo0,
					ModuleInfo) :-
	module_info_preds(ModuleInfo0, PredTable0),
	map__lookup(PredTable0, PredId, PredInfo0),
	pred_info_procedures(PredInfo0, ProcTable0),
	map__lookup(ProcTable0, ProcId, ProcInfo0),

	proc_info_goal(ProcInfo0, Goal0),
	proc_info_variables(ProcInfo0, Varset0),
	proc_info_vartypes(ProcInfo0, VarTypes0),

	inlining__inlining_in_goal(Goal0, Varset0, VarTypes0, ModuleInfo0,
		Goal, Varset, VarTypes),

	proc_info_set_variables(ProcInfo0, Varset, ProcInfo1),
	proc_info_set_vartypes(ProcInfo1, VarTypes, ProcInfo2),
	proc_info_set_goal(ProcInfo2, Goal, ProcInfo),

	map__set(ProcTable0, ProcId, ProcInfo, ProcTable),
	pred_info_set_procedures(PredInfo0, ProcTable, PredInfo),
	map__set(PredTable0, PredId, PredInfo, PredTable),
	module_info_set_preds(ModuleInfo0, PredTable, ModuleInfo1),
	inlining_in_procs(ProcIds, PredId, ModuleInfo1, ModuleInfo).

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

:- pred inlining__inlining_in_goal(hlds__goal, varset, map(var, type),
			module_info, hlds__goal, varset, map(var, type)).
:- mode inlining__inlining_in_goal(in, in, in, in, out, out, out) is det.

inlining__inlining_in_goal(Goal0 - GoalInfo, Varset0, VarTypes0, ModuleInfo,
		Goal - GoalInfo, Varset, VarTypes) :-
	inlining__inlining_in_goal_2(Goal0, Varset0, VarTypes0, ModuleInfo,
		Goal, Varset, VarTypes).

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

:- pred inlining__inlining_in_goal_2(hlds__goal_expr, varset, map(var, type),
		module_info, hlds__goal_expr, varset, map(var, type)).
:- mode inlining__inlining_in_goal_2(in, in, in, in, out, out, out) is det.

inlining__inlining_in_goal_2(conj(Goals0), Varset0, VarTypes0, ModuleInfo,
		conj(Goals), Varset, VarTypes) :-
	inlining__inlining_in_conj(Goals0, Varset0, VarTypes0, ModuleInfo,
		Goals, Varset, VarTypes).

inlining__inlining_in_goal_2(disj(Goals0), Varset0, VarTypes0, ModuleInfo,
		disj(Goals), Varset, VarTypes) :-
	inlining__inlining_in_disj(Goals0, Varset0, VarTypes0, ModuleInfo,
		Goals, Varset, VarTypes).

inlining__inlining_in_goal_2(switch(Var, Det, Cases0), Varset0, VarTypes0,
		ModuleInfo, switch(Var, Det, Cases), Varset, VarTypes) :-
	inlining__inlining_in_cases(Cases0, Varset0, VarTypes0, ModuleInfo,
		Cases, Varset, VarTypes).

inlining__inlining_in_goal_2(if_then_else(Vars, Cond0, Then0, Else0), Varset0,
		VarTypes0, ModuleInfo, if_then_else(Vars, Cond, Then, Else),
		Varset, VarTypes) :-
	inlining__inlining_in_goal(Cond0, Varset0, VarTypes0, ModuleInfo,
		Cond, Varset1, VarTypes1),
	inlining__inlining_in_goal(Then0, Varset1, VarTypes1, ModuleInfo,
		Then, Varset2, VarTypes2),
	inlining__inlining_in_goal(Else0, Varset2, VarTypes2, ModuleInfo,
		Else, Varset, VarTypes).

inlining__inlining_in_goal_2(not(Goal0), Varset0, VarTypes0, ModuleInfo,
		not(Goal), Varset, VarTypes) :-
	inlining__inlining_in_goal(Goal0, Varset0, VarTypes0, ModuleInfo,
		Goal, Varset, VarTypes).

inlining__inlining_in_goal_2(some(Vars, Goal0), Varset0, VarTypes0, ModuleInfo,
		some(Vars, Goal), Varset, VarTypes) :-
	inlining__inlining_in_goal(Goal0, Varset0, VarTypes0, ModuleInfo,
		Goal, Varset, VarTypes).

inlining__inlining_in_goal_2(
		call(PredId, ProcId, Args, Builtin, SymName, Follow),
		Varset0, VarTypes0, ModuleInfo, Goal, Varset, VarTypes) :-
	(
		\+ is_builtin__is_internal(Builtin),
        	module_info_preds(ModuleInfo, Preds),
        	map__lookup(Preds, PredId, PredInfo),
		\+ pred_info_is_imported(PredInfo),
        	pred_info_procedures(PredInfo, Procs),
        	map__lookup(Procs, ProcId, ProcInfo),
        	proc_info_goal(ProcInfo, CalledGoal),
			% this heuristic could be improved
		code_aux__contains_only_builtins(CalledGoal),
		code_aux__goal_is_flat(CalledGoal)
	->
		proc_info_headvars(ProcInfo, HeadVars),
        	proc_info_variables(ProcInfo, PVarset),
		proc_info_vartypes(ProcInfo, CVarTypes),
		varset__vars(PVarset, Vars0),
		term__vars_list(Args, ArgVars),
		map__init(Subn0),
		assoc_list__from_corresponding_lists(ArgVars, HeadVars, ArgSub),
		inlining__init_subn(ArgSub, Subn0, Subn1),
		inlining__create_variables(Vars0, Varset0, VarTypes0,
			Subn1, CVarTypes, Varset, VarTypes, Subn),
		inlining__name_apart(CalledGoal, Subn, Goal - _GoalInfo)
	;
		Goal = call(PredId, ProcId, Args, Builtin, SymName, Follow),
		Varset = Varset0,
		VarTypes = VarTypes0
	).

inlining__inlining_in_goal_2(unify(A,B,C,D,E), Varset, VarTypes, _,
					unify(A,B,C,D,E), Varset, VarTypes).

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

:- pred inlining__inlining_in_disj(list(hlds__goal), varset, map(var, type),
			module_info, list(hlds__goal), varset, map(var, type)).
:- mode inlining__inlining_in_disj(in, in, in, in, out, out, out) is det.

inlining__inlining_in_disj([], Varset, VarTypes, _ModuleInfo,
				[], Varset, VarTypes).
inlining__inlining_in_disj([Goal0|Goals0], Varset0, VarTypes0, ModuleInfo,
		[Goal|Goals], Varset, VarTypes) :-
	inlining__inlining_in_goal(Goal0, Varset0, VarTypes0, ModuleInfo,
		Goal, Varset1, VarTypes1),
	inlining__inlining_in_disj(Goals0, Varset1, VarTypes1, ModuleInfo,
		Goals, Varset, VarTypes).

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

:- pred inlining__inlining_in_cases(list(case), varset, map(var, type), module_info,
		list(case), varset, map(var, type)).
:- mode inlining__inlining_in_cases(in, in, in, in, out, out, out) is det.

inlining__inlining_in_cases([], Varset, VarTypes, _ModuleInfo,
		[], Varset, VarTypes).
inlining__inlining_in_cases([case(Cons, Goal0)|Goals0], Varset0, VarTypes0,
		ModuleInfo, [case(Cons, Goal)|Goals], Varset, VarTypes) :-
	inlining__inlining_in_goal(Goal0, Varset0, VarTypes0, ModuleInfo,
		Goal, Varset1, VarTypes1),
	inlining__inlining_in_cases(Goals0, Varset1, VarTypes1, ModuleInfo,
		Goals, Varset, VarTypes).

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

:- pred inlining__inlining_in_conj(list(hlds__goal), varset, map(var, type),
		module_info, list(hlds__goal), varset, map(var, type)).
:- mode inlining__inlining_in_conj(in, in, in, in, out, out, out) is det.

	% Since a single goal may become a conjunction,
	% we flatten the conjunction as we go.

inlining__inlining_in_conj([], Varset, VarTypes, _ModuleInfo,
		[], Varset, VarTypes).
inlining__inlining_in_conj([Goal0 | Goals0], Varset0, VarTypes0, ModuleInfo,
		Goals, Varset, VarTypes) :-
	inlining__inlining_in_goal(Goal0, Varset0, VarTypes0, ModuleInfo,
		Goal1, Varset1, VarTypes1),
	goal_to_conj_list(Goal1, Goal1List),
	inlining__inlining_in_conj(Goals0, Varset1, VarTypes1, ModuleInfo,
		Goals1, Varset, VarTypes),
	list__append(Goal1List, Goals1, Goals).

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

:- pred inlining__create_variables(list(var), varset,
		map(var, type), map(var, var), map(var, type),
				varset, map(var, type), map(var, var)).
:- mode inlining__create_variables(in, in, in, in, in, out, out, out) is det.

inlining__create_variables([], Varset, VarTypes, Subn, _CVars,
		Varset, VarTypes, Subn).
inlining__create_variables([V|Vs], Varset0, VarTypes0, Subn0, CVars,
		Varset, VarTypes, Subn) :-
	(
		map__contains(Subn0, V)
	->
		NV = V,
		Varset1 = Varset0,
		Subn1 = Subn0,
		VarTypes1 = VarTypes0
	;
		varset__new_var(Varset0, NV, Varset1),
		map__set(Subn0, V, NV, Subn1),
		map__lookup(CVars, V, VT),
		map__set(VarTypes0, NV, VT, VarTypes1)
	),
	inlining__create_variables(Vs, Varset1, VarTypes1, Subn1, CVars,
		Varset, VarTypes, Subn).

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

:- pred inlining__init_subn(assoc_list(var, var), map(var, var), map(var, var)).
:- mode inlining__init_subn(in, in, out) is det.

inlining__init_subn([], Subn, Subn).
inlining__init_subn([A-H|Vs], Subn0, Subn) :-
	map__set(Subn0, H, A, Subn1),
	inlining__init_subn(Vs, Subn1, Subn).

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

:- pred inlining__rename_var_list(list(var), map(var, var), list(var)).
:- mode inlining__rename_var_list(in, in, out) is det.

inlining__rename_var_list([], _Subn, []).
inlining__rename_var_list([V|Vs], Subn, [N|Ns]) :-
	map__lookup(Subn, V, N),
	inlining__rename_var_list(Vs, Subn, Ns).

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

:- pred inlining__name_apart(hlds__goal, map(var, var), hlds__goal).
:- mode inlining__name_apart(in, in, out) is det.

inlining__name_apart(Goal0 - GoalInfo0, Subn, Goal - GoalInfo) :-
	inlining__name_apart_2(Goal0, Subn, Goal),
	inlining__name_apart_goalinfo(GoalInfo0, Subn, GoalInfo).

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

:- pred inlining__name_apart_2(hlds__goal_expr, map(var, var), hlds__goal_expr).
:- mode inlining__name_apart_2(in, in, out) is det.

inlining__name_apart_2(conj(Goals0), Subn, conj(Goals)) :-
	inlining__name_apart_list(Goals0, Subn, Goals).

inlining__name_apart_2(disj(Goals0), Subn, disj(Goals)) :-
	inlining__name_apart_list(Goals0, Subn, Goals).

inlining__name_apart_2(switch(Var0, Det, Cases0), Subn,
						switch(Var, Det, Cases)) :-
	map__lookup(Subn, Var0, Var),
	inlining__name_apart_cases(Cases0, Subn, Cases).

inlining__name_apart_2(if_then_else(Vars0, Cond0, Then0, Else0), Subn,
				if_then_else(Vars, Cond, Then, Else)) :-
	inlining__rename_var_list(Vars0, Subn, Vars),
	inlining__name_apart(Cond0, Subn, Cond),
	inlining__name_apart(Then0, Subn, Then),
	inlining__name_apart(Else0, Subn, Else).

inlining__name_apart_2(not(Goal0), Subn, not(Goal)) :-
	inlining__name_apart(Goal0, Subn, Goal).

inlining__name_apart_2(some(Vars0, Goal0), Subn, some(Vars, Goal)) :-
	inlining__rename_var_list(Vars0, Subn, Vars),
	inlining__name_apart(Goal0, Subn, Goal).

inlining__name_apart_2(
		call(PredId, ProcId, Args0, Builtin, SymName, Follow0), Subn,
		call(PredId, ProcId, Args, Builtin, SymName, Follow)) :-
	inlining__rename_args(Args0, Subn, Args),
	inlining__rename_follow_vars(Follow0, Subn, Follow).

inlining__name_apart_2(unify(TermL0,TermR0,Mode,Unify0,Context), Subn,
		unify(TermL,TermR,Mode,Unify,Context)) :-
	inlining__rename_term(TermL0, Subn, TermL),
	inlining__rename_term(TermR0, Subn, TermR),
	inlining__rename_unify(Unify0, Subn, Unify).

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

:- pred inlining__name_apart_list(list(hlds__goal), map(var, var),
							list(hlds__goal)).
:- mode inlining__name_apart_list(in, in, out) is det.

inlining__name_apart_list([], _Subn, []).
inlining__name_apart_list([G0|Gs0], Subn, [G|Gs]) :-
	inlining__name_apart(G0, Subn, G),
	inlining__name_apart_list(Gs0, Subn, Gs).

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

:- pred inlining__name_apart_cases(list(case), map(var, var), list(case)).
:- mode inlining__name_apart_cases(in, in, out) is det.

inlining__name_apart_cases([], _Subn, []).
inlining__name_apart_cases([case(Cons, G0)|Gs0], Subn, [case(Cons, G)|Gs]) :-
	inlining__name_apart(G0, Subn, G),
	inlining__name_apart_cases(Gs0, Subn, Gs).

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

:- pred inlining__rename_args(list(term), map(var, var), list(term)).
:- mode inlining__rename_args(in, in, out) is det.

inlining__rename_args([], _Subn, []).
inlining__rename_args([T0|Ts0], Subn, [T|Ts]) :-
	inlining__rename_term(T0, Subn, T),
	inlining__rename_args(Ts0, Subn, Ts).

:- pred inlining__rename_term(term, map(var, var), term).
:- mode inlining__rename_term(in, in, out) is det.

inlining__rename_term(term__variable(V), Subn, term__variable(N)) :-
	map__lookup(Subn, V, N).
inlining__rename_term(term__functor(Cons, Terms0, Cont), Subn,
				term__functor(Cons, Terms, Cont)) :-
	inlining__rename_args(Terms0, Subn, Terms).

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

:- pred inlining__rename_unify(unification, map(var, var), unification).
:- mode inlining__rename_unify(in, in, out) is det.

inlining__rename_unify(construct(Var0, ConsId, Vars0, Modes), Subn,
			construct(Var, ConsId, Vars, Modes)) :-
	map__lookup(Subn, Var0, Var),
	inlining__rename_var_list(Vars0, Subn, Vars).
inlining__rename_unify(deconstruct(Var0, ConsId, Vars0, Modes, Cat), Subn,
			deconstruct(Var, ConsId, Vars, Modes, Cat)) :-
	map__lookup(Subn, Var0, Var),
	inlining__rename_var_list(Vars0, Subn, Vars).
inlining__rename_unify(assign(L0, R0), Subn, assign(L, R)) :-
	map__lookup(Subn, L0, L),
	map__lookup(Subn, R0, R).
inlining__rename_unify(simple_test(L0, R0), Subn, simple_test(L, R)) :-
	map__lookup(Subn, L0, L),
	map__lookup(Subn, R0, R).
inlining__rename_unify(complicated_unify(Modes, Cat, Follow0), Subn,
			complicated_unify(Modes, Cat, Follow)) :-
	inlining__rename_follow_vars(Follow0, Subn, Follow).

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

:- pred inlining__rename_follow_vars(map(var, T), map(var, var), map(var, T)).
:- mode inlining__rename_follow_vars(in, in, out) is det.

inlining__rename_follow_vars(Follow0, Subn, Follow) :-
	map__to_assoc_list(Follow0, FollowList0),
	inlining__rename_follow_vars_2(FollowList0, Subn, FollowList),
	map__from_assoc_list(FollowList, Follow).

:- pred inlining__rename_follow_vars_2(assoc_list(var, T),
				map(var, var), assoc_list(var, T)).
:- mode inlining__rename_follow_vars_2(in, in, out) is det.

inlining__rename_follow_vars_2([], _Subn, []).
inlining__rename_follow_vars_2([V - L | Vs], Subn, [N - L | Ns]) :-
	map__lookup(Subn, V, N),
	inlining__rename_follow_vars_2(Vs, Subn, Ns).

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

:- pred inlining__name_apart_goalinfo(hlds__goal_info,
					map(var, var), hlds__goal_info).
:- mode inlining__name_apart_goalinfo(in, in, out) is det.

inlining__name_apart_goalinfo(GoalInfo0, Subn, GoalInfo) :-
	goal_info_pre_delta_liveness(GoalInfo0, PreBirths0 - PreDeaths0),
	inlining__name_apart_set(PreBirths0, Subn, PreBirths),
	inlining__name_apart_set(PreDeaths0, Subn, PreDeaths),
	goal_info_set_pre_delta_liveness(GoalInfo0, PreBirths - PreDeaths,
						GoalInfo1),

	goal_info_post_delta_liveness(GoalInfo1, PostBirths0 - PostDeaths0),
	inlining__name_apart_set(PostBirths0, Subn, PostBirths),
	inlining__name_apart_set(PostDeaths0, Subn, PostDeaths),
	goal_info_set_pre_delta_liveness(GoalInfo1, PostBirths - PostDeaths,
						GoalInfo2),

	goal_info_get_nonlocals(GoalInfo2, NonLocals0),
	inlining__name_apart_set(NonLocals0, Subn, NonLocals),
	goal_info_set_nonlocals(GoalInfo2, NonLocals, GoalInfo3),

	goal_info_get_instmap_delta(GoalInfo3, MaybeInstMap0),
	(
		MaybeInstMap0 = reachable(InstMap0)
	->
		inlining__rename_follow_vars(InstMap0, Subn, InstMap),
		MaybeInstMap = reachable(InstMap)
	;
		MaybeInstMap = MaybeInstMap0
	),
	goal_info_set_instmap_delta(GoalInfo3, MaybeInstMap, GoalInfo4),

	goal_info_store_map(GoalInfo4, MaybeStoreMap0),
	(
		MaybeStoreMap0 = yes(StoreMap0)
	->
		inlining__rename_follow_vars(StoreMap0, Subn, StoreMap),
		MaybeStoreMap = yes(StoreMap)
	;
		MaybeStoreMap = MaybeStoreMap0
	),
	goal_info_set_store_map(GoalInfo4, MaybeStoreMap, GoalInfo).

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

:- pred inlining__name_apart_set(set(var), map(var, var), set(var)).
:- mode inlining__name_apart_set(in, in, out) is det.

inlining__name_apart_set(Vars0, Subn, Vars) :-
	set__to_sorted_list(Vars0, VarsList0),
	inlining__rename_var_list(VarsList0, Subn, VarsList),
	set__list_to_set(VarsList, Vars).

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