mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-17 02:13:54 +00:00
155bc71d72
compiler/prog_item.m:
Change foreign_procs from being one kind of impl_pragma item
to being their own item kind. Because of this, the changes to
some of the modules listed below delete "pragma" from the names
of predicates and types referring to foreign_procs.
Include foreign_proc items in parse_tree_module_srcs and
parse_tree_plain_opts, the two kinds of parse trees that may contain
foreign_procs.
compiler/make_hlds_separate_items.m:
Gather foreign procs independently of impl pragmas.
compiler/make_hlds_passes.m:
Add foreign_procs from the parse_tree_module_src and any
parse_tree_plain_opts to the HLDS at the same time as we add
foreign_procs generated by the compiler to implement solver types
and mutables. Document the reason for this.
Document also the reason why we should add all marker pragmas
just before we do this. Document the reason why two tests will fail
until that, or something similar, is done.
compiler/add_foreign_proc.m:
Delete a test that was required only because we couldn't guarantee
the relative order of adding foreign_procs and pragmas that mark
predicates as external on one backend.
compiler/module_qual.qual_errors.m:
Add foreign_procs as a possible context for errors during qualification.
compiler/status.m:
Add a comment documented an old issue.
compiler/add_mutable_aux_preds.m:
compiler/add_pragma.m:
compiler/add_pragma_tabling.m:
compiler/add_solver.m:
compiler/check_module_interface.m:
compiler/comp_unit_interface.m:
compiler/convert_parse_tree.m:
compiler/coverage_profiling.m:
compiler/dep_par_conj.m:
compiler/det_analysis.m:
compiler/equiv_type.m:
compiler/foreign.m:
compiler/get_dependencies.m:
compiler/goal_util.m:
compiler/grab_modules.m:
compiler/hlds_goal.m:
compiler/intermod.m:
compiler/item_util.m:
compiler/ml_foreign_proc_gen.m:
compiler/module_qual.collect_mq_info.m:
compiler/module_qual.qualify_items.m:
compiler/parse_pragma_foreign.m:
compiler/parse_tree_out.m:
compiler/parse_tree_out_pragma.m:
compiler/pragma_c_gen.m:
compiler/prog_item_stats.m:
compiler/prog_mutable.m:
compiler/recompilation.version.m:
compiler/structure_sharing.domain.m:
compiler/table_gen.m:
compiler/tabling_analysis.m:
compiler/term_util.m:
compiler/termination.m:
compiler/trailing_analysis.m:
compiler/prog_data_foreign.m:
compiler/unify_proc.m:
Conform to the changes above.
773 lines
31 KiB
Mathematica
773 lines
31 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% vim: ts=4 sw=4 expandtab ft=mercury
|
|
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 2015 The Mercury team.
|
|
% This file may only be copied under the terms of the GNU General
|
|
% Public License - see the file COPYING in the Mercury distribution.
|
|
%-----------------------------------------------------------------------------%
|
|
%
|
|
% This module defines the type that holds the status of six kinds of
|
|
% HLDS entities; types, insts, modes, typeclasses, instances and predicates.
|
|
%
|
|
% XXX The old import_status type applied to every one of these entity kinds,
|
|
% even though these have different visibility rules. (For example, types can be
|
|
% abstract-exported, but predicates cannot.)
|
|
%
|
|
% There is an accepted design for replacing this single status type with
|
|
% with a set of entity-kind-specific types, which avoids this confusion.
|
|
% This design is also more structured, in that it has separate fields recording
|
|
% the answers to separate questions, instead of flattening out all possible
|
|
% combinations of answers into an enum. For the details, see status_proposal
|
|
% in compiler/notes.
|
|
%
|
|
% We have made the first step towards implementing this proposal. Each kind
|
|
% of entity now has its own status type, but they are (for now) only wrappers
|
|
% around the old_import_status type. Later, they will be specialized to their
|
|
% unique needs.
|
|
%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module hlds.status.
|
|
:- interface.
|
|
|
|
:- import_module parse_tree.
|
|
:- import_module parse_tree.prog_item.
|
|
|
|
:- import_module bool.
|
|
|
|
:- type maybe_opt_imported
|
|
---> is_not_opt_imported
|
|
; is_opt_imported.
|
|
|
|
:- type type_status
|
|
---> type_status(old_import_status).
|
|
|
|
:- type inst_status
|
|
---> inst_status(new_instmode_status).
|
|
|
|
:- type mode_status
|
|
---> mode_status(new_instmode_status).
|
|
|
|
% NOTE Any replacement for this type should take into account
|
|
% the possibility that a predicate may be declared to be external
|
|
% for one backend, while being actually defined, by either clauses
|
|
% or foreign_procs, for another backend.
|
|
:- type pred_status
|
|
---> pred_status(old_import_status).
|
|
|
|
:- type typeclass_status
|
|
---> typeclass_status(old_import_status).
|
|
|
|
:- type instance_status
|
|
---> instance_status(old_import_status).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% The type that should represent the import/export status of both
|
|
% insts and modes, once we transition away from using old_import_status.
|
|
:- type new_instmode_status
|
|
---> instmode_defined_in_this_module(
|
|
instmode_export
|
|
)
|
|
; instmode_defined_in_other_module(
|
|
instmode_import
|
|
).
|
|
|
|
:- type instmode_export
|
|
---> instmode_export_nowhere
|
|
; instmode_export_only_submodules
|
|
; instmode_export_anywhere.
|
|
|
|
:- type instmode_import
|
|
---> instmode_import_plain
|
|
% This inst or mode is defined in a module that was imported
|
|
% by either the current module, or one of its ancestors.
|
|
; instmode_import_abstract
|
|
% This inst or mode is defined in a module (say module C)
|
|
% that was imported in the implementation section of another
|
|
% module (say module B) that was imported by this module (say
|
|
% module A).
|
|
% XXX STATUS These should never be needed, but there is a test
|
|
% case (just one, valid_seq/tc_map_lookup), that does create
|
|
% insts with such a status, though it does not seem to use them.
|
|
% NOTE We never store insts or modes in abstract form:
|
|
% we either store the full definition, or nothing.
|
|
; instmode_import_opt.
|
|
% This inst or mode was read in from either
|
|
% (a) the .opt or .trans_opt file of another module, or
|
|
% (b) an interface file that was read to make sense
|
|
% of a .opt or .trans_opt file.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% The type `old_import_status' describes whether an entity (a predicate,
|
|
% type, inst, or mode) is local to the current module, exported from
|
|
% the current module, or imported from some other module.
|
|
% Only predicates can have status pseudo_exported or pseudo_imported.
|
|
% Only types can have status abstract_exported or abstract_imported.
|
|
%
|
|
|
|
:- type old_import_status
|
|
---> status_external(old_import_status)
|
|
% Declared `:- external'. This means that the implementation
|
|
% for this procedure will be provided by some external source,
|
|
% rather than via Mercury clauses (including `pragma
|
|
% foreign_code' clauses). It can be through the use of another
|
|
% language, or it could be through some other method we haven't
|
|
% thought of yet.
|
|
%
|
|
% From the point of view of code generation, an external
|
|
% procedure usually acts like an imported procedure, as its
|
|
% definition is not visible. But in some cases, e.g. writing
|
|
% out declarations for procedures defined in a module, it may
|
|
% need to be treated like an exported procedure (depending on
|
|
% its inner old_import_status).
|
|
|
|
; status_imported(import_locn)
|
|
% Defined in the interface of some other module.
|
|
|
|
; status_opt_imported
|
|
% Defined in the optimization interface of another module.
|
|
|
|
; status_abstract_imported
|
|
% Describes a type with only an abstract declaration imported,
|
|
% maybe with the body of the type imported from a .opt file.
|
|
|
|
; status_pseudo_imported
|
|
% This is used for entities that are defined in the interface
|
|
% of some other module but for which we may generate some code
|
|
% in this module - in particular, this is used for unification
|
|
% predicates (see comments in unify_proc.m).
|
|
|
|
; status_exported
|
|
% Defined in the interface of this module.
|
|
|
|
; status_opt_exported
|
|
% A local item for which the import-status has been changed
|
|
% due to its presence in the .opt files
|
|
% (intermod.adjust_pred_import_status).
|
|
|
|
; status_abstract_exported
|
|
% Describes a type with only an abstract declaration exported
|
|
% to non-submodules. The definition of the type is exported to
|
|
% submodules.
|
|
|
|
; status_pseudo_exported
|
|
% The converse of pseudo_imported; this means that only the
|
|
% (in, in) mode of a unification is exported.
|
|
|
|
; status_exported_to_submodules
|
|
% Defined in the implementation of this module, and thus in
|
|
% a sense local, but the module contains submodules, so the
|
|
% entity needs to be exported to those submodules.
|
|
|
|
; status_local.
|
|
% Defined in the implementation of this module, and the module
|
|
% does not contain any submodules.
|
|
|
|
% Returns yes if the status indicates that the item was in any way exported
|
|
% -- that is, if it could be used by any other module, or by submodules
|
|
% of this module.
|
|
%
|
|
% NOTE: this returns `no' for :- external procedures.
|
|
%
|
|
% See also `procedure_is_exported'.
|
|
%
|
|
:- func type_status_is_exported(type_status) = bool.
|
|
:- func inst_status_is_exported(inst_status) = bool.
|
|
:- func mode_status_is_exported(mode_status) = bool.
|
|
:- func pred_status_is_exported(pred_status) = bool.
|
|
:- func typeclass_status_is_exported(typeclass_status) = bool.
|
|
:- func instance_status_is_exported(instance_status) = bool.
|
|
|
|
:- func old_status_is_exported(old_import_status) = bool.
|
|
|
|
% Returns yes if the status indicates that the item was exported
|
|
% to importing modules (not just to submodules).
|
|
%
|
|
% NOTE: this returns `no' for :- external procedures.
|
|
%
|
|
:- func type_status_is_exported_to_non_submodules(type_status) = bool.
|
|
:- func inst_status_is_exported_to_non_submodules(inst_status) = bool.
|
|
:- func mode_status_is_exported_to_non_submodules(mode_status) = bool.
|
|
:- func pred_status_is_exported_to_non_submodules(pred_status) = bool.
|
|
:- func typeclass_status_is_exported_to_non_submodules(typeclass_status)
|
|
= bool.
|
|
:- func instance_status_is_exported_to_non_submodules(instance_status) = bool.
|
|
|
|
% Returns yes if the status indicates that the item was in any way imported
|
|
% -- that is, if it was defined in some other module, or in a submodule
|
|
% of this module. This is the opposite of status_defined_in_this_module.
|
|
%
|
|
% NOTE: this returns `yes' for :- external procedures.
|
|
%
|
|
:- func type_status_is_imported(type_status) = bool.
|
|
:- func inst_status_is_imported(inst_status) = bool.
|
|
:- func mode_status_is_imported(mode_status) = bool.
|
|
:- func pred_status_is_imported(pred_status) = bool.
|
|
:- func typeclass_status_is_imported(typeclass_status) = bool.
|
|
:- func instance_status_is_imported(instance_status) = bool.
|
|
|
|
% Returns yes if the status indicates that the item was defined in this
|
|
% module. This is the opposite of status_is_imported.
|
|
%
|
|
% NOTE: this returns `no' for :- external procedures.
|
|
%
|
|
:- func type_status_defined_in_this_module(type_status) = bool.
|
|
:- func inst_status_defined_in_this_module(inst_status) = bool.
|
|
:- func mode_status_defined_in_this_module(mode_status) = bool.
|
|
:- func pred_status_defined_in_this_module(pred_status) = bool.
|
|
:- func typeclass_status_defined_in_this_module(typeclass_status) = bool.
|
|
:- func instance_status_defined_in_this_module(instance_status) = bool.
|
|
|
|
% Returns yes if the status indicates the item came from
|
|
% the implementation section.
|
|
%
|
|
:- func type_status_defined_in_impl_section(type_status) = bool.
|
|
:- func inst_status_defined_in_impl_section(inst_status) = bool.
|
|
:- func mode_status_defined_in_impl_section(mode_status) = bool.
|
|
:- func pred_status_defined_in_impl_section(pred_status) = bool.
|
|
:- func typeclass_status_defined_in_impl_section(typeclass_status) = bool.
|
|
:- func instance_status_defined_in_impl_section(instance_status) = bool.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred type_make_status_abstract(type_status::in, type_status::out) is det.
|
|
:- pred pred_make_status_abstract(pred_status::in, pred_status::out) is det.
|
|
:- pred typeclass_make_status_abstract(typeclass_status::in,
|
|
typeclass_status::out) is det.
|
|
:- pred instance_make_status_abstract(instance_status::in,
|
|
instance_status::out) is det.
|
|
|
|
% XXX Document me.
|
|
%
|
|
:- pred type_combine_status(type_status::in, type_status::in,
|
|
type_status::out) is det.
|
|
:- pred pred_combine_status(pred_status::in, pred_status::in,
|
|
pred_status::out) is det.
|
|
:- pred typeclass_combine_status(typeclass_status::in, typeclass_status::in,
|
|
typeclass_status::out) is det.
|
|
:- pred instance_combine_status(instance_status::in, instance_status::in,
|
|
instance_status::out) is det.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- type item_mercury_status
|
|
---> item_defined_in_this_module(
|
|
item_export
|
|
)
|
|
; item_defined_in_other_module(
|
|
item_import
|
|
).
|
|
|
|
:- type item_export
|
|
---> item_export_nowhere
|
|
; item_export_only_submodules
|
|
; item_export_anywhere.
|
|
|
|
:- type item_import
|
|
---> item_import_int_concrete(import_locn)
|
|
; item_import_int_abstract
|
|
; item_import_opt_int.
|
|
|
|
:- pred item_mercury_status_to_type_status(item_mercury_status::in,
|
|
type_status::out) is det.
|
|
:- pred item_mercury_status_to_inst_status(item_mercury_status::in,
|
|
inst_status::out) is det.
|
|
:- pred item_mercury_status_to_mode_status(item_mercury_status::in,
|
|
mode_status::out) is det.
|
|
:- pred item_mercury_status_to_typeclass_status(item_mercury_status::in,
|
|
typeclass_status::out) is det.
|
|
:- pred item_mercury_status_to_instance_status(item_mercury_status::in,
|
|
instance_status::out) is det.
|
|
:- pred item_mercury_status_to_pred_status(item_mercury_status::in,
|
|
pred_status::out) is det.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module require.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
type_status_is_exported(type_status(OldStatus)) =
|
|
old_status_is_exported(OldStatus).
|
|
|
|
inst_status_is_exported(InstStatus) = IsExported :-
|
|
InstStatus = inst_status(InstModeStatus),
|
|
IsExported = instmode_status_is_exported(InstModeStatus).
|
|
|
|
mode_status_is_exported(ModeStatus) = IsExported :-
|
|
ModeStatus = mode_status(InstModeStatus),
|
|
IsExported = instmode_status_is_exported(InstModeStatus).
|
|
|
|
pred_status_is_exported(pred_status(OldStatus)) =
|
|
old_status_is_exported(OldStatus).
|
|
typeclass_status_is_exported(typeclass_status(OldStatus)) =
|
|
old_status_is_exported(OldStatus).
|
|
instance_status_is_exported(instance_status(OldStatus)) =
|
|
old_status_is_exported(OldStatus).
|
|
|
|
:- func instmode_status_is_exported(new_instmode_status) = bool.
|
|
|
|
instmode_status_is_exported(NewInstModeStatus) = NewIsExported :-
|
|
(
|
|
NewInstModeStatus = instmode_defined_in_this_module(InstModeExport),
|
|
(
|
|
( InstModeExport = instmode_export_anywhere
|
|
; InstModeExport = instmode_export_only_submodules
|
|
),
|
|
NewIsExported = yes
|
|
;
|
|
InstModeExport = instmode_export_nowhere,
|
|
NewIsExported = no
|
|
)
|
|
;
|
|
NewInstModeStatus = instmode_defined_in_other_module(_InstModeImport),
|
|
NewIsExported = no
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
old_status_is_exported(status_imported(_)) = no.
|
|
old_status_is_exported(status_external(_)) = no.
|
|
old_status_is_exported(status_abstract_imported) = no.
|
|
old_status_is_exported(status_pseudo_imported) = no.
|
|
old_status_is_exported(status_opt_imported) = no.
|
|
old_status_is_exported(status_exported) = yes.
|
|
old_status_is_exported(status_opt_exported) = yes.
|
|
old_status_is_exported(status_abstract_exported) = yes.
|
|
old_status_is_exported(status_pseudo_exported) = yes.
|
|
old_status_is_exported(status_exported_to_submodules) = yes.
|
|
old_status_is_exported(status_local) = no.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
type_status_is_exported_to_non_submodules(type_status(Status)) =
|
|
old_status_is_exported_to_non_submodules(Status).
|
|
|
|
inst_status_is_exported_to_non_submodules(InstStatus) = IsExported :-
|
|
InstStatus = inst_status(InstModeStatus),
|
|
IsExported = instmode_status_is_exported_to_non_submodules(InstModeStatus).
|
|
|
|
mode_status_is_exported_to_non_submodules(ModeStatus) = IsExported :-
|
|
ModeStatus = mode_status(InstModeStatus),
|
|
IsExported = instmode_status_is_exported_to_non_submodules(InstModeStatus).
|
|
|
|
pred_status_is_exported_to_non_submodules(pred_status(Status)) =
|
|
old_status_is_exported_to_non_submodules(Status).
|
|
typeclass_status_is_exported_to_non_submodules(typeclass_status(Status)) =
|
|
old_status_is_exported_to_non_submodules(Status).
|
|
instance_status_is_exported_to_non_submodules(instance_status(Status)) =
|
|
old_status_is_exported_to_non_submodules(Status).
|
|
|
|
:- func old_status_is_exported_to_non_submodules(old_import_status) = bool.
|
|
|
|
old_status_is_exported_to_non_submodules(Status) =
|
|
( if
|
|
old_status_is_exported(Status) = yes,
|
|
Status \= status_exported_to_submodules
|
|
then
|
|
yes
|
|
else
|
|
no
|
|
).
|
|
|
|
:- func instmode_status_is_exported_to_non_submodules(new_instmode_status)
|
|
= bool.
|
|
|
|
instmode_status_is_exported_to_non_submodules(NewInstModeStatus)
|
|
= NewIsExported :-
|
|
(
|
|
NewInstModeStatus = instmode_defined_in_this_module(InstModeExport),
|
|
(
|
|
InstModeExport = instmode_export_anywhere,
|
|
NewIsExported = yes
|
|
;
|
|
( InstModeExport = instmode_export_nowhere
|
|
; InstModeExport = instmode_export_only_submodules
|
|
),
|
|
NewIsExported = no
|
|
)
|
|
;
|
|
NewInstModeStatus = instmode_defined_in_other_module(_InstModeImport),
|
|
NewIsExported = no
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
type_status_is_imported(type_status(OldStatus)) =
|
|
old_status_is_imported(OldStatus).
|
|
|
|
inst_status_is_imported(InstStatus) = IsImported :-
|
|
InstStatus = inst_status(InstModeStatus),
|
|
(
|
|
InstModeStatus = instmode_defined_in_this_module(_InstModeExport),
|
|
IsImported = no
|
|
;
|
|
InstModeStatus = instmode_defined_in_other_module(_InstModeImport),
|
|
IsImported = yes
|
|
).
|
|
|
|
mode_status_is_imported(ModeStatus) = IsImported :-
|
|
ModeStatus = mode_status(InstModeStatus),
|
|
(
|
|
InstModeStatus = instmode_defined_in_this_module(_InstModeExport),
|
|
IsImported = no
|
|
;
|
|
InstModeStatus = instmode_defined_in_other_module(_InstModeImport),
|
|
IsImported = yes
|
|
).
|
|
|
|
pred_status_is_imported(pred_status(OldStatus)) =
|
|
old_status_is_imported(OldStatus).
|
|
typeclass_status_is_imported(typeclass_status(OldStatus)) =
|
|
old_status_is_imported(OldStatus).
|
|
instance_status_is_imported(instance_status(OldStatus)) =
|
|
old_status_is_imported(OldStatus).
|
|
|
|
:- func old_status_is_imported(old_import_status) = bool.
|
|
|
|
old_status_is_imported(Status) =
|
|
bool.not(old_status_defined_in_this_module(Status)).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
type_status_defined_in_this_module(type_status(OldStatus)) =
|
|
old_status_defined_in_this_module(OldStatus).
|
|
|
|
inst_status_defined_in_this_module(InstStatus) = IsDefnThisModule :-
|
|
InstStatus = inst_status(InstModeStatus),
|
|
(
|
|
InstModeStatus = instmode_defined_in_this_module(_InstExport),
|
|
IsDefnThisModule = yes
|
|
;
|
|
InstModeStatus = instmode_defined_in_other_module(_InstImport),
|
|
IsDefnThisModule = no
|
|
).
|
|
|
|
mode_status_defined_in_this_module(ModeStatus) = IsDefnThisModule :-
|
|
ModeStatus = mode_status(InstModeStatus),
|
|
(
|
|
InstModeStatus = instmode_defined_in_this_module(_InstExport),
|
|
IsDefnThisModule = yes
|
|
;
|
|
InstModeStatus = instmode_defined_in_other_module(_InstImport),
|
|
IsDefnThisModule = no
|
|
).
|
|
|
|
pred_status_defined_in_this_module(pred_status(OldStatus)) =
|
|
old_status_defined_in_this_module(OldStatus).
|
|
typeclass_status_defined_in_this_module(typeclass_status(OldStatus)) =
|
|
old_status_defined_in_this_module(OldStatus).
|
|
instance_status_defined_in_this_module(instance_status(OldStatus)) =
|
|
old_status_defined_in_this_module(OldStatus).
|
|
|
|
:- func old_status_defined_in_this_module(old_import_status) = bool.
|
|
|
|
old_status_defined_in_this_module(status_imported(_)) = no.
|
|
old_status_defined_in_this_module(status_external(_)) = no.
|
|
old_status_defined_in_this_module(status_abstract_imported) = no.
|
|
old_status_defined_in_this_module(status_pseudo_imported) = no.
|
|
old_status_defined_in_this_module(status_opt_imported) = no.
|
|
old_status_defined_in_this_module(status_exported) = yes.
|
|
old_status_defined_in_this_module(status_opt_exported) = yes.
|
|
old_status_defined_in_this_module(status_abstract_exported) = yes.
|
|
old_status_defined_in_this_module(status_pseudo_exported) = yes.
|
|
old_status_defined_in_this_module(status_exported_to_submodules) = yes.
|
|
old_status_defined_in_this_module(status_local) = yes.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
type_status_defined_in_impl_section(type_status(OldStatus)) =
|
|
old_status_defined_in_impl_section(OldStatus).
|
|
|
|
inst_status_defined_in_impl_section(InstStatus) = IsDefnImplSection :-
|
|
InstStatus = inst_status(InstModeStatus),
|
|
IsDefnImplSection =
|
|
instmode_status_defined_in_impl_section(InstModeStatus).
|
|
|
|
mode_status_defined_in_impl_section(ModeStatus) = IsDefnImplSection :-
|
|
ModeStatus = mode_status(InstModeStatus),
|
|
IsDefnImplSection =
|
|
instmode_status_defined_in_impl_section(InstModeStatus).
|
|
|
|
pred_status_defined_in_impl_section(pred_status(OldStatus)) =
|
|
old_status_defined_in_impl_section(OldStatus).
|
|
typeclass_status_defined_in_impl_section(typeclass_status(OldStatus)) =
|
|
old_status_defined_in_impl_section(OldStatus).
|
|
instance_status_defined_in_impl_section(instance_status(OldStatus)) =
|
|
old_status_defined_in_impl_section(OldStatus).
|
|
|
|
:- func old_status_defined_in_impl_section(old_import_status) = bool.
|
|
|
|
old_status_defined_in_impl_section(status_abstract_exported) = yes.
|
|
old_status_defined_in_impl_section(status_exported_to_submodules) = yes.
|
|
old_status_defined_in_impl_section(status_local) = yes.
|
|
old_status_defined_in_impl_section(status_opt_imported) = no.
|
|
old_status_defined_in_impl_section(status_abstract_imported) = no.
|
|
old_status_defined_in_impl_section(status_pseudo_imported) = no.
|
|
old_status_defined_in_impl_section(status_exported) = no.
|
|
old_status_defined_in_impl_section(status_opt_exported) = yes.
|
|
old_status_defined_in_impl_section(status_pseudo_exported) = no.
|
|
old_status_defined_in_impl_section(status_external(Status)) =
|
|
old_status_defined_in_impl_section(Status).
|
|
old_status_defined_in_impl_section(status_imported(_ImportLocn)) = no.
|
|
|
|
:- func instmode_status_defined_in_impl_section(new_instmode_status) = bool.
|
|
|
|
instmode_status_defined_in_impl_section(NewInstModeStatus)
|
|
= NewIsDefnImplSection :-
|
|
(
|
|
NewInstModeStatus = instmode_defined_in_this_module(InstModeExport),
|
|
(
|
|
( InstModeExport = instmode_export_nowhere
|
|
; InstModeExport = instmode_export_only_submodules
|
|
),
|
|
NewIsDefnImplSection = yes
|
|
;
|
|
InstModeExport = instmode_export_anywhere,
|
|
NewIsDefnImplSection = no
|
|
)
|
|
;
|
|
NewInstModeStatus = instmode_defined_in_other_module(_InstModeImport),
|
|
NewIsDefnImplSection = no
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
type_make_status_abstract(type_status(Status), type_status(AbstractStatus)) :-
|
|
old_make_status_abstract(Status, AbstractStatus).
|
|
pred_make_status_abstract(pred_status(Status), pred_status(AbstractStatus)) :-
|
|
old_make_status_abstract(Status, AbstractStatus).
|
|
typeclass_make_status_abstract(typeclass_status(Status),
|
|
typeclass_status(AbstractStatus)) :-
|
|
old_make_status_abstract(Status, AbstractStatus).
|
|
instance_make_status_abstract(instance_status(Status),
|
|
instance_status(AbstractStatus)) :-
|
|
old_make_status_abstract(Status, AbstractStatus).
|
|
|
|
:- pred old_make_status_abstract(old_import_status::in, old_import_status::out)
|
|
is det.
|
|
|
|
old_make_status_abstract(Status, AbstractStatus) :-
|
|
( if Status = status_exported then
|
|
AbstractStatus = status_abstract_exported
|
|
else if Status = status_imported(_) then
|
|
AbstractStatus = status_abstract_imported
|
|
else
|
|
AbstractStatus = Status
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
type_combine_status(type_status(StatusA), type_status(StatusB),
|
|
type_status(Status)) :-
|
|
old_combine_status(StatusA, StatusB, Status).
|
|
pred_combine_status(pred_status(StatusA), pred_status(StatusB),
|
|
pred_status(Status)) :-
|
|
old_combine_status(StatusA, StatusB, Status).
|
|
typeclass_combine_status(typeclass_status(StatusA), typeclass_status(StatusB),
|
|
typeclass_status(Status)) :-
|
|
old_combine_status(StatusA, StatusB, Status).
|
|
instance_combine_status(instance_status(StatusA), instance_status(StatusB),
|
|
instance_status(Status)) :-
|
|
old_combine_status(StatusA, StatusB, Status).
|
|
|
|
:- pred old_combine_status(old_import_status::in, old_import_status::in,
|
|
old_import_status::out) is det.
|
|
|
|
old_combine_status(StatusA, StatusB, Status) :-
|
|
( if combine_status_2(StatusA, StatusB, CombinedStatus) then
|
|
Status = CombinedStatus
|
|
else
|
|
unexpected($pred, "unexpected status for type definition")
|
|
).
|
|
|
|
:- pred combine_status_2(old_import_status::in, old_import_status::in,
|
|
old_import_status::out) is semidet.
|
|
|
|
combine_status_2(status_imported(ImportLocn), Status2, Status) :-
|
|
require_complete_switch [ImportLocn]
|
|
(
|
|
( ImportLocn = import_locn_implementation
|
|
; ImportLocn = import_locn_interface
|
|
; ImportLocn = import_locn_import_by_ancestor
|
|
),
|
|
combine_status_imported_non_private(Status2, Status)
|
|
;
|
|
ImportLocn = import_locn_ancestor_int0_interface,
|
|
Status = status_imported(import_locn_ancestor_int0_interface)
|
|
;
|
|
ImportLocn = import_locn_ancestor_int0_implementation,
|
|
Status = status_imported(import_locn_ancestor_int0_implementation)
|
|
).
|
|
combine_status_2(status_local, Status2, Status) :-
|
|
combine_status_local(Status2, Status).
|
|
combine_status_2(status_exported, _Status2, status_exported).
|
|
combine_status_2(status_exported_to_submodules, Status2, Status) :-
|
|
combine_status_local(Status2, Status3),
|
|
( if Status3 = status_local then
|
|
Status = status_exported_to_submodules
|
|
else
|
|
Status = Status3
|
|
).
|
|
combine_status_2(status_opt_imported, _Status2, status_opt_imported).
|
|
combine_status_2(status_abstract_imported, Status2, Status) :-
|
|
combine_status_abstract_imported(Status2, Status).
|
|
combine_status_2(status_abstract_exported, Status2, Status) :-
|
|
combine_status_abstract_exported(Status2, Status).
|
|
|
|
:- pred combine_status_imported_non_private(old_import_status::in,
|
|
old_import_status::out) is semidet.
|
|
|
|
combine_status_imported_non_private(Status2, Status) :-
|
|
(
|
|
Status2 = status_imported(Section),
|
|
Status = status_imported(Section)
|
|
;
|
|
Status2 = status_local,
|
|
Status = status_imported(import_locn_implementation)
|
|
;
|
|
Status2 = status_exported,
|
|
Status = status_exported
|
|
;
|
|
Status2 = status_opt_imported,
|
|
Status = status_opt_imported
|
|
;
|
|
Status2 = status_abstract_imported,
|
|
Status = status_imported(import_locn_interface)
|
|
;
|
|
Status2 = status_abstract_exported,
|
|
Status = status_abstract_exported
|
|
).
|
|
|
|
:- pred combine_status_local(old_import_status::in, old_import_status::out)
|
|
is semidet.
|
|
|
|
combine_status_local(status_exported_to_submodules,
|
|
status_exported_to_submodules).
|
|
combine_status_local(status_imported(_), status_local).
|
|
combine_status_local(status_local, status_local).
|
|
combine_status_local(status_exported, status_exported).
|
|
combine_status_local(status_opt_imported, status_local).
|
|
combine_status_local(status_abstract_imported, status_local).
|
|
combine_status_local(status_abstract_exported, status_abstract_exported).
|
|
|
|
:- pred combine_status_abstract_exported(old_import_status::in,
|
|
old_import_status::out) is det.
|
|
|
|
combine_status_abstract_exported(Status2, Status) :-
|
|
( if Status2 = status_exported then
|
|
Status = status_exported
|
|
else
|
|
Status = status_abstract_exported
|
|
).
|
|
|
|
:- pred combine_status_abstract_imported(old_import_status::in,
|
|
old_import_status::out) is det.
|
|
|
|
combine_status_abstract_imported(Status2, Status) :-
|
|
( if Status2 = status_imported(Section) then
|
|
Status = status_imported(Section)
|
|
else
|
|
Status = status_abstract_imported
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
item_mercury_status_to_type_status(ItemMercuryStatus, TypeStatus) :-
|
|
item_mercury_status_to_old_import_status(ItemMercuryStatus,
|
|
OldImportStatus),
|
|
TypeStatus = type_status(OldImportStatus).
|
|
|
|
item_mercury_status_to_inst_status(ItemMercuryStatus, InstStatus) :-
|
|
item_mercury_status_to_instmode_status(ItemMercuryStatus, InstModeStatus),
|
|
InstStatus = inst_status(InstModeStatus).
|
|
|
|
item_mercury_status_to_mode_status(ItemMercuryStatus, ModeStatus) :-
|
|
item_mercury_status_to_instmode_status(ItemMercuryStatus, InstModeStatus),
|
|
ModeStatus = mode_status(InstModeStatus).
|
|
|
|
item_mercury_status_to_typeclass_status(ItemMercuryStatus, TypeClassStatus) :-
|
|
item_mercury_status_to_old_import_status(ItemMercuryStatus,
|
|
OldImportStatus),
|
|
TypeClassStatus = typeclass_status(OldImportStatus).
|
|
|
|
item_mercury_status_to_instance_status(ItemMercuryStatus, InstanceStatus) :-
|
|
item_mercury_status_to_old_import_status(ItemMercuryStatus,
|
|
OldImportStatus),
|
|
InstanceStatus = instance_status(OldImportStatus).
|
|
|
|
item_mercury_status_to_pred_status(ItemMercuryStatus, PredStatus) :-
|
|
item_mercury_status_to_old_import_status(ItemMercuryStatus,
|
|
OldImportStatus),
|
|
PredStatus = pred_status(OldImportStatus).
|
|
|
|
:- pred item_mercury_status_to_instmode_status(item_mercury_status::in,
|
|
new_instmode_status::out) is det.
|
|
|
|
item_mercury_status_to_instmode_status(ItemMercuryStatus, InstModeStatus) :-
|
|
(
|
|
ItemMercuryStatus = item_defined_in_this_module(ItemExport),
|
|
(
|
|
ItemExport = item_export_nowhere,
|
|
InstExport = instmode_export_nowhere
|
|
;
|
|
ItemExport = item_export_only_submodules,
|
|
InstExport = instmode_export_only_submodules
|
|
;
|
|
ItemExport = item_export_anywhere,
|
|
InstExport = instmode_export_anywhere
|
|
),
|
|
InstModeStatus = instmode_defined_in_this_module(InstExport)
|
|
;
|
|
ItemMercuryStatus = item_defined_in_other_module(ItemImport),
|
|
(
|
|
ItemImport = item_import_int_concrete(_ImportLocn),
|
|
InstImport = instmode_import_plain
|
|
;
|
|
ItemImport = item_import_int_abstract,
|
|
InstImport = instmode_import_abstract
|
|
;
|
|
ItemImport = item_import_opt_int,
|
|
InstImport = instmode_import_opt
|
|
),
|
|
InstModeStatus = instmode_defined_in_other_module(InstImport)
|
|
).
|
|
|
|
:- pred item_mercury_status_to_old_import_status(item_mercury_status::in,
|
|
old_import_status::out) is det.
|
|
|
|
item_mercury_status_to_old_import_status(ItemMercuryStatus, OldImportStatus) :-
|
|
(
|
|
ItemMercuryStatus = item_defined_in_this_module(ItemExport),
|
|
(
|
|
ItemExport = item_export_nowhere,
|
|
OldImportStatus = status_local
|
|
;
|
|
ItemExport = item_export_only_submodules,
|
|
OldImportStatus = status_exported_to_submodules
|
|
;
|
|
ItemExport = item_export_anywhere,
|
|
OldImportStatus = status_exported
|
|
)
|
|
;
|
|
ItemMercuryStatus = item_defined_in_other_module(ItemImport),
|
|
(
|
|
ItemImport = item_import_int_concrete(ImportLocn),
|
|
OldImportStatus = status_imported(ImportLocn)
|
|
;
|
|
ItemImport = item_import_int_abstract,
|
|
OldImportStatus = status_abstract_imported
|
|
;
|
|
ItemImport = item_import_opt_int,
|
|
OldImportStatus = status_opt_imported
|
|
)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
:- end_module hlds.status.
|
|
%-----------------------------------------------------------------------------%
|