Include the type_ctor in cons_ids for user-defined types.

Estimated hours taken: 32
Branches: main

Include the type_ctor in cons_ids for user-defined types. The intention is
two-fold:

- It prepares for a future in which we allow more than one function symbol to
  with the same name to be defined in a module.

- It makes the HLDS code more self-contained. In many places, processing
  construction and deconstruction unifications required knowing which type
  the cons_id belongs to, but until now, code couldn't know that unless it
  kept track of the type of the variable unified with the cons_id.

With this diff, user-defined cons_ids are represented as

	cons(SymName, Arity, TypeCtor)

The last field is filled in during post-typecheck. After that time, any module
qualification in the SymName (which may initially be partial) is redundant,
since it is also available in the TypeCtor.

In the future, we could make all those SymNames be just unqualified(_) at that
time. We could also replace the current maps in HLDS type definitions with
full cons_id keys with just name/arity keys (since the module qualifier is a
given for any given type definition), we could also support partially
qualified cons_ids in source code using a map from name/arity pairs to a list
of all the type_ctors that have function symbols with that name/arity, instead
of our current practice of inserting all possible partially module qualified
version of every cons_id into a single giant table, and we could do the same
thing with the field names table.

This diff also separates tuples out from user-defined types, since in many
respects they are different (they don't have a single type_ctor, for starters).
It also separates out character constants, since they were alreay treated
specially in most places, though not in some places where they *ought* to
have been treated specially. Take the opportunity to give some other cons_ids
better names.

compiler/prog_data.m:
	Make the change described above, and document it.

	Put the implementations of the predicates declared in each part
	of this module next to the declarations, instead of keeping all the
	code until the very end (where it was usually far from their
	declarations).

	Remove three predicates with identical definitions from inst_match.m,
	inst_util.m and mode_constraints.m, and put the common definition
	in prog_data.m.

library/term_io.m:
	Add a new predicate that is basically a reversible version of
	the existing function espaced_char, since the definition of char_consts
	needs reversibilty.

compiler/post_typecheck.m:
	For functors of user-defined types, record their type_ctor. For tuples
	and char constants, record them as such.

compiler/builtin_lib_types.m:
compiler/parse_tree.m:
compiler/notes/compiler_design.html:
	New module to centralize knowledge about builtin types, specially
	handled library types, and their function symbols. Previously,
	the stuff now in this module used to be in several different places,
	including prog_type.m and stm_expand.m, and some of it was duplicated.

mdbcomp/prim_data.m:
	Add some predicates now needed by builtin_lib_types.m.

compiler/builtin_ops.m:
	Factor out some duplicated code.

compiler/add_type.m:
	Include the relevant type_ctors in the cons_ids generated in type
	definitions.

compiler/hlds_data.m:
	Document an existing type better.

	Rename a cons_tag in sync with its corresponding cons_id.

	Put some declarations into logical order.

compiler/hlds_out.m:
	Rename a misleadingly-named predicate.

compiler/prog_ctgc.m:
compiler/term_constr_build.m:
	Add XXXs for questionable existing code.

compiler/add_clause.m:
compiler/add_heap_ops.m:
compiler/add_pragma.m:
compiler/add_pred.m:
compiler/add_trail_ops.m:
compiler/assertion.m:
compiler/bytecode_gen.m:
compiler/closure_analysis.m:
compiler/code_info.m:
compiler/complexity.m:
compiler/ctgc_selector.m:
compiler/dead_proc_elim.m:
compiler/deep_profiling.m:
compiler/delay_partial_inst.m:
compiler/dependency_graph.m:
compiler/det_analysis.m:
compiler/det_report.m:
compiler/distance_granularity.m:
compiler/erl_rtti.m:
compiler/erl_unify_gen.m:
compiler/export.m:
compiler/field_access.m:
compiler/foreign.m:
compiler/format_call.m:
compiler/hhf.m:
compiler/higher_order.m:
compiler/hlds_code_util.m:
compiler/hlds_desc.m:
compiler/hlds_goal.m:
compiler/implementation_defined_literals.m:
compiler/inst_check.m:
compiler/inst_graph.m:
compiler/inst_match.m:
compiler/inst_util.m:
compiler/instmap.m:
compiler/intermod.m:
compiler/interval.m:
compiler/lambda.m:
compiler/lco.m:
compiler/make_tags.m:
compiler/mercury_compile.m:
compiler/mercury_to_mercury.m:
compiler/middle_rec.m:
compiler/ml_closure_gen.m:
compiler/ml_code_gen.m:
compiler/ml_code_util.m:
compiler/ml_switch_gen.m:
compiler/ml_type_gen.m:
compiler/ml_unify_gen.m:
compiler/ml_util.m:
compiler/mlds_to_c.m:
compiler/mlds_to_java.m:
compiler/mode_constraints.m:
compiler/mode_errors.m:
compiler/mode_ordering.m:
compiler/mode_util.m:
compiler/modecheck_unify.m:
compiler/modes.m:
compiler/module_qual.m:
compiler/polymorphism.m:
compiler/prog_ctgc.m:
compiler/prog_event.m:
compiler/prog_io_util.m:
compiler/prog_mode.m:
compiler/prog_mutable.m:
compiler/prog_out.m:
compiler/prog_type.m:
compiler/prog_util.m:
compiler/purity.m:
compiler/qual_info.m:
compiler/rbmm.add_rbmm_goal_infos.m:
compiler/rbmm.execution_path.m:
compiler/rbmm.points_to_analysis.m:
compiler/rbmm.region_transformation.m:
compiler/recompilation.usage.m:
compiler/rtti.m:
compiler/rtti_out.m:
compiler/rtti_to_mlds.m:
compiler/simplify.m:
compiler/simplify.m:
compiler/special_pred.m:
compiler/ssdebug.m:
compiler/stack_opt.m:
compiler/stm_expand.m:
compiler/stratify.m:
compiler/structure_reuse.direct.detect_garbagem:
compiler/superhomoegenous.m:
compiler/switch_detection.m:
compiler/switch_gen.m:
compiler/switch_util.m:
compiler/table_gen.m:
compiler/term_constr_build.m:
compiler/term_norm.m:
compiler/try_expand.m:
compiler/type_constraints.m:
compiler/type_ctor_info.m:
compiler/type_util.m:
compiler/typecheck.m:
compiler/typecheck_errors.m:
compiler/unify_gen.m:
compiler/unify_proc.m:
compiler/unify_modes.m:
compiler/untupling.m:
compiler/unused_imports.m:
compiler/xml_documentation.m:
	Minor changes, mostly to ignore the type_ctor in cons_ids in places
	where it is not needed, take the type_ctor from the cons_id in places
	where it is more convenient, conform to the new names of some cons_ids,
	conform to the changes in hlds_out.m, and/or add now-needed imports
	of builtin_lib_types.m.

	In some places, the handling previously applied to cons/2 (which
	included tuples and character constants as well as user-defined
	function symbols) is now applied only to user-defined function symbols
	or to user-defined function symbols and tuples, as appropriate,
	with character constants being handled more like the other kinds of
	constants.

	In inst_match.m, rename a whole bunch of predicates to avoid
	ambiguities.

	In prog_util.m, remove two predicates that did almost nothing yet were
	far too easy to misuse.

compiler/prog_util.m

@@ -1,7 +1,7 @@
 %-----------------------------------------------------------------------------%
 % vim: ft=mercury ts=4 sw=4 et
 %-----------------------------------------------------------------------------%
-% Copyright (C) 1994-2001, 2003-2008 The University of Melbourne.
+% Copyright (C) 1994-2001, 2003-2009 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.
 %-----------------------------------------------------------------------------%
@@ -107,8 +107,9 @@
 
     % Various predicates for accessing the cons_id type.
 
-    % Given a cons_id and a list of argument terms, convert it into a
-    % term. Fails if the cons_id is a pred_const, or type_ctor_info_const.
+    % Given a cons_id and a list of argument terms, convert it into a term.
+    % Works only on the cons_ids that can be expressed in source programs,
+    % so it fails e.g. on pred_consts and type_ctor_info_consts.
     %
 :- pred cons_id_and_args_to_term(cons_id::in, list(term(T))::in, term(T)::out)
     is semidet.
@@ -128,23 +129,6 @@
     %
 :- func make_functor_cons_id(const, arity) = cons_id.
 
-    % Another way of making a cons_id from a functor.
-    % Given the name, argument types, and type_ctor of a functor,
-    % create a cons_id for that functor.
-    %
-:- func make_cons_id(sym_name, list(constructor_arg), type_ctor) = cons_id.
-
-    % Another way of making a cons_id from a functor.
-    % Given the name, argument types, and type_ctor of a functor,
-    % create a cons_id for that functor.
-    %
-    % Differs from make_cons_id in that (a) it requires the sym_name
-    % to be already module qualified, which means that it does not
-    % need the module qualification of the type, (b) it can compute the
-    % arity from any list of the right length.
-    %
-:- func make_cons_id_from_qualified_sym_name(sym_name, list(_)) = cons_id.
-
 %-----------------------------------------------------------------------------%
 
     % make_n_fresh_vars(Name, N, VarSet0, Vars, VarSet):
@@ -215,6 +199,7 @@
 :- import_module pair.
 :- import_module string.
 :- import_module svmap.
+:- import_module term_io.
 :- import_module varset.
 
 %-----------------------------------------------------------------------------%
@@ -577,46 +562,52 @@ cons_id_and_args_to_term(int_const(Int), [], Term) :-
 cons_id_and_args_to_term(float_const(Float), [], Term) :-
     term.context_init(Context),
     Term = term.functor(term.float(Float), [], Context).
+cons_id_and_args_to_term(char_const(Char), [], Term) :-
+    SymName = unqualified(term_io.escaped_char(Char)),
+    construct_qualified_term(SymName, [], Term).
 cons_id_and_args_to_term(string_const(String), [], Term) :-
     term.context_init(Context),
     Term = term.functor(term.string(String), [], Context).
-cons_id_and_args_to_term(cons(SymName, _Arity), Args, Term) :-
+cons_id_and_args_to_term(tuple_cons(_Arity), Args, Term) :-
+    SymName = unqualified("{}"),
+    construct_qualified_term(SymName, Args, Term).
+cons_id_and_args_to_term(cons(SymName, _Arity, _TypeCtor), Args, Term) :-
     construct_qualified_term(SymName, Args, Term).
 
-cons_id_arity(cons(_, Arity)) = Arity.
-cons_id_arity(int_const(_)) = 0.
-cons_id_arity(string_const(_)) = 0.
-cons_id_arity(float_const(_)) = 0.
-cons_id_arity(implementation_defined_const(_)) = 0.
-cons_id_arity(pred_const(_, _)) =
-    unexpected(this_file, "cons_id_arity: can't get arity of pred_const").
-cons_id_arity(type_ctor_info_const(_, _, _)) =
-    unexpected(this_file,
-        "cons_id_arity: can't get arity of type_ctor_info_const").
-cons_id_arity(base_typeclass_info_const(_, _, _, _)) =
-    unexpected(this_file, "cons_id_arity: " ++
-        "can't get arity of base_typeclass_info_const").
-cons_id_arity(type_info_cell_constructor(_)) =
-    unexpected(this_file, "cons_id_arity: " ++
-        "can't get arity of type_info_cell_constructor").
-cons_id_arity(typeclass_info_cell_constructor) =
-    unexpected(this_file, "cons_id_arity: " ++
-        "can't get arity of typeclass_info_cell_constructor").
-cons_id_arity(tabling_info_const(_)) =
-    unexpected(this_file,
-        "cons_id_arity: can't get arity of tabling_info_const").
-cons_id_arity(deep_profiling_proc_layout(_)) =
-    unexpected(this_file, "cons_id_arity: " ++
-        "can't get arity of deep_profiling_proc_layout").
-cons_id_arity(table_io_decl(_)) =
-    unexpected(this_file, "cons_id_arity: can't get arity of table_io_decl").
+cons_id_arity(ConsId) = Arity :-
+    (
+        ConsId = cons(_, Arity, _)
+    ;
+        ConsId = tuple_cons(Arity)
+    ;
+        ( ConsId = int_const(_)
+        ; ConsId = float_const(_)
+        ; ConsId = char_const(_)
+        ; ConsId = string_const(_)
+        ; ConsId = impl_defined_const(_)
+        ),
+        Arity = 0
+    ;
+        ( ConsId = closure_cons(_, _)
+        ; ConsId = type_ctor_info_const(_, _, _)
+        ; ConsId = base_typeclass_info_const(_, _, _, _)
+        ; ConsId = type_info_cell_constructor(_)
+        ; ConsId = typeclass_info_cell_constructor
+        ; ConsId = tabling_info_const(_)
+        ; ConsId = deep_profiling_proc_layout(_)
+        ; ConsId = table_io_decl(_)
+        ),
+        unexpected(this_file, "cons_id_arity: unexpected cons_id")
+    ).
 
-cons_id_maybe_arity(cons(_, Arity)) = yes(Arity).
+cons_id_maybe_arity(cons(_, Arity, _)) = yes(Arity).
+cons_id_maybe_arity(tuple_cons(Arity)) = yes(Arity).
 cons_id_maybe_arity(int_const(_)) = yes(0).
-cons_id_maybe_arity(string_const(_)) = yes(0).
 cons_id_maybe_arity(float_const(_)) = yes(0).
-cons_id_maybe_arity(implementation_defined_const(_)) = yes(0).
-cons_id_maybe_arity(pred_const(_, _)) = no.
+cons_id_maybe_arity(char_const(_)) = yes(0).
+cons_id_maybe_arity(string_const(_)) = yes(0).
+cons_id_maybe_arity(impl_defined_const(_)) = yes(0).
+cons_id_maybe_arity(closure_cons(_, _)) = no.
 cons_id_maybe_arity(type_ctor_info_const(_, _, _)) = no.
 cons_id_maybe_arity(base_typeclass_info_const(_, _, _, _)) = no.
 cons_id_maybe_arity(type_info_cell_constructor(_)) = no.
@@ -625,35 +616,13 @@ cons_id_maybe_arity(tabling_info_const(_)) = no.
 cons_id_maybe_arity(deep_profiling_proc_layout(_)) = no.
 cons_id_maybe_arity(table_io_decl(_)) = no.
 
-make_functor_cons_id(term.atom(Name), Arity) = cons(unqualified(Name), Arity).
+make_functor_cons_id(term.atom(Name), Arity) =
+    cons(unqualified(Name), Arity, cons_id_dummy_type_ctor).
 make_functor_cons_id(term.integer(Int), _) = int_const(Int).
 make_functor_cons_id(term.string(String), _) = string_const(String).
 make_functor_cons_id(term.float(Float), _) = float_const(Float).
 make_functor_cons_id(term.implementation_defined(Name), _) =
-    implementation_defined_const(Name).
-
-make_cons_id(SymName0, Args, TypeCtor) = cons(SymName, Arity) :-
-    % Use the module qualifier on the SymName, if there is one,
-    % otherwise use the module qualifier on the Type, if there is one,
-    % otherwise leave it unqualified.
-    % XXX is that the right thing to do?
-    (
-        SymName0 = qualified(_, _),
-        SymName = SymName0
-    ;
-        SymName0 = unqualified(ConsName),
-        (
-            TypeCtor = type_ctor(unqualified(_), _),
-            SymName = SymName0
-        ;
-            TypeCtor = type_ctor(qualified(TypeModule, _), _),
-            SymName = qualified(TypeModule, ConsName)
-        )
-    ),
-    list.length(Args, Arity).
-
-make_cons_id_from_qualified_sym_name(SymName, Args) = cons(SymName, Arity) :-
-    list.length(Args, Arity).
+    impl_defined_const(Name).
 
 %-----------------------------------------------------------------------------%