33 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	c32098222e	Remove unneeded type qualifications in some errors. ... compiler/module_qual.qual_errors.m: When generating the context for an error message of the form "In definition of type/inst/mode/pred/func X:", if the X is guaranteed to be defined in the current module, then print its name unqualified. Since the module qualifier is guaranteed to be the same as the name of the module being compiled, its presence in the error message adds no information and is therefore only clutter. tests/invalid/errors.err_exp: tests/invalid/errors1.err_exp: tests/invalid/int_impl_imports.err_exp: tests/invalid/kind.err_exp: tests/invalid/test_nested.err_exp: tests/invalid/type_arity.err_exp: tests/invalid/undef_type.err_exp: tests/invalid_make_int/missing_interface_import.int_err_exp: tests/invalid_make_int/missing_interface_import.int_err_exp2: Expect the updated error message. tests/invalid_make_int/missing_interface_import.m: Fix a comment.	2020-08-10 19:47:36 +10:00
Zoltan Somogyi	3a1ed2efcb	Replace simple_call_id with pf_sym_name_arity. ... compiler/prog_data.m: Delete the simple_call_id data type, since it is isomorphic to the pf_sym_name_arity type, which more clearly specifies what is stored inside it. compiler/prog_out.m: Rename (all three versions of) simple_call_id_to_string to pf_sym_name_orig_arity_to_string, both to conform to the change in the input data type, and to emphasize that the resulting string will contain the *original* arity of functions (which does not include the return value), which is one less than the arity in the pf_sym_name_arity structure (which, in accordance with the convention inside the compiler that the arity is the length of the argument list, *does* include the return value). Delete the provision inside simple_call_id_to_string, now pf_sym_name_orig_arity_to_string, for special handling of the names of the predicates we use to implement promises, because it seems that *none* of the call sites to any of the three versions of this function can actually pass to it the identity of such a predicate. These calls refer to a predicate or mode declaration item (which promise predicates do not have), to clause or foreign_proc items (which again, promise predicates cannot have) or calls to the predicate (promise predicates cannot be called). Delete the exported predicate simple_call_id_to_sym_name_arity. It was called from exactly one place, inside prog_out.m itself, and this diff inlines that call. Avoid unnecessary forwarding of work from prog_out.m to error_util.m. Delete (all three versions of) write_simple_call_id. The changes below replace all their (few) uses with calls to pf_sym_name_orig_arity_to_string. compiler/error_util.m: Replace the simple_call() error piece with qual_pf_sym_name_orig_arity, and add a new version unqual_pf_sym_name_orig_arity. Their names explicitly say that they print the original arities of functions, also say whether they strip away any module qualification on the sym_name inside the pf_sym_name_arity. We prefer the unqual version in situations where the module qualifier is implicit, which usually means that it must be the same as the name of the module being compiled, because it reduces visual clutter for readers of error messages. Put {qual,unqual}_pf_sym_name_orig_arity next to their most closely related function symbols, {qual,unqual}_sym_name_arity, in the format_component type. (This yields a few inconsequential changes in the order of error_specs when sorted.) compiler/add_class.m: compiler/add_clause.m: compiler/add_foreign_proc.m: compiler/add_pragma.m: compiler/add_pragma_tabling.m: compiler/add_pragma_type_spec.m: compiler/add_pred.m: compiler/check_libgrades.m: compiler/check_parse_tree_type_defns.m: compiler/check_promise.m: compiler/check_typeclass.m: compiler/convert_parse_tree.m: compiler/equiv_type.m: compiler/goal_expr_to_goal.m: compiler/hlds_data.m: compiler/hlds_desc.m: compiler/hlds_goal.m: compiler/hlds_out_pred.m: compiler/hlds_out_util.m: compiler/hlds_pred.m: compiler/inst_util.m: compiler/llds_out_instr.m: compiler/make.module_target.m: compiler/make.program_target.m: compiler/make_hlds_error.m: compiler/make_hlds_warn.m: compiler/mark_tail_calls.m: compiler/ml_unify_gen_construct.m: compiler/mlds_to_c_stmt.m: compiler/mode_errors.m: compiler/mode_info.m: compiler/modecheck_util.m: compiler/module_qual.collect_mq_info.m: compiler/module_qual.qualify_items.m: compiler/parse_item.m: compiler/parse_module.m: compiler/parse_type_repn.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/pre_quantification.m: compiler/pred_table.m: compiler/prog_item.m: compiler/recompilation.version.m: compiler/term_constr_build.m: compiler/termination.m: compiler/type_ctor_info.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/typecheck_info.m: compiler/unify_gen_construct.m: compiler/unused_imports.m: Conform to the changes above. Where I am pretty sure that in an error message, the module qualifier of a name must be the current module, use unqual_pf_sym_name_orig_arity instead of qual_pf_sym_name_orig_arity. Add some sanity checks where they seem appropriate. Replace sequences of io.write_strings with uses of io.format where this yields clearer code. (This is why there were no remaining calls to write_simple_call_id.) Shorten some too-long lines. In add_pred.m, make the order of some predicate definitions match the order of the calls to them. tests/invalid/ambiguous_method.err_exp: tests/invalid/ambiguous_method_2.err_exp: tests/invalid/bad_pred_arity.err_exp: tests/invalid/bad_sv_unify_msg.err_exp: tests/invalid/bigtest.err_exp: tests/invalid/bug113.err_exp: tests/invalid/bug197.err_exp: tests/invalid/bug278.err_exp: tests/invalid/bug410.err_exp: tests/invalid/bug476.err_exp: tests/invalid/bug487.err_exp: tests/invalid/complex_constraint_err.err_exp: tests/invalid/constrained_poly_insts.err_exp: tests/invalid/errors.err_exp: tests/invalid/errors1.err_exp: tests/invalid/errors2.err_exp: tests/invalid/exported_mode.err_exp: tests/invalid/field_syntax_error.err_exp: tests/invalid/foreign_singleton.err_exp: tests/invalid/funcs_as_preds.err_exp: tests/invalid/imported_mode.err_exp: tests/invalid/invalid_binary_literal.err_exp: tests/invalid/invalid_float_literal.err_exp: tests/invalid/invalid_hex_literal.err_exp: tests/invalid/invalid_octal_literal.err_exp: tests/invalid/make_opt_error.err_exp: tests/invalid/missing_det_decls.err_exp: tests/invalid/multimode_syntax.err_exp: tests/invalid/null_char.err_exp: tests/invalid/occurs.err_exp: tests/invalid/record_syntax_errors.err_exp: tests/invalid/ref_to_implicit_pred.err_exp: tests/invalid/require_tailrec_1.err_exp: tests/invalid/require_tailrec_1.err_exp2: tests/invalid/require_tailrec_2.err_exp: tests/invalid/require_tailrec_2.err_exp2: tests/invalid/require_tailrec_3.err_exp: tests/invalid/require_tailrec_3.err_exp2: tests/invalid/state_vars_test2.err_exp: tests/invalid/state_vars_test3.err_exp: tests/invalid/state_vars_test5.err_exp: tests/invalid/type_inf_loop.err_exp: tests/invalid/typeclass_constraint_extra_var.err_exp: tests/invalid/typeclass_mode_2.err_exp: tests/invalid/typeclass_test_12.err_exp: tests/invalid/typeclass_test_2.err_exp: tests/invalid/typeclass_test_9.err_exp: tests/invalid/types.err_exp: tests/invalid/types2.err_exp: tests/invalid/unbound_type_vars.err_exp: tests/invalid/with_type.err_exp: tests/invalid_purity/purity_nonsense.err_exp: tests/invalid_purity/purity_nonsense2.err_exp: tests/warnings/double_underscore.exp: tests/warnings/pragma_source_file.exp: tests/warnings/singleton_test.exp: tests/warnings/singleton_test.exp2: tests/warnings/singleton_test.exp3: tests/warnings/singleton_test.exp4: tests/warnings/singleton_test_state_var.exp: tests/warnings/warn_return.exp: tests/warnings/warn_return.exp2: tests/warnings/warn_return.exp3: tests/warnings/warn_succ_ind.exp: tests/warnings/warn_succ_ind.exp2: tests/warnings/warn_succ_ind.exp3: tests/warnings/warn_succ_ind.exp4: Update all these expected output files. Most changes are due to predicate and function names no longer being module qualified when the module qualification is obvious. A few changes are due to the change in the relative ordering of the function symbols of the format_component type. For singleton_test, warn_return and warn_succ_ind in warnings, the changes to the non-C .exp files were done by hand, so they may have the wrong white space.	2020-03-16 12:10:28 +11:00
Zoltan Somogyi	9789375cc5	Make pre-HLDS passes use file-kind-specific parse trees. ... Replacing item blocks file-kind-specific kinds of section markers with file-kind-specific parse trees has several benefits. - It allows us to encode the structural invariants of each kind of file we read in within the type of its representation. This makes the detection of any accidental violations of those invariants trivial. - Since each file-kind-specific parse tree has separate lists for separate kinds of items, code that wants to operate on one or a few kinds of items can just operate on those kinds of items, without having to traverse item blocks containing many other kinds of items as well. The most important consequence of this is not the improved efficiency, though that is nice, but the increased clarity of the code. - The new design is much more flexible. For example, it should be possible to record that e.g. an interface file we read in as a indirect dependency (i.e. a file we read not because its module was imported by the module we are compiling, but because its module was imported by *another* imported module) should be used *only* for the purpose it was read in for. This should avoid situations where deleting an import of A from a module, because it is not needed anymore, leads the compiler to generate an error message about a missing import of module B. This can happen if (a) module B always *should* have been imported, since it is used, but (b) module A's import of module B lead to module B's interface being available *without* an import of B. Specifically, this flexibility should enable us to establish each module's .int file as the single source of truth about how values of each type defined in that module should be represented. When compiling each source file, this approach requires the compiler to read in that module's .int file but using only the type_repn items from that .int file, and nothing else. - By recording a single parse tree for each file we have read, instead of a varying number of item blocks, it should be significantly easier to derive the contents of .d files directly from the records of those parse trees, *without* having to maintain a separate set of fields in the module_and_imports structure for that purpose. We could also trivially avoid any possibility of inconsistencies between these two different sources of truth. (We currently fill in the fields used to drive the generation of .d files using two different pieces of code, one used for --generate-dependencies and one used for all other invocations, and these two *definitely* generate inconsistent results, as the significant differences in .d files between (a) just after an invocation of --generate-dependencies and (b) just after any other compiler invocation can witness.) This change is big and therefore hard to review. Therefore in many files, this change adds "XXX CLEANUP" comments to draw attention to places that have issues that should be fixed, but whose fixes should come later, in separate diffs. compiler/module_imports.m: The compiler uses the module_and_imports structure defined here to go from a raw compilation unit (essentially a module to be compiled) to an augmented compilation unit (a raw compilation unit together with all the interface and optimization files its compilation needs). We used to store the contents of both the source file and of the interface and optimization files in the module_and_imports structure as item blocks. This diff replaces all those item blocks with file-kind-specific parse trees, for the reasons mentioned above. Separate out the .int0 files of ancestors modules from the .intN files for N>0 of directly imported modules. (Their item blocks used to be stored in the same list.) Maintain a database of the source, interface and optimization files we have read in so far. We use it to avoid reading in interface files if we have already read in a file for the same module that contains strictly more information (either an interface file with a smaller number as a suffix, or the source file itself). Shorten some field names. compiler/prog_item.m: Define data structures for storing information about include_module, import_module and use_module declarations, both in a form that allows the representation of possibly erroneous code in actual source files, and in checked-and-cleaned-up form which is guaranteed to be free of the relevant kinds of errors. Add a block comment at the start of the module about the need for this distinction. Define parse_tree_module_src, a data structure for representing the source code of a single module. This is different from the existing parse_tree_src type, which represents the contents of a single source file but which may contain *more* than one module, and also different from a raw_compilation_unit, which is based on item blocks and is thus unable to express to invariants such as "no clauses in the interface". Modify the existing parse_tree_intN types to express the distinction mentioned just above, and to unify them "culturally", i.e. if they store the same information, make them store it using the same types. Fix a mistake by allowing promises to appear in .opt files. I originally ruled them out because the code that generates .opt files does not have any code to write out promises, but some of the predicates whose clauses it writes out have goal_type_promise, which means that they originated as promises, and get written out as promises. Split the existing pragma item kind into three item kinds, which have different invariants applying to them. - The decl (short for declarative) pragmas give the compiler some information, such as that a predicate is obsolete or that we want to type specialize some predicate or function, that is in effect part of the module's interface. Decl pragmas may appear in module interfaces, and the compiler may put them into interface files; neither statement is true of the other two kinds of pragmas. - The impl (short for implementation) pragmas are named so precisely because they may appear only in implementation sections. They give the compiler information that is private to that module. Examples include foreign_decls, foreign_codes, foreign_procs, and promises of clause equivalence, and requests for inlining, tabling etc. These will never be put into interface files, though some of them can affect the compilation of other modules by being included in .opt files. - The gen (short for generated) pragmas can never (legally) appear in source files at all. They record the results of compiler analyses e.g. about which arguments of a predicate are unused, or what exceptions a function can throw, and accordingly they should only ever occur in compiler-generated interface files. Use the new type differences between the three kinds of pragmas to encode the above invariants about which kinds of pragmas can appear where into the various kinds of parse trees. Make the augmented compilation unit, which is computed from the final module_and_imports structure, likewise switch from storing item blocks to storing the whole parse trees of the files that went into its construction. With each such parse tree, record *why* we read it, since this controls what permissions the source module being compiled has for access to the entities in the parse tree. Simplify the contains_foreign_code type, since one of three function symbols was equivalent to one possible use of another function symbol. Provide a way to record which method of which class a compiler-generated predicate is for. (See hlds_pred.m below.) Move the code of almost all utility operations to item_util.m (which is imported by many fewer modules than prog_item.m), keeping just the most "popular" ones. compiler/item_util.m: Move most of the previously-existing utility operations here from prog_item.m, most in a pretty heavily modified form. Add a whole bunch of other utility operations that are needed in more than one other module. compiler/convert_parse_tree.m: Provide predicates to convert from raw compilation units to parse_tree_module_srcs, and vice versa (though the reverse shouldn't be needed much longer). Update the conversion operations between the general parse_tree_int and the specific parse_tree_intN forms for the changes in prog_item.m mentioned above. In doing so, use a consistent approach, based on new operations in item_util.m, to detect errors such as duplicate include_module and import/use_module declarations in all kinds of parse trees. Enforce the invariants that the types of parse trees of various kinds can now express in types, generating error messages for their violations. Delete some utility operations that have been moved to item_util.m because now they are also needed by other modules. compiler/grab_modules.m: Delete code that did tests on raw compilation units that are now done when that raw compilation unit is converted to a parse_tree_module_src. Use the results of the checks done during that conversion to decide which modules are imported/used and in which module section. Record a single reason for why we reading in each interface and optimization file. The code of make_hlds_separate_items.m will use this reason to set up the appropriate permissions for each item in those files. Use separate code for handling different kinds of interface and optimization files. Using generic traversal code was acceptable economy when we used the same data structure for every kind of interface file, but now that we *can* express different invariants for different kinds of interface and optimization file, we want to execute not just different code for each kind of file, but the data structures we want to work on are also of different types. Using file-kind-specific code is a bit longer, but it is significantly simpler and more robust, and it is *much* easier to read and understand. Delete the code that separates the parts of the implementation section that are exported to submodules, and the part that isn't, since that task is now done in make_hlds_separate_items.m. Pass a database of the files we have read through the relevant predicates. Give some predicates more meaningful names. compiler/notes/interface_files.html: Note a problem with the current operation of grab_modules. compiler/get_dependencies.m: Add operations to gather implicit references to builtin modules (which have to be made available even without an explicit import_module or use_module declaration) in all kinds of parse trees. These have more code overall, but will be at runtime, since we need only look at the item kinds that may *have* such implicit references. Add a mechanism to record the result of these gathering operations in import_and_or_use_maps. Give some types, function symbols, predicates and variables more meaningful names. compiler/make_hlds_separate_items.m: When we stored the contents of the source module and the interface and optimization files we read in to augment it in the module_and_imports structure as a bunch of item blocks, the job of this module was to separate out the different kinds of items in the item blocks, returning a single list of each kind of item, with each such item being packaged up with its status (which encodes a set of permissions saying what the source module is allowed to do with it). Now that the module_and_imports structure stores this info in file-kind-specific parse trees, all of which have separate lists for each kind of item and none of which contain item blocks, the job of this module has changed. Now its job is to convert the reason why each file was read in into the (one or more) statuses that apply to the different kinds of items stored in it, wrap up each item with its status, and return the resulting overall list of status/item pairs for each kind of item. compiler/read_modules.m: Add predicates that, when reading an interface file, return its contents in the tightest possible file-kind-specific parse tree. Refine the database of files we have read to allow us to store more file-kind-specific parse trees. Don't require that files in the database have associated timestamps, since in some cases, we read files we can put into the database *without* getting their timestamps. Allow the database to record that an attempt to read a file failed. compiler/split_parse_tree_src.m: Rearchitect how this module separates out nested submodules from within the main module in a file. Another of the jobs of this module is to generate error messages for when module A includes module B twice, whether via nesting or via include_module declarations, with one special exception for the case where A's interface contains nested submodule A.B's interface, and A's implementation contains nested submodule A.B's implementation. The problem ironically was that while it reported duplicate include_module declarations as errors, split_parse_tree_src.m also *generated* duplicate include_module declarations. Since it replaced each nested submodule occurrence with an include_module declaration, in the scenario above, it generated two include_module declarations for A.B. Even worse, the interface incarnation of submodule A.B could contain (the interface of) its own nested submodule A.B.C, while its implementation incarnation could contain (the implementation section of) A.B.C. Each occurrence of A.B.C would be its only occurrence in the including part of its parent A.B, which means local tests for duplicates do not work. (I found this out the hard way.) The solution we now adopt adds include_module declarations to the parents of any submodule only once the parse tree of the entire file has been processed, since only then do we know all the includer/included relationships among nested modules. Until then, we just record such relationships in a database as we discover them, reporting duplicates when needed (e.g. when A includes B twice *in the same section*), but not reporting duplicates when not needed (e.g. when A.B includes A.B.C in *different* sections). compiler/prog_data.m: Add a new type, pf_sym_name_and_arity, that exactly specifies a predicate or function. It is a clone of the existing simple_call_id type, but its name does NOT imply that the predicate or function is being called. Add XXXs that call for some other improvements in type names. compiler/prog_data_foreign.m: Give a type, and the operations on that type, a more specific name. compiler/error_util.m: Add an id field to all error_specs, which by convention should be filled in with $pred. Print out the value in this field if the compiler is invoked with the developer-only option --print-error-spec-id. This allows a person debugging the compiler find out where in the code an undesired error message is coming from significantly easier than was previously possible. Most of the modules that have changes only "to conform to the changes above" will be for this change. In many cases, the updated code will also simplify the creation of the affected error_specs. Fix a bug that looked for a phase in only one kind of error_spec. Add some utility operations needed by other parts of this change. Delete a previously internal function that has been moved to mdbcomp/prim_data.m to make it accessible in other modules as well. compiler/Mercury.options: Ask the compiler to warn about dead predicates in every module touched by this change (at least in one its earlier versions). compiler/add_foreign_enum.m: Replace a check for an inappropriately placed foreign_enum declaration with a sanity check, since with this diff, the error should be caught earlier. compiler/add_mutable_aux_preds.m: Delete a check for an inappropriately placed mutable declaration, since with this diff, the error should be caught earlier. compiler/add_pragma.m: Instead of adding pass2 and pass3 pragmas, add decl and impl and generated pragmas. Delete the tests for generated pragma occurring anywhere except .opt files, since those tests are now done earlier. Shorten some too-long predicate names. compiler/comp_unit_interface.m: Operate on as specific kinds of parse trees as the interface of this module will allow. (We could operate on more specific parse trees if we changed the interface, but that is future work). Use the same predicates for handling duplicate include_module, import_module and use_module declarations as everywhere else. Delete the code of an experiment that shouldn't be needed anymore. compiler/equiv_type.m: Replace code that operated on item blocks with code that operates on various kinds of parse trees. Move a giant block of comments to the front, where it belongs. compiler/hlds_module.m: Add a field to the module_info that lets us avoid generating misleading error messages above missing definitions of predicates or functions when those definitions were present but were not added to the HLDS because they had errors. Give a field and its access predicates a more specific name. Mark a spot where an existing type cannot express everything it is supposed to. compiler/hlds_pred.m: For predicates which the compiler creates to represent a class method (the virtual function, in OOP terms), record not just this fact, but the id of the class and of the method. Using this extra info in progress messages (with mmc -V) prevents the compiler from printing e.g. % Checking typeclass constraints on class method % Checking typeclass constraints on class method % Checking typeclass constraints on class method when checking three such predicates. compiler/make.m: Provide a slot in the make_info structure to allow the database of the files we have read in to be passed around. compiler/make_hlds_error.m: Delete predicates that are needed in just one other module, and have therefore been moved there. compiler/make_hlds_passes.m: Add decl, impl and generated pragma separately, instead of adding pass2 and pass3 pragmas separately. Do not generate error messages for clauses, initialises or finalises in module interfaces, since with this diff, such errors should be caught earlier. compiler/mercury_compile_main.m: compiler/recompilation.check.m: Explicitly pass around the expanded database of parse trees of files that have been read in. compiler/module_qual.collect_mq_info.m: compiler/module_qual.m: compiler/module_qual.qualify_items.m: Collect module qualification information, and do module qualification respectively on parse trees of various kinds, not item blocks. Take information about what the module may do with the contents of each interface or optimization file from the record of why we read that file, not from the section markers in item blocks. Break up some too-large predicates by carving smaller ones out of them. compiler/options.m: Add an option to control whether errors and/or warnings detecting when deciding what should go into a .intN file be printed, thus (potentially) preventing the creation of that file. Add commented-out documentation for a previously totally undocumented option. doc/user_guide.texi: Document the new option. NEWS: Announce the new option. Mention that we now generate warnings for unused import_module and use_module declarations in the interface even if the module has submodules. compiler/write_module_interface_files.m: Let the new option control whether we filter out any messages generated when deciding what should go into a .intN file. compiler/parse_item.m: Delete actually_read_module_opt, since it is no longer needed; its callers now call actually_read_module_{plain,trans}_opt instead. Delete unneeded arguments from some predicates. compiler/parse_module.m: Delete some long unused predicates. compiler/parse_pragma.m: When parsing pragmas, wrap them up in the new decl, impl or generated pragma kinds. compiler/parse_tree_out.m: Add predicates to write out each of the file-kind-specific parse trees. compiler/parse_tree_out_pragma.m: Add predicates to write out decl, impl and generated pragmas. compiler/polymorphism.m: Add a conditionally-enabled progress message, which can be useful in tracking down problems. compiler/prog_item_stats.m: Conform NOT to the changes above beyond what is needed to let this module compile. Let that work be done the next time the functionality of this module is needed, by which time the affected data structures maybe have changed further. compiler/typecheck.m: Fix a performance problem. With intermodule optimization, we read in .opt files, some of which (e.g. list.opt and int.opt) contain promises. These promises are read in as predicates with goal_type_promise, but they do not have declarations of the types of their arguments (since promises do not have declarations as such). Those argument types therefore have to be inferred. That inference replaces the original "I don't know" argument types with their actual types. The performance problem is that when we change the recorded argument types of a predicate, we require another loop over all the predicates in the module, so that any calls to this predicate can be checked against the updated types. This is as it should be for callable predicates, but promises are not callable. So if all the *only* predicates whose recorded argument types change during the first iteration to fixpoint are promises, then a second iteration is not needed, yet we used to do it. The fix is to replace the "Have the recorded types of this predicate changed?" boolean flag with a bespoke enum that says "Did the checking of this predicate discover a need for another iteration", and not setting it when processing predicates whose type is goal_type_promise. compiler/typecheck_errors.m: Do not generate an error message for a predicate missing its clauses is the clauses existed but were not added to the HLDS because they were in the interface section. When reporting on ambiguities (when a call can match more than one predicate or function), sort the possible matches before reporting them. compiler/accumulator.m: compiler/add_class.m: compiler/add_clause.m: compiler/add_foreign_proc.m: compiler/add_mode.m: compiler/add_pragma_tabling.m: compiler/add_pragma_type_spec.m: compiler/add_pred.m: compiler/add_type.m: compiler/canonicalize_interface.m: compiler/check_for_missing_type_defns.m: compiler/check_parse_tree_type_defns.m: compiler/check_promise.m: compiler/check_raw_comp_unit.m: compiler/check_typeclass.m: compiler/common.m: compiler/compile_target_code.m: compiler/compiler_util.m: compiler/dead_proc_elim.m: compiler/deps_map.m: compiler/det_analysis.m: compiler/det_report.m: compiler/du_type_layout.m: compiler/field_access.m: compiler/find_module.m: compiler/float_regs.m: compiler/format_call.m: compiler/goal_expr_to_goal.m: compiler/handle_options.m: compiler/hlds_out_module.m: compiler/hlds_out_pred.m: compiler/hlds_out_util.m: compiler/inst_check.m: compiler/intermod.m: compiler/introduce_parallelism.m: compiler/layout_out.m: compiler/make.dependencies.m: compiler/make.module_dep_file.m: compiler/make_hlds_warn.m: compiler/mark_tail_calls.m: compiler/mercury_compile_llds_back_end.m: compiler/ml_top_gen.m: compiler/mmakefiles.m: compiler/mode_errors.m: compiler/mode_robdd.equiv_vars.m: compiler/modes.m: compiler/module_qual.qual_errors.m: compiler/oisu_check.m: compiler/old_type_constraints.m: compiler/options_file.m: compiler/parse_class.m: compiler/parse_dcg_goal.m: compiler/parse_goal.m: compiler/parse_inst_mode_defn.m: compiler/parse_inst_mode_name.m: compiler/parse_mutable.m: compiler/parse_sym_name.m: compiler/parse_type_defn.m: compiler/parse_type_name.m: compiler/parse_type_repn.m: compiler/parse_types.m: compiler/parse_util.m: compiler/parse_vars.m: compiler/post_term_analysis.m: compiler/post_typecheck.m: compiler/prog_event.m: compiler/prog_mode.m: compiler/purity.m: compiler/qual_info.m: compiler/recompilation.version.m: compiler/resolve_unify_functor.m: compiler/simplify_goal.m: compiler/simplify_goal_call.m: compiler/simplify_goal_disj.m: compiler/simplify_goal_ite.m: compiler/simplify_proc.m: compiler/state_var.m: compiler/stratify.m: compiler/style_checks.m: compiler/superhomogeneous.m: compiler/table_gen.m: compiler/term_constr_errors.m: compiler/term_errors.m: compiler/termination.m: compiler/trace_params.m: compiler/unused_args.m: compiler/unused_imports.m: compiler/write_deps_file.m: compiler/xml_documentation.m: Conform to the changes above. mdbcomp/prim_data.m: Move a utility function on pred_or_funcs here from a compiler module, to make it available to other compiler modules as well. scripts/compare_s1s2_lib: A new script that helped debug this diff, and may help debug similar diffs the future. It can compare (a) .int* files, (b) .*opt files, (c) .mh/.mih files or (d) .c files between the stage 1 and stage 2 library directories. The reason for the restriction to the library directory is that any problems affecting the generation of any of these kinds of files are likely to manifest themselves in the library directory, and if they do, the bootcheck won't go on to compile any of the other stage 2 directories. tests/debugger/breakpoints.a.m: tests/debugger/breakpoints.b.m: Move import_module declarations to the implementation section when they are not used in the interface. Until now, the compiler has ignored this, but this diff causes the compiler to generate a warning for such misplaced import_module declarations even modules that have submodules. The testing of such warnings is not the point of the breakpoints test. tests/invalid/Mercury.options: Since the missing_interface_import test case tests error messages generated during an invocation of mmc --make-interface, add the new option that *allows* that invocation to generate error messages. tests/invalid/ambiguous_overloading_error.err_exp: tests/invalid/max_error_line_width.err_exp: tests/warnings/ambiguous_overloading.exp: Expect the updated error messages for ambiguity, in which the possible matches are sorted. tests/invalid/bad_finalise_decl.m: tests/invalid/bad_initialise_decl.m: Fix programming style. tests/invalid/bad_item_in_interface.err_exp: Expect an error message for a foreign_export_enum item in the interface, where it should not be. tests/invalid/errors.err_exp: Expect the expanded wording of a warning message. tests/invalid/foreign_enum_invalid.err_exp: Expect a different wording for an error message. It is more "standard" but slightly less informative. tests/invalid_submodules/children2.m: Move a badly placed import_module declaration, to avoid having the message the compiler now generates for it from affecting the test. tests/submodules/parent2.m: Move a badly placed import_module declaration, to avoid having the message the compiler now generates for it from affecting the test. Update programming style.	2020-03-13 12:58:33 +11:00
Zoltan Somogyi	fc347fb6a1	Stop generating interface files only in the presence of errors. ... compiler/write_module_interface_files.m: If the code that computes the contents of an interface file also generates messages to the user, don't take the mere existence of these messages as grounds for not writing out the interface file; instead, require them to report errors, or (if --halt-at-warn is enabled) warnings. compiler/error_util.m: Provide a predicate for checking the above condition. compiler/check_raw_comp_unit.m: Fix, in two different ways, the warning that indicated the need for the change to write_module_interface_files. First, if the module exports nothing, then generate a warning only if warn_nothing_exported is set, instead of always generating a warning that is conditional on warn_nothing_exported being set. The latter doesn't just tickle the problem mentioned above, it also uses more complex code. Second, fix the wording of the warning. tests/invalid/bigtest.err_exp: tests/invalid/duplicate_modes.err_exp: tests/invalid/empty_interface.err_exp: tests/invalid/errors.err_exp: tests/invalid/errors1.err_exp: tests/invalid/errors2.err_exp: tests/invalid/funcs_as_preds.err_exp: tests/invalid/inst_list_dup.err_exp: tests/invalid/no_exports.err_exp: tests/invalid/occurs.err_exp: tests/invalid/prog_io_erroneous.err_exp: tests/invalid/type_inf_loop.err_exp: tests/invalid/typeclass_missing_det_3.err_exp: tests/invalid/typeclass_no_param.err_exp: tests/invalid/typeclass_test_11.err_exp: tests/invalid/types.err_exp: tests/invalid/undef_inst.err_exp: tests/invalid/undef_mode.err_exp: tests/invalid/undef_type.err_exp: tests/invalid/unicode1.err_exp: tests/invalid/unicode2.err_exp: tests/invalid/vars_in_wrong_places.err_exp: Expect the improved wording of the warning.	2019-10-27 01:25:11 +11:00
Julien Fischer	b8b132260c	Expand more acronyms in error messages. ... compiler/parse_type_defn.m: s/RHS/right hand side/ in a couple of error messages. tests/invalid/errors.err_exp: Conform to the above change.	2017-03-15 19:46:16 +11:00
Zoltan Somogyi	5649f36c80	Handle "use_module in interface, import_module in implementation". ... If a module m1 imports module m2 using a use_module declaration in its interface section but also imports it using an import_module declaration in its implementation section, then references to entities defined in m2 in the interface of m1 must be module qualified, but similar references in the implementation of m1 need NOT be module qualified. The Mercury compiler has long had a bug that allowed entities imported in the implementation of module m1 to be used in the interface of m1, against the rules of the language. When I fixed that bug on 2015 nov 11, the compiler became unable to properly process the situation described in the paragraph above, because it still had another bug, which was that it had a single setting for module qualification requirements: either it was required *everywhere* in m1, or it was required *nowhere* in m1. This diff fixes that bug (mantis bug 401) by allowing different requirements in this respect in the interface of m1 versus its implementation. It also changes the de-facto meaning of what exactly a use_module declaration requires. The reference manual says only: Uses of entities imported using @code{use_module} declarations @emph{must} be explicitly module qualified. This WAS unambiguous when it was written in june 1997, a few months before submodules were added to the language. With a flat module system, there were no nested module names, so either the module name was present, or it wasn't. In the presence of nested modules, though, it IS ambiguous: HOW MUCH of the module name must be present? The reference manual is silent on this. At the moment, in the presence of a use_module for module ma.mb.mc, a predicate p1 in ma.mb.mc may of course be referred to as ma.mb.mc.p1, but may also be referred to as mb.mc.p1, or even just mc.p1. The specification of mc is always required, but exactly WHICH of the previous module name components are required depends on whether e.g. ma or ma.mb were themselves imported via use_module or import_module declarations. The code implementing the check (find_matches_in_permissions_map in module_qual.id_set.m) is itself not too clear. This diff changes the rules so that all references to anything imported via a use_module declarations have to be fully qualified. This is stricter than the existing rule, but it is MUCH simpler, and it better matches the original intent of use_module declarations, which is the avoidance of ALL POSSIBILITY of ambiguity. NEWS: doc/reference_manual.texi: Document this change to the language. compiler/prog_item.m: Change the representation of sections in .int* files. Previously, we recorded whether the interface file that the section was from was read for an `import_module' or a `use_module' declaration. We now allow the recording of the fact that it had both declarations, a use_module in the interface and an import_module in the implementation. compiler/modules.m: Treat modules that have both a `use_module' declaration in interface and an `import_module' declaration in the implementation as being of this new internal section kind. Add some infrastructure for debugging similar problems in the future. compiler/module_qual.id_set.m: Change the permissions system. Instead of recording *independently* whether (a) an entity may be used in the interface and (b) whether references to it must be qualified, record *separately* whether (a) it may be used in the interface, and if so with what qualification requirements, and (b) what its qualification requirements are in the implementation. Unlike the old permission setup, the new one allows us to express the "use_module in interface, import_module in implementation" situation. Implement the change to the language, by requiring full module qualification of entities imported via use_module declarations. This allows us to use a single parameterized piece of code to handle both unqualified and qualified references, whereas before we used separate pieces of code for them. Change the way we handle errors in module qualification. Instead of looking only for precise matches only, and looking for the possible causes of errors only if we find either no matches or two or more matches, we now return the near-miss matches as well, the ones that we need to decide on what error message we want to generate. While this is slightly slower, it is *much* simpler, since it allows us to avoid duplicating the search code: once for precise matches only, once for no-match errors, and once for multiple-match errors. compiler/module_qual.collect_mq_info.m: Set permissions for symbol access according to the new permissions system. Code that previously triggered the bug will use the new interface file section kind, and can now have its permissions record correctly. compiler/module_qual.qual_errors.m: Use a single predicate to generate error messages for all situations in which there is not a single precise match for a module qualification. This allows us to diagnose multiple potential problems with a single lookup. Change the wording of an existing error message to avoid a possibly-untrue implication. compiler/hlds_data.m: Rename a field of the type_defn type to better document its meaning. compiler/make_hlds.m: Document the meaning of the need_qualifier field in sec_infos. compiler/add_type.m: compiler/make_hlds_separate_items.m: compiler/module_qual.m: compiler/pred_table.m: compiler/parse_tree_out.m: compiler/prog_item_stats.m: Conform to the above changes. mdbcomp/sym_name.m: Add a utility predicate for use in looking for near-miss matches in module qualification. Make the documentation of a related predicate more precise. tests/invalid/bad_instance.m: tests/submodules/class.m: tests/submodules/nested.m: tests/submodules/nested3.m: tests/submodules/parent.m: Make names fully module qualified where the language rules now require it. tests/submodules/deeply_nested.m: Comment out a part of the test that tested the partially qualified names, since these are now not allowed. tests/invalid/errors.err_exp: Expect a now-improved error message. tests/invalid/test_nested.err_exp: tests/invalid/transitive_import.err_exp: tests/invalid/undef_type.err_exp: Expect a now less-likely-to-mislead error message. tests/valid_seq/int_impl_imports.m: tests/valid_seq/int_impl_imports_2.m: The test case for mantis bug 401. tests/valid_seq/Mmakefile: Enable the new test case.	2016-01-11 23:05:39 +11:00
Zoltan Somogyi	9a7a7d4e9c	Reserve the type names known to Mercury. ... We have traditionally allowed type definitions like this :- type int(A, B, C) ---> f1(A) ; f2(B) ; f3(C). even though "int" is a type name that is built into Mercury, just with a different arity. This diff reserves those type names, generating errors for any attempts to define them in user code. compiler/prog_io_util.m: We used to parse types by trying to match the input term against one pattern after another. If one pattern didn't match, for any reason, we went on to the next, the final being to assume that the term's top functor is the name of a user defined type. This happened even if the top functor was the name of a builtin type or a word (such as "pred" that constructed types), but it either had the wrong number of arguments, or one of the arguments itself had a problem. This lead to a confusing error message being generated. We now effectively look at the top functor of the term, and if it is the name of a builtin inst or mode construct, then we parse it as that construct requires, and never fall back to interpreting it as a user defined inst. (To get even better diagnostics, we will need to convert some utility predicates from indicating the failure of parsing by failing to indicating it by returning a list of error_specs.) compiler/prog_io_type_defn.m: Enforce the prohibition against defining builtin type names, even with different module qualifiers and/or arities. Changes the predicates that parse the different kinds of type definitions to not stop at the first errors they encounter, but to print all the errors they can find. When a type parameter of a type definition is repeated, include its name in the error message. Delete some out-of-date comments. compiler/prog_io_mode_defn.m: When an inst parameter of an inst or mode definition is repeated, include its name in the error message. library/bag.m: Add a predicate that returns only the repeated items in a bag. doc/reference_manual.texi: Document the list of reserved inst names. We could document the list of reserved mode names, but probably no-one would want to define those anyway, so the list would probably be more confusing than helpful. tests/invalid/reserved.{m,err_exp}: Expect an error message for the attempted redefinition of a builtin type. Add a valid type as well, and use that to test the error messages for bad inst definitions. This changes the line numbers; expect the new line numbers. tests/invalid/bigtest.err_exp: tests/invalid/uu_type.err_exp: Expect an error message for the attempted redefinition of a builtin type. tests/invalid/errors.err_exp: Expect a more precise error message.	2015-09-04 06:28:10 +10:00
Zoltan Somogyi	f2043fc9bd	Replace the item list with more structured ASTs. ... The parts of the compiler that run before the HLDS is constructed used to use a raw list of items to represent source files (.m), interface files (.int0, .int3, .int2 and .int) and optimization files (.opt, and .trans_opt). These lists had structure, but this structure was implicit, not explicit, and its invariants were never really documented. This diff changes that. It replaces the item list with FIVE separate types. Three of these each represent the unprocessed content of one file: - parse_tree_int represents the contents of one interface file; - parse_tree_opt represents the contents of one optimization file; - parse_tree_src represents the contents of one source file. Two of these each represent the processed contents of one or more files: - raw_compilation_unit represents the contents of one module in a source file. (The source file may contain several nested modules; the compilation unit represents just one.) - aug_compilation_unit represents the contents of one module in a source file, just like raw_compilation_unit, but it is augmented with the contents of the interface and optimization files of the other modules imported (directly or indirectly) by the original module. These five separate concepts all used to be represented by the same type, list(item), but different invariants applied to the structure of those lists. The most important of those invariants at least are now explicit in the types. I think it is entirely possible that there are other invariants I haven't discovered and documented (for example, .int3 files must have stricter invariants on what can appear in them than .int files), but discovering and documenting these should be MUCH easier after this change. I have marked many further opportunities for improvements with "XXX ITEM_LIST". Some of these include moving code between modules, and the creation of new modules. However, I have left acting on those XXXs until later, in order to keep the size of this diff down as much as possible, for easier reviewing. compiler/prog_item.m: Define the five new AST types described above, and utility predicates that operate on them. In the rest of this change, I tried, as much as possible, to change predicates that used to take item lists as arguments to make them change one of these types instead. In many cases, this required putting the argument lists of those predicates into a more consistent order. (Often, predicates that operated on the contents of the module took the name of the module and the list of items in the module not just as separate arguments, but as separate arguments that weren't even next to each other.) Define types that identify the different kinds of interface and optimization files (.int, .int2 etc). These replace the string suffixes we used to use to identify file types. Predicates that used to take strings representing suffixes as arguments now have to specify whether they can handle all these file types (source, interface and optimization), or just (e.g.) all interface file types. We used to have items corresponding to `:- module' and `:- end_module'. Delete these; this information is now implicit in the structure of the relevant AST. The parser handles the corresponding terms as markers, not items; these markers are live only during parsing. We used to have module_defns corresponding to `:- interface' and `:- implementation'. Delete these; this information is now also implicit in the structure of the relevant AST. Delete also, for the same reason, the module_defns used to mark the starts of sublists in the overall lists of items whose items came from the interface files or optimization files of other modules. The former are now markers during parsing. The latter are never parsed, but are created directly, after parsing has been done. Delete the pragma type for `:- pragma source_file'. This is never needed later; it is now a marker during parsing. Change the internal representation of `:- import' and `:- use'. It used to store a list of module names, but that list was an actual list only during parsing; after that, it always had exactly one element. It now stores one module name, and the parser has a mechanism to convert one read-in term to more than one item, for use with terms such as `:- import_module a, b'. Delete the internal representation of `:- export', which was never implemented, since if it IS ever implemented, it will almost certainly be in a different form, which will need different support. Document some further opportunities for simplification, later. (This diff is already more than big enough.) compiler/prog_io_item.m: Rewrite the top-level part of this module. Instead of returning an item for every parsed term, distinguish between parsing items that end up in item lists inside ASTs, and parsing markers that end up creating the STRUCTURE of those ASTs. compiler/prog_io.m: Rewrite the meat of this module. Instead of reading in a simple item list, we now have to read in three different parse trees with three different grammars, each of which is more complex than a simple list. compiler/read_modules.m: We used to have a map that mapped file names to the contents of those files. We now need three separate maps, for interface files, optimization files and source files, due to their separate types. (We don't actually use the map for optimization files, which seems to be a potential performance bug. The root cause of that problem us that while intermod.m and the grab_*modules part of modules.m do similar jobs, they don't use the same mechanisms.) Replace the read_module predicate with the predicates read_module_src and read_module_int, since these now return different types. To avoid having to create AST-type-specialized variants of read_module_ignore_errors and read_module_if_changed, give each of read_module_{src,int} arguments that optionally tell them to ignore errors and/or to read the module only if changed (though the "and" part of "and/or" should not be needed.) These options already existed, but they weren't exported. compiler/timestamp.m: Define the type we use for this option in read_modules. compiler/status.m: New module, containing mostly - stuff carved out of hlds_pred.m, which defines the import_status type, and the predicates that operate on it; - stuff carved out of make_hlds_passes.m, which defines the item_status type and the predicates that operate on that; and - stuff carved out prog_data.m, which defines the section (now module_section) and import_locn types. It also contains the new section kinds we now use to represent item blocks that were imported from interface and optimization files. compiler/parse_tree.m: compiler/notes/compiler_design.html: Add status.m to the parse_tree package. compiler/hlds_pred.m: compiler/prog_data.m: Remove the stuff now in status.m. compiler/error_util.m: Provide a mechanism to control the order of messages with respect to ALL other messages, not just those that also specify ordering. compiler/mercury_to_mercury.m: Provide predicates for printing out parse_tree_* and *_compilation_unit, since printing out a simple item list is no longer enough for debugging. Pretty-print type definitions nicely. Replace a boolean with a purpose-specific enum. compiler/modules.m: Rewrite virtually all this module to make it work on the new AST representations. Generate more detailed error messages for duplicate module inclusions. Note lots of possibilities for further improvements, including in the documentation. Mark places I am still not sure about, especially places where I am not sure *why* the code is doing what it is doing. compiler/module_imports.m: This module stores the data structure in which we accumulate the stuff imported into a compilation unit, i.e. it is in these data structures that a raw_compilation_unit becomes an aug_compilation_unit. Modify the data structure and the predicates that operate on it to work on the new AST representations, not on an (apparently) simple list of items. Avoid ambiguities by adding a prefix to field names. Add some convenience predicates. compiler/module_qual.m: Perform module qualification on both raw lists of items (for use when generating .int3 files) but also on item blocks (for use pretty much in every other situation). Generate warnings about module imports that are unnecessarily in the module interface using the module's context (the context of the `:- module' declaration), not line 1 of the relevant file. compiler/prog_io_error.m: Split some error categories more finely, since some error kinds here actually used to be reported for more than one distinct situation. compiler/prog_io_util.m: Provide utility predicates that operate on nonempty lists. compiler/recompilation.version.m: Make the comparison of the old and new contents of the interface file work on two parse_tree_ints, not on two raw sequences of items. Delete a boolean option that was always `yes', never 'no'. compiler/recompilation.m: Turn some functions into predicates to allow the use of state variable notation. Avoid ambiguities by adding a prefix to field names. compiler/write_module_interface_files.m: Besides updating the code in this module to work on the new parse tree representations, also use cords instead of reversed lists in several cases. Note many possibilities for further improvements. library/list.m: Move the type one_or_more here from the compiler directory, since we now use it in more than one compiler module, and this is its natural home. mdbcomp/sym_name.m: Rename "match_sym_name" to "partial_sym_name_matches_full", since this better describes its job. Add a det version of sym_name_get_module_name. compiler/equiv_type.m: Rename some types to make them more expressive. compiler/accumulator.m: compiler/add_class.m: compiler/add_foreign_enum.m: compiler/add_foreign_proc.m: compiler/add_mode.m: compiler/add_pragma.m: compiler/add_pragma_tabling.m: compiler/add_pred.m: compiler/add_solver.m: compiler/add_special_pred.m: compiler/add_type.m: compiler/assertion.m: compiler/base_typeclass_info.m: compiler/check_typeclass.m: compiler/ctgc.util.m: compiler/dead_proc_elim.m: compiler/dep_par_conj.m: compiler/dependency_graph.m: compiler/deps_map.m: compiler/det_report.m: compiler/elds_to_erlang.m: compiler/equiv_type_hlds.m: compiler/erl_code_gen.m: compiler/export.m: compiler/format_call.m: compiler/higher_order.m: compiler/hlds_data.m: compiler/hlds_module.m: compiler/hlds_out_pred.m: compiler/inst_check.m: compiler/intermod.m: compiler/item_util.m: compiler/lambda.m: compiler/lco.m: compiler/make.module_dep_file.m: compiler/make_hlds.m: compiler/make_hlds_error.m: compiler/make_hlds_passes.m: compiler/make_tags.m: compiler/mercury_compile.m: compiler/ml_proc_gen.m: compiler/ml_type_gen.m: compiler/mode_errors.m: compiler/oisu_check.m: compiler/par_loop_control.m: compiler/polymorphism.m: compiler/post_term_analysis.m: compiler/post_typecheck.m: compiler/pred_table.m: compiler/prog_io_dcg.m: compiler/prog_io_find.m: compiler/prog_io_pragma.m: compiler/prog_io_sym_name.m: compiler/prog_io_type_defn.m: compiler/prog_io_typeclass.m: compiler/prop_mode_constraints.m: compiler/push_goals_together.m: compiler/qual_info.m: compiler/recompilation.check.m: compiler/recompilation.usage.m: compiler/simplify_proc.m: compiler/smm_common.m: compiler/special_pred.m: compiler/ssdebug.m: compiler/stm_expand.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.versions.m: compiler/structure_sharing.analysis.m: compiler/structure_sharing.domain.m: compiler/table_gen.m: compiler/term_constr_initial.m: compiler/term_constr_main.m: compiler/termination.m: compiler/trace_params.m: compiler/trans_opt.m: compiler/type_class_info.m: compiler/type_ctor_info.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/typecheck_info.m: compiler/unify_proc.m: compiler/untupling.m: compiler/unused_args.m: compiler/unused_imports.m: compiler/write_deps_file.m: compiler/xml_documentation.m: Conform to the changes above. tests/hard_coded/higher_order_func_test.m: tests/hard_coded/higher_order_syntax.m: Avoid a warning about importing a module in the interface, not the implementation. tests/invalid/after_end_module.err_exp: tests/invalid/any_mode.err_exp: tests/invalid/bad_end_module.err_exp: tests/invalid/bigtest.err_exp: tests/invalid/bug113.err_exp: tests/invalid/duplicate_modes.err_exp: tests/invalid/errors.err_exp: tests/invalid/errors1.err_exp: tests/invalid/errors2.err_exp: tests/invalid/funcs_as_preds.err_exp: tests/invalid/inst_list_dup.err_exp: tests/invalid/invalid_main.err_exp: tests/invalid/missing_interface_import2.err_exp: tests/invalid/no_exports.err_exp: tests/invalid/occurs.err_exp: tests/invalid/predmode.err_exp: tests/invalid/prog_io_erroneous.err_exp: tests/invalid/type_inf_loop.err_exp: tests/invalid/typeclass_missing_det_3.err_exp: tests/invalid/typeclass_test_11.err_exp: tests/invalid/types.err_exp: tests/invalid/undef_inst.err_exp: tests/invalid/undef_mode.err_exp: tests/invalid/undef_type.err_exp: tests/invalid/unicode1.err_exp: tests/invalid/unicode2.err_exp: tests/invalid/vars_in_wrong_places.err_exp: tests/warnings/unused_import.exp: tests/warnings/unused_interface_import.exp: Update the expected outputs in the invalid and warnings directories to account for one or more of the following five changes. Error messages that warn about a module not exporting anything used to always refer to line 1 of the module's source file. Now expect these messages to refer to the actual context of the module, which is the context of its `:- module' declaration. Expect a similarly updated context for messages that warn about unnecessarily importing modules in the interface, not in the implementation. Expect a similarly updated context for messages that warn about importing a module via both `:- import_module' and `:- use_module'. For the modules that follow the `:- module' declaration directly with code, also expect an error message about the missing section marker. For modules that have terms after the `:- end_module' declaration, replace "end_module" with "`:- end_module'" in the error message. tests/invalid/func_class.{m,err_exp}: New test case. It is a copy of the old tests/valid/func_class.m, which is missing more than one module marker. The expected output is what I think we should generate. The test case currently fails, because we currently print only a subset of the expected errors. I am pretty sure the reason for that is that old code I have not modified simply throws away the missing error messages. Fixing this is work for the near future. tests/invalid/Mmakefile: Enable the new test case. tests/misc_tests/pretty_print_test.exp: Expect the pretty-printed output to use four-space indentation, per our current style guide, since the compiler now generates such output. tests/misc_tests/pretty_print_test.m: Clean up the source code of the test as well. tests/valid/complicated_unify.m: tests/valid/det_switch.m: tests/valid/easy_nondet_test.m: tests/valid/error.m: tests/valid/func_class.m: tests/valid/func_int_bug_main.m: tests/valid/higher_order.m: tests/valid/higher_order2.m: tests/valid/implied_mode.m: tests/valid/indexing.m: tests/valid/multidet_test.m: tests/valid/nasty_func_test.m: tests/valid/semidet_disj.m: tests/valid/stack_alloc.m: tests/valid/switches.m: Add missing section markers to these modules. They used to follow the `:- module' declaration directly with code.	2015-07-21 04:06:52 +10:00
Zoltan Somogyi	fdd141bf77	Clean up the tests in the other test directories. ... tests/invalid/*.{m,err_exp}: tests/misc_tests/*.m: tests/mmc_make/*.m: tests/par_conj/*.m: tests/purity/*.m: tests/stm/*.m: tests/string_format/*.m: tests/structure_reuse/*.m: tests/submodules/*.m: tests/tabling/*.m: tests/term/*.m: tests/trailing/*.m: tests/typeclasses/*.m: tests/valid/*.m: tests/warnings/*.{m,exp}: Make these tests use four-space indentation, and ensure that each module is imported on its own line. (I intend to use the latter to figure out which subdirectories' tests can be executed in parallel.) These changes usually move code to different lines. For the tests that check compiler error messages, expect the new line numbers. browser/cterm.m: browser/tree234_cc.m: Import only one module per line. tests/hard_coded/boyer.m: Fix something I missed.	2015-02-16 12:32:18 +11:00
Zoltan Somogyi	11f2a2e9ee	Print better contexts for module qualification errors. ... Specifically, when we find undefined types in type definitions, say WHERE the undefined type is (both as line number and as function symbol/arg number, and field name if present), since the body of the type definition is sometimes quite big. compiler/module_qual.m: When module qualification found an error, it used to get the context it printed for the error from the mq_info structure, which also contained the rest of the state of the qualification process. The drawback of this setup is that the mq_info's record of the error context was updated only in a few of the places where that context actually changed. This diff takes the error context out of the mq_info, and passes it as a separate argument to the predicates that need it. This makes it really visible if a context is passed onward unchanged even when it should be updated. Fix some of these places, and mark the rest with XXXs. When printing error messages about predicate or function declarations, the message talked about definitions, not declarations. Fix that. Put a prog_context inside each function symbol of mq_error_context; don't require the creation of a separate memory cell for a pair to link the mq_error_context with the prog_context. Factor out some common code. compiler/prog_data.m: I tried to put a context inside constraints for use in error contexts in module_qual.m, but that turned out to be a bad idea. Document why. compiler/add_class.m: compiler/equiv_type.m: compiler/goal_util.m: compiler/higher_order.m: compiler/hlds_data.m: compiler/post_typecheck.m: compiler/pred_table.m: compiler/prog_io_typeclass.m: compiler/prog_type.m: compiler/recompilation.usage.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/typecheck.m: compiler/typeclasses.m: compiler/unused_imports.m: compiler/write_module_interface_files.m: compiler/xml_documentation.m: Clean up some code dealing with constraints. I did this cleanup while adding contexts to constraints, a change I then had to undo. tests/invalid/builtin_int.err_exp: tests/invalid/errors.err_exp: tests/invalid/errors1.err_exp: tests/invalid/fundeps_vars.err_exp: tests/invalid/missing_interface_import.err_exp: tests/invalid/missing_interface_import2.err_exp: tests/invalid/test_nested.err_exp: tests/invalid/transitive_import.err_exp: tests/invalid/undef_type.err_exp: tests/invalid/undef_type_mod_qual.err_exp: tests/recompilation/add_type_re.err_exp.2: tests/recompilation/remove_type_re.err_exp.2: Update these expected output files to match the better messages we now generate.	2015-01-01 15:19:56 +11:00
Julien Fischer	6682cc0a44	Improve the wording of some error messages. ... Use the word "corresponding" instead of "preceding" in error messages like: Error: clause for predicate `foo'/0 without preceding `:- pred' declaration. The language imposes no ordering on declarations so there is no sense in which the `:- pred' declaration has to precede the clause. This is doubly true for `:- typeclass' and `:- instance' declarations, which may also occur in different source files from each other. compiler/make_hlds_error.m: compiler/add_class.m: Make the above change. Delete a comment regarding this issue. tests/invalid/*/.err_exp: Update expected error outputs.	2014-08-25 15:02:37 +10:00
Julien Fischer	d5cdd701b1	Further consistency improvements for error and warning messages. ... The two main changes in this commit are: (1) Use the error_util library's decl/1 and pramga_decl/1 format components in more places. (2) Quote type variables that appear in error messages. compiler/error_util.m: Add a version of list_to_pieces/1 that places each of the strings in the input list in single quotes. compiler/prog_io_type_defn.m: Quote type variables names in error messages. compiler/add_class.m: compiler/add_pragma.m: compiler/add_pred.m: compiler/check_typeclass.m: compiler/make_hlds_error.m: compiler/post_typecheck.m: compiler/prog_io.m: Use the error_util library's decl/1 and pragma_decl/1 format components in more places. compiler/mode_errors.m: Quote program variables and insts in some error messages. compiler/post_term_analysis.m: Format a type ctor and arity in an error message properly. tests/invalid/*.err_exp: tests/warnings/*.exp: Conform to the above changes.	2014-07-30 23:09:39 +10:00
Julien Fischer	12503b84f3	Do not hardcode quoting style in error messages. ... Replace spots in error message specs. where single quotes are hardcoded as `' with the error_util library's quote/1 constructor. Fix minor issues with some error messages and add a couple of XXX comments about some others. compiler/accumulator.m: compiler/add_clause.m: compiler/add_pragma.m: compiler/add_pred.m: compiler/add_type.m: compiler/det_analysis.m: compiler/det_report.m: compiler/goal_expr_to_goal.m: compiler/make_hlds_error.m: compiler/mercury_compile.m: compiler/mode_errors.m: compiler/modes.m: compiler/modules.m: compiler/options_file.m: compiler/post_typecheck.m: compiler/prog_io.m: compiler/prog_io_pragma.m: compiler/simplify_goal.m: compiler/simplify_proc.m: compiler/term_constr_errors.m: compiler/term_errors.m: compiler/termination.m: compiler/typecheck.m: compiler/typecheck_errors.m: As above. tests/invalid/errors.err_exp: tests/invalid/missing_det_decl.err_exp: tests/invalid/no_exports.err_exp: tests/invalid/predmode.err_exp: tests/invalid/undef_type.err_exp: Conform to the above changes.	2014-07-28 12:09:44 +10:00
Zoltan Somogyi	8e8281ce7b	Represent ":- module" and ":- end_module" items using purpose-specific kinds of ... Estimated hours taken: 8 Branches: main Represent ":- module" and ":- end_module" items using purpose-specific kinds of items, instead of as part of the generic "module_defn" item kind. This is in preparation for a diff that would return submodules as separate entities in their own right, instead of as an embedded sequence of items that happen to start with a :- module item and end with an optional :- end_module item. Also as preparation, make missing a ":- module" declaration at the start of a source file an error instead of a warning. compiler/prog_item.m: Change the type representing items. compiler/prog_io.m: Conform to the change above, make missing module declarations into an error, and simplify some code. compiler/equiv_type.m: compiler/make_hlds_passes.m: compiler/mercury_to_mercury.m: compiler/module_qual.m: compiler/modules.m: compiler/recompilation.check.m: compiler/recompilation.version.m: Conform to the change above. Where relevant, turn chains of if-then-elses on item types into switches. compiler/inst.m: Make the module name in the module declaration match the module name. tests/invalid/big_test.err_exp: tests/invalid/errors.err_exp: tests/invalid/typeclass_test_1.err_exp: Update the expected error messages. tests/valid/inhibit_warn_test.m: To keep this test case valid, don't omit the ":- module" declaration.	2009-11-05 06:34:49 +00:00
Zoltan Somogyi	cc1711071e	Make all the pre-HLDS and front-end passes of the compiler gather up ... Estimated hours taken: 50 Branches: main Make all the pre-HLDS and front-end passes of the compiler gather up all their error messages and print them all at once, in sorted order, unless the user asked for progress messages, in which case we print all the errors accumulated so far just before each printing each progress message. This should make error message output significantly easier to interpret. compiler/module_imports.m: Add a new field to the module_imports structure (the main pre-HLDS representation of the parse tree) to hold the list of error messages generated so far. Rename the module_imports structure as the module_and_imports structure, since it holds the module's items as well as information about its imports. Update the access predicates to encourage getting the items, the error messages and the error indication all at once. Add mechanisms for updating the error indication and the error messages. Add a distinguishing prefix to the field names of the structure. compiler/error_util.m: compiler/hlds_error_util.m: Add facilities for printing error messages in batches. In error_util.m, delete an unused argument from several predicates. compiler/mercury_compile.m: compiler/intermod.m: Gather up error messages to print in batches. In the parts of the code affected by the above, explicitly pass around a globals structure, instead of having all the predicates get it of the I/O state. Since some code (e.g. the start recompilation system) still uses the copy in the I/O state, we ensure that this copy is kept in sync with the explicitly passed around copy. Rename some predicates to avoid ambiguities. compiler/modules.m: Return errors in the module_and_imports structure, not separately. Gather up error messages to print in batches. Explicitly pass around globals structures. compiler/read_modules.m: Rename the read_modules type to have_read_module_map, since this is more explicit. For each module we have already read, remember not just the items we read from it, but also the error messages we generated during the reading. This is so these error messages can be printed together with other errors from other sources. Explicitly pass around globals structures. compiler/prog_io.m: compiler/purity.m: compiler/stratify.m: Rename several predicates to avoid ambiguities. compiler/modes.m: Change the interface of the main predicate to avoid the need for a lambda expression in mercury_compile.m. compiler/recompilation.check.m: Add a distinguishing prefix to the field names of a structure. Fix a wrong definition of this_file. Conform to the changes above. compiler/compiler_target_code.m: compiler/deps_map.m: compiler/make.m: compiler/make.dependencies.m: compiler/make.module_dep_file.m: compiler/make.module_target.m: compiler/make.program_target.m: compiler/make.util.m: compiler/make_hlds.m: compiler/make_hlds_passes.m: compiler/trans_opt.m: compiler/write_deps_file.m: Conform to the changes above. compiler/add_clause.m: compiler/add_pragma.m: compiler/state_var.m: Add an import of io, since their parent make_hlds.m does not import io anymore. In add_pragma, update an error message that did not mention trseg as well as tr as indicating a trailing grade. tests/hard_coded/Mmakefile: Move two tests that cannot pass in debug grades due to the lack of tail recursion to the list containing the other tests with this property. tests/invalid/test_feature_set.err_exp: Update the expected output of this test to expect the updated error message from add_pragma. tests/invalid/test_feature_set.err_exp2: Add this file as the expected output for trailing grades. tests/invalid/*.err_exp: tests/warnings/*.err_exp: Update the expected output for many tests to expect the error messages in sorted order.	2009-08-14 20:37:57 +00:00
Zoltan Somogyi	cc42c8fac5	Switch to using error_util to generate error message during the process of ... Estimated hours taken: 40 Branches: main Switch to using error_util to generate error message during the process of converting terms to prog_items. In many predicates, we used to return error messages as a string/term pair, with the string being the error message and a term, which both provided the context and was printed after the message. We now return error indications as lists of error_specs. These include a printout of the relevant term only if this helps users understand the nature or the location of the error. To make the printouts easier to understand we print variable names in them using the applicable varsets. (The old version of the compiler used to print each error term long after it lost track of the right varset, and thus used a dummy varset that yielded error messages referring to _1, _2 etc instead of the variable names used by the programmer.) Sometimes the callers of some parse predicates prepended other strings indicating the context of the error in front of the error string. This diff changes things so that now the caller instead passes a list of format components describing the context to the predicates that construct the error_specs. In some places, simplify the code, e.g. by factoring out common code, and by inlining some auxiliary predicates (we used to need these auxiliary predicates for indexing when we executed the compiler using Prolog, but those days are long past). Mark with XXXs places where I think the error messages or their contexts could be improved, and places where the structure of the code could be improved. compiler/prog_io_util.m: Change the representation of the maybeN types to use error_spec lists. compiler/prog_io.m: compiler/prog_io_dcg.m: compiler/prog_io_goal.m: compiler/prog_io_pragma.m: compiler/prog_io_typeclass.m: compiler/prog_io_util.m: Change the way we generate error messages along the lines described at the top. In several cases, this required adding extra arguments (varsets, context descriptions) to predicates for use in error messages. Some of these predicates were also used in contexts where the caller was interested only in success, and would ignore any error messages. In these cases, add a version of the predicate that does not require the extra arguments, and which is semidet (to allow the caller to avoid a test for ok). compiler/error_util.m: Add a mechanism for changing the case of the next format_component, to allow an error message to be appended to a list of format_components providing the context that generates good-looking output whether or not that context is empty. Replace some bools with purpose-specific types. Make sort_error_specs internal to the module, since outside modules should never need to use it. Use cords instead of reversed lists to simplify some parts of the internal implementation. compiler/mercury_to_mercury.m: Provide a mechanism to print out terms only if they aren't too big, for use in our error messages. compiler/prog_item.m: Delete the message_list type, and note a future improvement. compiler/prog_out.m: Delete the predicates for printing message_lists. compiler/intermod.m: compiler/modules.m: Change the way we print out error messages along the lines described at the top. compiler/add_clause.m: compiler/field_access.m: compiler/recompilation.check.m: compiler/recompilation.version.m: compiler/superhomogeneous.m: Conform to the changes above by modifying how we generate error messages. compiler/add_class.m: compiler/add_pragma.m: compiler/check_typeclass.m: compiler/common.m: compiler/make.module_dep_file.m: compiler/make_hlds_error.m: compiler/make_hlds_passes.m: compiler/mercury_compile.m: compiler/mode_errors.m: compiler/modes.m: compiler/options_file.m: compiler/prog_ctgc.m: compiler/prog_event.m: compiler/purity.m: compiler/trans_opt.m: compiler/typecheck.m: Trivial updates to conform to the changes above. compiler/prog_data.m: Add some field names and access functions for use in the modules above. library/list.m: Add list.contains, which is list.member with the arguments reversed to make it possibly to partially apply it. tests/invalid/bad_finalise_decl.err_exp: tests/invalid/bad_initialise_decl.err_exp: tests/invalid/bad_mutable.err_exp: tests/invalid/bigtest.err_exp: tests/invalid/conflicting_fs.err_exp: tests/invalid/constrained_poly_insts.err_exp: tests/invalid/errors.err_exp: tests/invalid/func_errors.err_exp: tests/invalid/fundeps_unbound_in_ctor.err_exp: tests/invalid/fundeps_vars.err_exp: tests/invalid/impl_def_literal_syntax.err_exp: tests/invalid/inst_list_dup.err_exp: tests/invalid/invalid_typeclass.err_exp: tests/invalid/kind.err_exp: tests/invalid/null_char.err_exp: tests/invalid/pragma_source_file.err_exp: tests/invalid/predmode.err_exp: tests/invalid/reserve_tag.err_exp: tests/invalid/some.err_exp: tests/invalid/specified.err_exp: tests/invalid/trace_goal_env.err_exp: tests/invalid/type_vars.err_exp: tests/invalid/typeclass_test_1.err_exp: tests/invalid/typeclass_test_11.err_exp: tests/invalid/typeclass_test_2.err_exp: tests/invalid/unbound_type_vars.err_exp: tests/invalid/unicode1.err_exp: tests/invalid/unicode2.err_exp: tests/invalid/uu_type.err_exp: tests/invalid/vars_in_wrong_places.err_exp: tests/invalid/with_type.err_exp: tests/invalid/purity/purity_nonsense2.err_exp: Update the expected error messages.	2008-07-16 03:31:03 +00:00
Zoltan Somogyi	f070e2a1b7	Convert the make_hlds stage of the compiler from printing out error messages ... Estimated hours taken: 14 Branches: main Convert the make_hlds stage of the compiler from printing out error messages one at a time to gathering them all up and printing them all at once after sorting and deleting duplicates. This approach makes it much easier to be consistent about updating the exit status in the I/O state and the error count in the module info, and indeed this diff fixes some bugs in this area. This approach also means that instead of threading a pair of I/O states through these modules, we now mostly thread through a list of error specifications. In a couple of places, we create the I/O states we need for printing progress messages using trace goals. configure.in: Check that the installed compiler supports trace goals (perhaps with warnings), since the compiler now uses them. compiler/Mercury.options: Temporarily compensate for a bug in the handling of trace goals. compiler/add_class.m: compiler/add_clause.m: compiler/add_mode.m: compiler/add_pragma.m: compiler/add_pred.m: compiler/add_solver.m: compiler/add_type.m: compiler/field_access.m: compiler/foreign.m: compiler/make_hlds_error.m: compiler/make_hlds_passes.m: compiler/make_hlds_warn.m: compiler/module_qual.m: compiler/modules.m: compiler/qual_info.m: compiler/state_var.m: compiler/superhomogeneous.m: Make the change described at the top. In many cases, this required changing code to error util instead of io.write_strings to create the error messages. In some cases, move a predicate used in one module but defined in another module to the first module. Delete some predicates whose job used to be to test options to see whether a message should be generated, since we can now embed the option value that a message depends on in the error message itself. In module_qual.m, remove unnecessary module qualifications. In modules.m, give explicit names to a bunch of lambda expressions. Reformat comments to exploit the available columns. compiler/check_typeclass.m: Conform to the changes above. Mark with XXX the places where we are ignoring the proper update of the error count in module_infos. compiler/modes.m: compiler/post_typecheck.m: compiler/stratify.m: compiler/table_gen.m: compiler/unused_args.m: Use error_specs instead of plain pieces to print error messages. compiler/options.m: Rename an option that conflicts with a language keyword. compiler/handle_options.m: Conform to the change to options.m. compiler/prog_data.m: Rename some function symbols that conflict with language keywords. compiler/prog_out.m: compiler/prog_io_util.m: Conform the change above, and delete some predicates that have now become unused. compiler/mercury_compile.m: Rename a predicate to avoid an ambiguity. Conform to the changes above. compiler/hlds_out.m: compiler/make.module_dep_file.m: compiler/make_hlds.m: compiler/mercury_to_mercury.m: compiler/mode_errors.m: compiler/prog_io.m: Conform to the changes above. In some cases, delete predicates that aren't needed anymore. tests/invalid/errors.err_exp: tests/invalid/errors1.err_exp: tests/invalid/state_vars_test3.err_exp: tests/invalid/undef_inst.err_exp: Update this expected output to reflect the fact that we now sort the error messages. tests/invalid/missing_interface_import2.err_exp: tests/warnings/double_underscore.exp: Update this expected output to reflect the fact that we no longer print the same error message twice. tests/invalid/missing_det_decls.err_exp: Update this expected output to reflect the fact that we now indent an error messages correctly. tests/invalid/multimode_syntax.err_exp: Update this expected output to reflect the fact that we now use error_util instead of plain io.writes to create an error message. tests/invalid/typeclass_test.err_exp: tests/invalid/unsatisfiable_constraint.err_exp: Update this expected output to reflect minor improvements in the formatting of an error message.	2006-09-10 23:39:17 +00:00
Zoltan Somogyi	5eee81204e	A big step towards cleaning up the way we handle errors. ... Estimated hours taken: 28 Branches: main A big step towards cleaning up the way we handle errors. The main changes are - the provision, in error_util.m, of a mechanism for completely specifying everything to do with a single error in one data structure, - the conversion of typecheck_errors.m from using io.write_string to using this new capability, - the conversion of mode_errors.m and det_report.m from using write_error_pieces to using this new capability, and - consistently using the quoting style `symname'/N instead of `symname/N' in error_util and hlds_error_util (previously, error_util used the former but hlds_error_util used the latter). This diff sets up later diffs which will collect all error specifications in a central place and print them all at once, in order. compiler/error_util.m: The new type error_spec, which completely specifies an error. An error_spec may have multiple components with different contexts and may have parts which are printed only under certain conditions, e.g. a given option being set. Each error_spec has a severity and also records which phase found the error. The new predicate write_error_spec takes care of updates of the exit status for errors and (if --halt-at-warn is set) for warnings. It also takes care of setting the flag that calls for the reminder about -E at the end. This diff also makes it simpler to use the ability to print arbitrary output. It adds the ability to include integers in messages directly, and the ability to create blank lines. It renames some function symbols to avoid ambiguities. Move a predicate that only used by typecheck_errors.m to that file. compiler/hlds_error_util.m: Switch to the `symname'/N quoting style for describing predicates and procedures. compiler/prog_util.m: Switch to the `symname'/N quoting style for describing sym_name_and_arity. compiler/hlds_module.m: Provide a predicate to increment the number of errors not by one, but by the number of errors printed by write_error_spec. Fix some documentation rot. compiler/typecheck_errors.m: Use write_error_spec instead of io.write_strings to print error messages. In several cases, improve the formatting of the messages printed. Mark a number of places where we don't (yet) update the number of errors in the module_info correctly. Rename the checkpoint predicate to avoid potential ambiguity with similar predicates in e.g. mode_info. compiler/typecheck_info.m: Group the code for writing stuff out together in one bunch. For each such predicate, create another that returns a list of format components instead of doing I/O directly. compiler/typecheck.m: Move the code for writing inference messages here from typecheck_errors.m, since these messages aren't errors. compiler/mode_errors.m: compiler/det_report.m: Use write_error_spec instead of write_error_pieces. In the case of mode_errors.m, this means we now get correct the set of circumstances in which we set the flag that calls for the reminder about -E. compiler/add_pragma.m: compiler/add_type.m: Convert some code that used to use write_error_pieces to print error messages to use write_error_spec instead. compiler/assertion.m: compiler/hlds_pred.m: compiler/post_typecheck.m: Assertion.m used to contain some code to check for assertions in the interface that mention predicates that are not exported. Move most of this code to post_typecheck.m (which is where this code used to be called from). One small part, which is a test for a particular property of import_statuses, is moved to hlds_pred.m to be with all the other similar tests of import_statuses. compiler/prog_util.m: Change unqualify_name from a predicate to a function. compiler/pred_table.m: compiler/hlds_out.m: Avoid some ambiguities by adding a suffix to the names of some predicates. compiler/*.m: Conform to the changes above. library/list.m: Add a function that was previously present (with different names) in two compiler modules. tests/hard_coded/allow_stubs.exp: Update the format of the expected exception. tests/invalid/errors2.err_exp2: Remove this file. As far as I can tell, it was never the correct expected output on the main branch. (It originated on the alias branch way back in the mists of time.) tests/invalid/*.err_exp: tests/invalid/purity/*.err_exp: tests/warnings/*.exp: Update the format of the expected error messages. tests/recompilation/*.err_exp.2: Update the format of the expected messages about what was modified.	2006-09-07 05:51:48 +00:00
Julien Fischer	835d8315ef	Do not allow discriminated unions with a single zero-arity constructor to have ... Estimated hours taken: 10 Branches: main, release Do not allow discriminated unions with a single zero-arity constructor to have user-defined equality or comparison. Defining such types causes an assertion failure in the compiler because the types are considered to be dummy types and the runtime currently doesn't support (and probably won't ever) d.u. dummy types with user-defined equality or comparison. Fix another bug where the compiler was not printing out the `recompile with -E' prompt at the appropriate time. The bug was caused by the fact that there were several copies of the globals structure and the one that was being checked at the time the prompt was being printed out was not the one that had been updated during the rest of compilation. compiler/add_types.m: Emit an error message if an attempt is made to define a d.u. dummy type with user-defined equality or comparison. compiler/globals.m: Remove the extra_error_info field from the globals structure and turn it into a mutable. Export access predicates for this mutable. The reason for doing this is that the compiler was sometimes looking at the wrong copy of the globals structure when checking the value of this flag - this meant that sometimes the recompile with `-E' prompt was not being displayed. Turning this flag into a mutable avoids the problem because now there is only one copy. compiler/make_hlds.m: s/__/./ in a few spots. doc/reference_manual.texi: Mention the new restrictions on discriminated union types with user-defined equality or comparison. tests/invalid/exported_unify2.m: tests/invalid/exported_unify3.m: Change some types with user-defined equality or comparison so that they are no longer dummy types. These test cases have not been triggering the assertion failure in the compiler because they are only error checked and the assertion that is failing occurs further along in the compilation process. tests/invalid/user_eq_dummy.{m,err_exp}: Test the new error message for dummy types with user-defined equality or comparison. tests/invalid/extra_info_prompt.{m,err_exp}: Test that the recompile with `-E' prompt is being displayed when it should. tests/invalid/Mercury.options: tests/invalid/Mmakefile: Include the new test cases. Where there is a verbose version of the error message compile with `-E'. tests/recompilation/add_type_re.err_exp.2: tests/invalid/*.err_exp: Update expected outputs to conform to the above.	2006-06-14 08:15:01 +00:00
Julien Fischer	18c0510231	Improve the formatting of some error messages by using error_util ... Estimated hours taken: 2 Branches: main Improve the formatting of some error messages by using error_util and hlds_error_util to handle the formatting of the error messages. compiler/error_util.m: Add a new format component `quote', which is identical to `fixed' except that it outputs it's argument surrounded by `' quotes. compiler/add_clause.m: compiler/add_type.m: compiler/make_hlds_passes.m: compiler/options_file.m: compiler/qual_info.m: compiler/stratify.m: Use the error_util to format warning/error messages rather than doing it manually. compiler/passes_aux.m: complier/hlds_out.m: Update comments. tests/invalid/errors.err_exp: tests/invalid/errors1.err_exp: tests/invalid/multimode_dcg.err_exp: tests/invalid/multimode_syntax.err_exp: tests/invalid/sub_c.err_exp: tests/invalid/types.err_exp: Update the expected outputs of these test cases to account for formatting changes introduced by the above. tests/warnings/Mmakefile: tests/warnings/Mercury.options: tests/warnings/non_stratification.{exp,m}: Add a test case for the `--warn-non-stratification' option.	2006-02-27 06:57:06 +00:00
Julien Fischer	e069d16ab1	Do not display the For more information try recompiling with -E'' prompt ... Estimated hours taken: 1.5 Branches: main Do not display the `For more information try recompiling with `-E'' prompt unless we really mean it, i.e. there is actually more information available. XXX This change is incomplete for the mode_errors module because that module requires more substantial changes to make this work - I'll do that as a separate diff. compiler/globals.m Add a new global (and access predicates) that keeps track of whether we have any verbose error information that could be displayed if we recompiled with `-E'. compiler/mercury_compile.m Check the new global flag before prompting the user to recompile with `-E'. compiler/mode_errors.m Add an XXX comment about needing to respect the extra error info flag properly. compiler/accumulator.m compiler/add_clause.m compiler/add_pred.m compiler/add_type.m compiler/assertion.m compiler/check_typeclass.m compiler/det_report.m compiler/magic_util.m compiler/make_hlds_error.m compiler/modes.m compiler/module_qual.m compiler/modules.m compiler/post_typecheck.m compiler/purity.m compiler/stratify.m compiler/typecheck_errors.m Set the new global flag when we come across an error for which we have a verbose error message. tests/recompilation/*: tests/invalid/*: Update expected error files.	2005-09-14 05:27:11 +00:00
Zoltan Somogyi	a65ad5dcb6	Allow simple_call_ids to be formatted by the predicates of error_util.m, ... Estimated hours taken: 6 Branches: main Allow simple_call_ids to be formatted by the predicates of error_util.m, and convert the error messages in some submodules of make_hlds.m to use this capability. compiler/hlds_pred.m: compiler/prog_data.m: Move the simple_call_id type from hlds_pred to prog_data, since error_util shouldn't import any HLDS modules. compiler/hlds_out.m: compiler/prog_out.m: Move the predicates for printing simple_call_ids from hlds_out to prog_out. Change prog_out.m to four-space indentation to reduce the number of bad line breaks. In prog_out.m, move the relevant comments to the interface, delete unnecessary module qualifications, and delete some long obsolete commented-out code. compiler/error_util.m: Add simple_call_id to the list of format components. Change to four-space indentation to reduce the number of bad line breaks. Conform to the standard format for comments. compiler/add_pragma.m: compiler/make_hlds_passes.m: compiler/make_hlds_warn.m: Use the new capability to convert some error reporting code to use error_util. compiler/*.m: Conform to the changes above, mostly by deleting now incorrect module qualifications. tests/invalid/*.err_exp: tests/warnings/*.err_exp: Expect the new, better formatted error messages. tests/invalid/Mmakefile: Fix some too-long lines in comments.	2005-08-08 02:33:19 +00:00
Zoltan Somogyi	10c8d88223	Convert this module to our current coding style. ... Estimated hours taken: 6 Branches: main compiler/module_qual.m: Convert this module to our current coding style. Use state variables where appropriate. Reorder arguments as required to allow the use of state variables. Use error_util instead of io__write_string to print error messages. Use predmode declarations where possible. Use . as the module name separator. There are no algorithmic changes except for the use of error_util. compiler/middle_rec.m: Convert this module to our current coding style. Use predmode declarations where possible. compiler/make_hlds.m: compiler/mercury_compile.m: Conform to changed argument orders of predicates in module_qual.m. compiler/error_util.m: Add a new version of the utility predicate that puts commas and "and"s between elements of a list. Fix an old bug: when printing a symname/arity pair, put quotes around only the symname part. tests/invalid/*.err_exp: tests/invalid/purity/*.err_exp: tests/recompilation/*.err_exp.2: tests/warning/*.exp: Update the expected error messages to reflect the better wrapping we get from error_util, and in some cases to reflect the fixed code for quotes around symnames.	2005-03-20 02:24:48 +00:00
Zoltan Somogyi	bd9e060cef	Update a large part of this module to use error_util to generate error ... Estimated hours taken: 4 Branches: main compiler/make_hlds.m: Update a large part of this module to use error_util to generate error messages. Switch to four-space indentation to reduce the number of places with awkward indentation. tests/invalid/*.err_exp: tests/invalid/purity/*.err_exp: Update these expected output files to expect the new format of error messages.	2005-02-14 08:26:42 +00:00
Zoltan Somogyi	c91313b32f	Bring these modules up to date with our current coding style. ... Estimated hours taken: 8 Branches: main compiler/modules.m: compiler/compile_target_code.m: compiler/handle_options.m: compiler/bytecode_data.m: compiler/prog_io_util.m: Bring these modules up to date with our current coding style. Use predmode declarations and state variable syntax where appropriate. Fix inconsistent indentation. Print more error messages using error_util.m for printing error messages. compiler/trace_param.m: Add a new predicate for use by the updated code in handle_options.m. compiler/error_util.m: compiler/hlds_error_util.m: Make error_util.m to be a submodule of parse_tree.m, not hlds.m. Most of its predicates are not dependent on HLDS data structures. Move the ones that are into a new module, hlds_error_util, that is a submodule of hlds.m. Overall, this reduces the dependence of submodules of parse_tree.m, including modules.m, on submodules of hlds.m. compiler/notes/compiler_design.html: Update the documentation of compiler modes to account for hlds_error_util.m. compiler/hlds.m: compiler/parse_tree.m: Update the list of included submodules. compiler/*.m: Update module imports and module qualifications as needed for the change above. tests/invalid/*.{exp,exp2}: Update the expected outputs of a bunch of test cases to reflect the new format of some warning messages due to the user error_util; they now observe line length limits, and print contexts in some cases where they were previously missing.	2004-03-19 10:19:53 +00:00
Ralph Becket	a8ffd3680c	Change the compiler and tools so that .' and not :' is now used as the ... Estimated hours taken: 14 Branches: main Change the compiler and tools so that `.' and not `:' is now used as the module separator in all output. Infix `.' now has associativity yfx and priority 10. NEWS: Report the change. configure.in: Amend the test for an up-to-date Mercury compiler to check whether it recognises `.' as a module qualifier. compiler/code_gen.m: compiler/error_util.m: compiler/hlds_out.m: compiler/prog_out.m: compiler/prog_util.m: compiler/rl_exprn.m: compiler/rl_gen.m: compiler/source_file_map.m: compiler/unused_args.m: library/io.m: library/rtti_implementation.m: library/type_desc.m: runtime/mercury_debug.c: runtime/mercury_deconstruct.c: runtime/mercury_stack_trace.c: Change `:' to `.' as module separator for output. compiler/mercury_to_mercury.m: compiler/prog_io_typeclass.m: As above. Fixed a bug where `.' was not being recognised as a module separator. doc/reference_manual.texi: Report the change. library/term_io.m: Ensure that infix `.' is written without surrounding spaces. tests/hard_coded/dot_separator.m: tests/hard_coded/dot_separator.exp: tests/hard_coded/Mmakefile: Test case added.	2003-01-17 05:57:20 +00:00
Simon Taylor	d96f7a9bd5	Allow declarations of the form ... Estimated hours taken: 40 Branches: main Allow declarations of the form :- pred p `with_type` higher_order_type `with_inst` higher_order_inst. XXX We should allow `with_inst` annotations on higher-order terms. compiler/prog_data.m: Add fields to `pred_or_func' and `pred_or_func_mode' items to hold the `with_type` and `with_inst` annotations. compiler/prog_io.m: compiler/prog_io_typeclass.m: Parse the annotations. compiler/module_qual.m: Module qualify the annotations. compiler/equiv_type.m: Expand away `with_type` and `with_inst`. Report errors. Strip items containing errors from the item list. Record smart recompilation dependencies on the types and modes expanded. Also record a dependency on the arity of predicate and function declarations before expansion. Use error_util for error messages. compiler/mercury_to_mercury.m: Write `with_type` and `with_inst` annotations to interface files. compiler/make_hlds.m: Ignore `with_type` and `with_inst` fields in predicate and function declarations. compiler/recompilation.m: Changes to allow equiv_type.m to record dependencies on arbitrary items, not just types. compiler/recompilation_usage.m: compiler/recompilation_check.m: Allow searches in the sets of used predicates and functions using name, not name and arity, as the key. This is needed because the actual arity of a predicate defined using `with_type` is not known when writing the interface files. compiler/recompilation_version.m: Handle `with_inst` and `with_type`. Pragmas now need to be recorded in the version_numbers even if there is no matching `:- pred' or `:- func' declaration -- the pragma may apply to a predicate or function declared using `with_type`. compiler/mode_util.m: Export inst_subsitute_arg_list for use by equiv_type.m. compiler/error_util.m: Add predicate `pred_or_func_to_string'. library/std_util.m: Add std_util__map_foldl_maybe and std_util__map_foldl2_maybe, which are like list__map_foldl and list__map_foldl2, but apply to the item stored in a value of type std_util__maybe. NEWS: doc/reference_manual.texi: Document the new syntax and library predicates. tests/invalid/Mmakefile: tests/invalid/with_type.m: tests/invalid/with_type.err_exp: tests/invalid/constrained_poly_insts.err_exp: tests/recompilation/TESTS: tests/recompilation/unchanged_with_type_nr*: tests/recompilation/with_type_re*: Test cases. tests/invalid/errors1.err_exp: tests/invalid/type_loop.err_exp: tests/invalid/vars_in_wrong_places.err_exp: Update expected output.	2002-03-15 07:32:27 +00:00
Fergus Henderson	bc05cc9e40	Update the test results to reflect the new variable numbers ... Estimated hours taken: 0.25 tests/invalid/errors.err_exp: tests/invalid/vars_in_wrong_places.err_exp: Update the test results to reflect the new variable numbers printed out by term_io__write_term.	1998-11-12 03:36:57 +00:00
Fergus Henderson	66cf5dc7be	Update the test results to reflect the new warnings ... Estimated hours taken: 0.25 tests/invalid/*.err_exp: Update the test results to reflect the new warnings about modules with no exports.	1998-10-30 04:38:48 +00:00
Fergus Henderson	11d8161692	Add support for nested modules. ... Estimated hours taken: 50 Add support for nested modules. - module names may themselves be module-qualified - modules may contain `:- include_module' declarations which name sub-modules - a sub-module has access to all the declarations in the parent module (including its implementation section). This support is not yet complete; see the BUGS and LIMITATIONS below. LIMITATIONS - source file names must match module names (just as they did previously) - mmc doesn't allow path names on the command line any more (e.g. `mmc --make-int ../library/foo.m'). - import_module declarations must use the fully-qualified module name - module qualifiers must use the fully-qualified module name - no support for root-qualified module names (e.g. `:parent:child' instead of `parent:child'). - modules may not be physically nested (only logical nesting, via `include_module'). BUGS - doesn't check that the parent module is imported/used before allowing import/use of its sub-modules. - doesn't check that there is an include_module declaration in the parent for each module claiming to be a child of that parent - privacy of private modules is not enforced ------------------- NEWS: Mention that we support nested modules. library/ops.m: library/nc_builtin.nl: library/sp_builtin.nl: compiler/mercury_to_mercury.m: Add `include_module' as a new prefix operator. Change the associativity of `:' from xfy to yfx (since this made parsing module qualifiers slightly easier). compiler/prog_data.m: Add new `include_module' declaration. Change the `module_name' and `module_specifier' types from strings to sym_names, so that module names can themselves be module qualified. compiler/modules.m: Add predicates module_name_to_file_name/2 and file_name_to_module_name/2. Lots of changes to handle parent module dependencies, to create parent interface (`.int0') files, to read them in, to output correct dependencies information for them to the `.d' and `.dep' files, etc. Rewrite a lot of the code to improve the readability (add comments, use subroutines, better variable names). Also fix a couple of bugs: - generate_dependencies was using the transitive implementation dependencies rather than the transitive interface dependencies to compute the `.int3' dependencies when writing `.d' files (this bug was introduced during crs's changes to support `.trans_opt' files) - when creating the `.int' file, it was reading in the interfaces for modules imported in the implementation section, not just those in the interface section. This meant that the compiler missed a lot of errors. library/graph.m: library/lexer.m: library/term.m: library/term_io.m: library/varset.m: compiler/*.m: Add `:- import_module' declarations to the interface needed by declarations in the interface. (The previous version of the compiler did not detect these missing interface imports, due to the above-mentioned bug in modules.m.) compiler/mercury_compile.m: compiler/intermod.m: Change mercury_compile__maybe_grab_optfiles and intermod__grab_optfiles so that they grab the opt files for parent modules as well as the ones for imported modules. compiler/mercury_compile.m: Minor changes to handle parent module dependencies. (Also improve the wording of the warning about trans-opt dependencies.) compiler/make_hlds.m: compiler/module_qual.m: Ignore `:- include_module' declarations. compiler/module_qual.m: A couple of small changes to handle nested module names. compiler/prog_out.m: compiler/prog_util.m: Add new predicates string_to_sym_name/3 (prog_util.m) and sym_name_to_string/{2,3} (prog_out.m). compiler/*.m: Replace many occurrences of `string' with `module_name'. Change code that prints out module names or converts them to strings or filenames to handle the fact that module names are now sym_names intead of strings. Also change a few places (e.g. in intermod.m, hlds_module.m) where the code assumed that any qualified symbol was fully-qualified. compiler/prog_io.m: compiler/prog_io_goal.m: Move sym_name_and_args/3, parse_qualified_term/4 and parse_qualified_term/5 preds from prog_io_goal.m to prog_io.m, since they are very similar to the parse_symbol_name/2 predicate already in prog_io.m. Rewrite these predicates, both to improve maintainability, and to handle the newly allowed syntax (module-qualified module names). Rename parse_qualified_term/5 as `parse_implicit_qualified_term'. compiler/prog_io.m: Rewrite the handling of `:- module' and `:- end_module' declarations, so that it can handle nested modules. Add code to parse `include_module' declarations. compiler/prog_util.m: compiler/*.m: Add new predicates mercury_public_builtin_module/1 and mercury_private_builtin_module/1 in prog_util.m. Change most of the hard-coded occurrences of "mercury_builtin" to call mercury_private_builtin_module/1 or mercury_public_builtin_module/1 or both. compiler/llds_out.m: Add llds_out__sym_name_mangle/2, for mangling module names. compiler/special_pred.m: compiler/mode_util.m: compiler/clause_to_proc.m: compiler/prog_io_goal.m: compiler/lambda.m: compiler/polymorphism.m: Move the predicates in_mode/1, out_mode/1, and uo_mode/1 from special_pred.m to mode_util.m, and change various hard-coded definitions to instead call these predicates. compiler/polymorphism.m: Ensure that the type names `type_info' and `typeclass_info' are module-qualified in the generated code. This avoids a problem where the code generated by polymorphism.m was not considered type-correct, due to the type `type_info' not matching `mercury_builtin:type_info'. compiler/check_typeclass.m: Simplify the code for check_instance_pred and get_matching_instance_pred_ids. compiler/mercury_compile.m: compiler/modules.m: Disallow directory names in command-line arguments. compiler/options.m: compiler/handle_options.m: compiler/mercury_compile.m: compiler/modules.m: Add a `--make-private-interface' option. The private interface file `<module>.int0' contains all the declarations in the module; it is used for compiling sub-modules. scripts/Mmake.rules: scripts/Mmake.vars.in: Add support for creating `.int0' and `.date0' files by invoking mmc with `--make-private-interface'. doc/user_guide.texi: Document `--make-private-interface' and the `.int0' and `.date0' file extensions. doc/reference_manual.texi: Document nested modules. util/mdemangle.c: profiler/demangle.m: Demangle names with multiple module qualifiers. tests/general/Mmakefile: tests/general/string_format_test.m: tests/general/string_format_test.exp: tests/general/string__format_test.m: tests/general/string__format_test.exp: tests/general/.cvsignore: Change the `:- module string__format_test' declaration in `string__format_test.m' to `:- module string_format_test', because with the original declaration the `__' was taken as a module qualifier, which lead to an error message. Hence rename the file accordingly, to avoid the warning about file name not matching module name. tests/invalid/Mmakefile: tests/invalid/missing_interface_import.m: tests/invalid/missing_interface_import.err_exp: Regression test to check that the compiler reports errors for missing `import_module' in the interface section. tests/invalid/*.err_exp: tests/warnings/unused_args_test.exp: tests/warnings/unused_import.exp: Update the expected diagnostics output for the test cases to reflect a few minor changes to the warning messages. tests/hard_coded/Mmakefile: tests/hard_coded/parent.m: tests/hard_coded/parent.child.m: tests/hard_coded/parent.exp: tests/hard_coded/parent2.m: tests/hard_coded/parent2.child.m: tests/hard_coded/parent2.exp: Two simple tests case for the use of nested modules with separate compilation.	1998-03-03 17:48:14 +00:00
Simon Taylor	9a23c8e1ac	Test cases for `:- use_module' ... Estimated hours taken: 0.1 tests/invalid/errors.m tests/invalid/errors2.m Test cases for `:- use_module'	1997-06-29 23:24:38 +00:00
Zoltan Somogyi	c30efafc56	It seems that when I added the runtests files for all the subdirectories ... Estimated hours taken: 3 It seems that when I added the runtests files for all the subdirectories in tests, I did not do a "cvs add" for invalid/runtests (even though the log message says I did). As a consequence, our test runs since then have not exercised the test cases in this directory. This checkin fixes that oversight. runtests: Shell script to exercise the test cases in this directory. qual_basic_test2.*: A test case that was removed from hard_coded a while ago because it was really a test of the error message. *.err_exp: Updated the expected error message outputs for several test cases according to the changes of the last few months. Added two missing .err_exp files. Mmake: Disabled the tests prog_io_erroneous and qualified_cons_id2 since we do not pass them, and I don't know what the expected output ought to be (it should not be what we output now).	1997-04-27 05:28:58 +00:00
Zoltan Somogyi	64b3e74266	A script to compare actual and expected error outputs from the ... Estimated hours taken: 0.5 runtests: A script to compare actual and expected error outputs from the compiler. Mmake: Don't test types.m, since we don't pass it, and lambda_type_bad, since the tested code is no longer invalid. *.err_exp: The expected error outputs.	1996-11-04 07:15:18 +00:00