diff --git a/compiler/add_class.m b/compiler/add_class.m index 37446a3e1..acf2ac9b0 100644 --- a/compiler/add_class.m +++ b/compiler/add_class.m @@ -151,8 +151,8 @@ add_typeclass_defn(ItemMercuryStatus, TypeClassStatus0, NeedQual, true else report_multiply_defined("typeclass", ClassName, - user_arity(ClassArity), Context, OldContext, - [], !Specs) + user_arity(ClassArity), Context, OldContext, [], Spec), + !:Specs = [Spec | !.Specs] ), HasIncompatibility = yes(OldDefn) else @@ -165,7 +165,8 @@ add_typeclass_defn(ItemMercuryStatus, TypeClassStatus0, NeedQual, % the original. Always report such errors, even in `.opt' files. UserArity = user_arity(ClassArity), report_multiply_defined("typeclass", ClassName, UserArity, - Context, OldContext, MismatchPieces, !Specs), + Context, OldContext, MismatchPieces, Spec), + !:Specs = [Spec | !.Specs], HasIncompatibility = yes(OldDefn) ) else diff --git a/compiler/add_clause.m b/compiler/add_clause.m index c824b9843..64cf5a243 100644 --- a/compiler/add_clause.m +++ b/compiler/add_clause.m @@ -447,7 +447,7 @@ select_applicable_modes(ModuleInfo, MaybeAnnotatedArgTerms, VarSet, ), qual_info_get_mq_info(!.QualInfo, MQInfo0), qualify_clause_mode_list(InInt, Context, - ArgModes0, ArgModes, MQInfo0, MQInfo, !Specs), + ArgModes0, ArgModes, MQInfo0, MQInfo), qual_info_set_mq_info(MQInfo, !QualInfo) ), @@ -493,7 +493,8 @@ select_applicable_modes(ModuleInfo, MaybeAnnotatedArgTerms, VarSet, ) else report_undeclared_mode_error(ModuleInfo, PredId, PredInfo, - VarSet, ArgModes, [words("clause")], Context, !Specs), + VarSet, ArgModes, [words("clause")], Context, UndefSpec), + !:Specs = [UndefSpec | !.Specs], % Apply the clause to all modes. % XXX Would it be better to apply it to none? ApplProcIds = selected_modes(AllProcIds) diff --git a/compiler/add_mode.m b/compiler/add_mode.m index 9ccf9b379..d70b60761 100644 --- a/compiler/add_mode.m +++ b/compiler/add_mode.m @@ -40,13 +40,11 @@ %---------------------% :- pred check_inst_defns(module_info::in, ims_list(item_inst_defn_info)::in, - found_invalid_inst_or_mode::in, found_invalid_inst_or_mode::out, list(error_spec)::in, list(error_spec)::out) is det. %---------------------% :- pred check_mode_defns(module_info::in, ims_list(item_mode_defn_info)::in, - found_invalid_inst_or_mode::in, found_invalid_inst_or_mode::out, list(error_spec)::in, list(error_spec)::out) is det. %---------------------------------------------------------------------------% @@ -169,7 +167,8 @@ insts_add(VarSet, InstSymName, InstParams, MaybeForType, eqv_inst(EqvInst), map.lookup(!.UserInstTable, InstCtor, OrigInstDefn), OrigContext = OrigInstDefn ^ inst_context, report_multiply_defined("inst", InstSymName, user_arity(InstArity), - Context, OrigContext, [], !Specs) + Context, OrigContext, [], DupSpec), + !:Specs = [DupSpec | !.Specs] ) ). @@ -216,7 +215,8 @@ modes_add(VarSet, Name, Params, ModeBody, Context, ModeStatus, map.lookup(ModeDefns, ModeCtor, OrigModeDefn), OrigModeDefn = hlds_mode_defn(_, _, _, OrigContext, _), report_multiply_defined("mode", Name, user_arity(Arity), - Context, OrigContext, [], !Specs) + Context, OrigContext, [], Spec), + !:Specs = [Spec | !.Specs] ) ). @@ -243,26 +243,24 @@ should_report_duplicate_inst_or_mode(InstModeStatus) = ReportDup :- %---------------------------------------------------------------------------% -check_inst_defns(ModuleInfo, ImsSubLists, !FoundInvalidInstOrMode, !Specs) :- +check_inst_defns(ModuleInfo, ImsSubLists, !InvalidInstModeSpecs) :- find_eqv_cycles_in_insts(ModuleInfo, ImsSubLists, set.init, Cycles), ( if set.is_empty(Cycles) then true else - !:FoundInvalidInstOrMode = found_invalid_inst_or_mode, list.map(cycle_to_error_spec(ModuleInfo, iom_inst), set.to_sorted_list(Cycles), CycleSpecs), - !:Specs = CycleSpecs ++ !.Specs + !:InvalidInstModeSpecs = CycleSpecs ++ !.InvalidInstModeSpecs ). -check_mode_defns(ModuleInfo, ImsSubLists, !FoundInvalidInstOrMode, !Specs) :- +check_mode_defns(ModuleInfo, ImsSubLists, !InvalidInstModeSpecs) :- find_eqv_cycles_in_modes(ModuleInfo, ImsSubLists, set.init, Cycles), ( if set.is_empty(Cycles) then true else - !:FoundInvalidInstOrMode = found_invalid_inst_or_mode, list.map(cycle_to_error_spec(ModuleInfo, iom_mode), set.to_sorted_list(Cycles), CycleSpecs), - !:Specs = CycleSpecs ++ !.Specs + !:InvalidInstModeSpecs = CycleSpecs ++ !.InvalidInstModeSpecs ). %---------------------% diff --git a/compiler/add_pragma_impl.m b/compiler/add_pragma_impl.m index 803bac7ff..8c45f496f 100644 --- a/compiler/add_pragma_impl.m +++ b/compiler/add_pragma_impl.m @@ -255,7 +255,8 @@ add_pragma_foreign_proc_export(FPEInfo, !ModuleInfo, !Specs) :- DescPieces = [pragma_decl("foreign_export"), words("declaration")], report_undeclared_mode_error(!.ModuleInfo, PredId, PredInfo, - VarSet, ArgModes, DescPieces, Context, !Specs) + VarSet, ArgModes, DescPieces, Context, Spec), + !:Specs = [Spec | !.Specs] ; Origin = item_origin_compiler(_CompilerAttrs) % We do not warn about errors in export pragmas created by diff --git a/compiler/add_pragma_type_spec.m b/compiler/add_pragma_type_spec.m index a832c54ba..e5fccf33e 100644 --- a/compiler/add_pragma_type_spec.m +++ b/compiler/add_pragma_type_spec.m @@ -340,8 +340,8 @@ find_pred_procs_to_type_spec(ModuleInfo, PredId, PredInfo, ProcTable, TVarSet, varset.coerce(TVarSet, VarSet), DescPieces = [pragma_decl("type_spec"), words("declaration")], report_undeclared_mode_error(ModuleInfo, PredId, PredInfo, - VarSet, ArgModes, DescPieces, Context, [], Specs), - MaybeSpecProcs = error6(Specs) + VarSet, ArgModes, DescPieces, Context, Spec), + MaybeSpecProcs = error6([Spec]) ) ; ModesOrArity = moa_arity(UserArity), diff --git a/compiler/add_pred.m b/compiler/add_pred.m index f9523e2ec..43cc43379 100644 --- a/compiler/add_pred.m +++ b/compiler/add_pred.m @@ -425,7 +425,8 @@ add_new_pred(PredOrigin, Context, SeqNum, PredStatus0, NeedQual, PredOrFunc, PredOrFuncStr = pred_or_func_to_full_str(PredOrFunc), user_arity_pred_form_arity(PredOrFunc, UserArity, PredFormArity), report_multiply_defined(PredOrFuncStr, PredSymName, UserArity, - Context, OrigContext, [], !Specs) + Context, OrigContext, [], DupSpec), + !:Specs = [DupSpec | !.Specs] ) ; MaybeOrigPredId = no, diff --git a/compiler/add_type.m b/compiler/add_type.m index be3bc42e4..ecc27a75b 100644 --- a/compiler/add_type.m +++ b/compiler/add_type.m @@ -21,7 +21,6 @@ :- import_module hlds.hlds_data. :- import_module hlds.hlds_module. -:- import_module hlds.make_hlds.make_hlds_types. :- import_module hlds.status. :- import_module parse_tree. :- import_module parse_tree.error_spec. @@ -36,7 +35,7 @@ % :- pred module_add_type_defn(type_status::in, need_qualifier::in, item_type_defn_info::in, module_info::in, module_info::out, - found_invalid_type::in, found_invalid_type::out, + list(error_spec)::in, list(error_spec)::out, list(error_spec)::in, list(error_spec)::out) is det. % Add the constructors of du types to the constructor table of the HLDS, @@ -45,8 +44,8 @@ % :- pred add_du_ctors_check_subtype_check_foreign_type(type_table::in, type_ctor::in, hlds_type_defn::in, - found_invalid_type::in, found_invalid_type::out, module_info::in, module_info::out, + list(error_spec)::in, list(error_spec)::out, list(error_spec)::in, list(error_spec)::out) is det. %---------------------------------------------------------------------------% @@ -95,7 +94,7 @@ % module_add_type_defn(TypeStatus0, NeedQual, ItemTypeDefnInfo, - !ModuleInfo, !FoundInvalidType, !Specs) :- + !ModuleInfo, !InvalidTypeSpecs, !Specs) :- % XXX We should consider setting !:FoundInvalidType *only* for type % errors that can cause later compiler passes to either crash or to % report nonexistent problems. If the only effect of a type error @@ -145,7 +144,7 @@ module_add_type_defn(TypeStatus0, NeedQual, ItemTypeDefnInfo, ( ParseTreeTypeDefn = parse_tree_abstract_type(_), module_add_type_defn_abstract(TypeStatus, TypeCtor, Body, - HLDSTypeDefn0, Context, !ModuleInfo, !FoundInvalidType, [], Specs) + HLDSTypeDefn0, Context, !ModuleInfo, !InvalidTypeSpecs) ; ( ParseTreeTypeDefn = parse_tree_du_type(_) ; ParseTreeTypeDefn = parse_tree_sub_type(_) @@ -153,7 +152,7 @@ module_add_type_defn(TypeStatus0, NeedQual, ItemTypeDefnInfo, ), module_add_type_defn_mercury(TypeStatus, TypeCtor, TypeParams, ParseTreeTypeDefn, Body, HLDSTypeDefn0, Context, - !ModuleInfo, !FoundInvalidType, [], Specs) + !ModuleInfo, !InvalidTypeSpecs) ; ParseTreeTypeDefn = parse_tree_solver_type(_), ( if @@ -167,40 +166,38 @@ module_add_type_defn(TypeStatus0, NeedQual, ItemTypeDefnInfo, [words("from its defining module."), nl], SolverSpec = spec($pred, severity_error, phase_pt2h, Context, SolverPieces), - Specs0 = [SolverSpec] + !:Specs = [SolverSpec | !.Specs] else - Specs0 = [] + true ), module_add_type_defn_mercury(TypeStatus, TypeCtor, TypeParams, ParseTreeTypeDefn, Body, HLDSTypeDefn0, Context, - !ModuleInfo, !FoundInvalidType, Specs0, Specs) + !ModuleInfo, !InvalidTypeSpecs) ; ParseTreeTypeDefn = parse_tree_foreign_type(_), module_add_type_defn_foreign(TypeStatus0, TypeStatus, TypeCtor, Body, - HLDSTypeDefn0, Context, !ModuleInfo, !FoundInvalidType, [], Specs) - ), - !:Specs = Specs ++ !.Specs. + HLDSTypeDefn0, Context, !ModuleInfo, !InvalidTypeSpecs) + ). %---------------------% :- pred module_add_type_defn_abstract(type_status::in, type_ctor::in, hlds_type_body::in, hlds_type_defn::in, prog_context::in, module_info::in, module_info::out, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. module_add_type_defn_abstract(TypeStatus1, TypeCtor, Body, TypeDefn0, Context, - !ModuleInfo, !FoundInvalidType, !Specs) :- + !ModuleInfo, !InvalidTypeSpecs) :- module_info_get_type_table(!.ModuleInfo, TypeTable0), ( if search_type_ctor_defn(TypeTable0, TypeCtor, OldDefn) then % Since make_hlds_passes.m adds all abstract definitions first, % the previous definition can only be another abstract definition. check_for_duplicate_type_declaration(TypeCtor, OldDefn, TypeStatus1, - Context, !FoundInvalidType, !Specs), + Context, !InvalidTypeSpecs), combine_old_and_new_type_status(OldDefn, TypeStatus1, _TypeStatus, TypeDefn0, TypeDefn), check_for_inconsistent_solver_nosolver_type(TypeCtor, - OldDefn, Body, Context, !FoundInvalidType, !Specs), + OldDefn, Body, Context, !InvalidTypeSpecs), replace_type_ctor_defn(TypeCtor, TypeDefn, TypeTable0, TypeTable) else add_type_ctor_defn(TypeCtor, TypeDefn0, TypeTable0, TypeTable) @@ -209,11 +206,10 @@ module_add_type_defn_abstract(TypeStatus1, TypeCtor, Body, TypeDefn0, Context, :- pred check_for_duplicate_type_declaration(type_ctor::in, hlds_type_defn::in, type_status::in, prog_context::in, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. check_for_duplicate_type_declaration(TypeCtor, OldDefn, NewStatus, NewContext, - !FoundInvalidType, !Specs) :- + !InvalidTypeSpecs) :- % Even if the source code includes only one declaration of a type, % augmenting a raw compilation unit can yield duplicates of that % declaration, included e.g. in both x.int2 and then x.int, @@ -258,7 +254,6 @@ check_for_duplicate_type_declaration(TypeCtor, OldDefn, NewStatus, NewContext, [nl] else Severity = severity_error, - !:FoundInvalidType = found_invalid_type, % XXX If there were not one but *two or more* previous % declarations for the type, then FirstStatus may not have come % from the previous declaration at FirstContext; it could have @@ -288,7 +283,7 @@ check_for_duplicate_type_declaration(TypeCtor, OldDefn, NewStatus, NewContext, FirstPieces = [words("The previous declaration was here."), nl], FirstMsg = msg(FirstContext, FirstPieces), DupSpec = error_spec($pred, Severity, phase_pt2h, [DupMsg, FirstMsg]), - !:Specs = [DupSpec | !.Specs] + !:InvalidTypeSpecs = [DupSpec | !.InvalidTypeSpecs] else true ). @@ -305,12 +300,11 @@ check_for_duplicate_type_declaration(TypeCtor, OldDefn, NewStatus, NewContext, type_ctor::in, list(type_param)::in, type_defn::in(type_defn_mercury), hlds_type_body::in, hlds_type_defn::in, prog_context::in, module_info::in, module_info::out, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. module_add_type_defn_mercury(TypeStatus1, TypeCtor, TypeParams, ParseTreeTypeDefn, Body, TypeDefn0, Context, - !ModuleInfo, !FoundInvalidType, !Specs) :- + !ModuleInfo, !InvalidTypeSpecs) :- module_info_get_type_table(!.ModuleInfo, TypeTable0), ( if search_type_ctor_defn(TypeTable0, TypeCtor, OldDefn) then % Since make_hlds_passes.m adds all abstract definitions first @@ -320,13 +314,13 @@ module_add_type_defn_mercury(TypeStatus1, TypeCtor, TypeParams, combine_old_and_new_type_status(OldDefn, TypeStatus1, TypeStatus, TypeDefn0, TypeDefn), check_for_inconsistent_solver_nosolver_type(TypeCtor, OldDefn, - Body, Context, !FoundInvalidType, !Specs), + Body, Context, !InvalidTypeSpecs), ( if hlds_data.get_type_defn_body(OldDefn, OldDefnBody), OldDefnBody \= hlds_abstract_type(_) then maybe_report_multiply_defined_type(TypeStatus, TypeCtor, Context, - OldDefn, !FoundInvalidType, !Specs) + OldDefn, !InvalidTypeSpecs) else replace_type_ctor_defn(TypeCtor, TypeDefn, TypeTable0, TypeTable), module_info_set_type_table(TypeTable, !ModuleInfo) @@ -339,12 +333,11 @@ module_add_type_defn_mercury(TypeStatus1, TypeCtor, TypeParams, ( ParseTreeTypeDefn = parse_tree_du_type(DetailsDu), check_for_invalid_user_defined_unify_compare(TypeStatus, - TypeCtor, DetailsDu, Context, !FoundInvalidType, !Specs) + TypeCtor, DetailsDu, Context, !InvalidTypeSpecs) ; ParseTreeTypeDefn = parse_tree_eqv_type(DetailsEqv), check_for_polymorphic_eqv_type_with_monomorphic_body(TypeStatus, - TypeCtor, TypeParams, DetailsEqv, Context, - !FoundInvalidType, !Specs) + TypeCtor, TypeParams, DetailsEqv, Context, !InvalidTypeSpecs) ; ( ParseTreeTypeDefn = parse_tree_sub_type(_) ; ParseTreeTypeDefn = parse_tree_solver_type(_) @@ -356,11 +349,10 @@ module_add_type_defn_mercury(TypeStatus1, TypeCtor, TypeParams, :- pred module_add_type_defn_foreign(type_status::in, type_status::in, type_ctor::in, hlds_type_body::in, hlds_type_defn::in, prog_context::in, module_info::in, module_info::out, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. module_add_type_defn_foreign(TypeStatus0, TypeStatus1, TypeCtor, - Body, TypeDefn0, Context, !ModuleInfo, !FoundInvalidType, !Specs) :- + Body, TypeDefn0, Context, !ModuleInfo, !InvalidTypeSpecs) :- module_info_get_type_table(!.ModuleInfo, TypeTable0), ( if search_type_ctor_defn(TypeTable0, TypeCtor, OldDefn) then % Since make_hlds_passes.m adds all abstract definitions first, @@ -373,7 +365,7 @@ module_add_type_defn_foreign(TypeStatus0, TypeStatus1, TypeCtor, combine_old_and_new_type_status(OldDefn, TypeStatus1, TypeStatus, TypeDefn0, TypeDefn1), check_for_inconsistent_solver_nosolver_type(TypeCtor, - OldDefn, Body, Context, !FoundInvalidType, !Specs), + OldDefn, Body, Context, !InvalidTypeSpecs), hlds_data.get_type_defn_status(OldDefn, OldTypeStatus), hlds_data.get_type_defn_body(OldDefn, OldBody), @@ -383,8 +375,7 @@ module_add_type_defn_foreign(TypeStatus0, TypeStatus1, TypeCtor, % for this type. check_for_inconsistent_foreign_type_visibility(TypeCtor, old_defn_is_abstract, OldTypeStatus, OldContext, - TypeStatus0, Context, TypeDefn1, TypeDefn, - !FoundInvalidType, !Specs), + TypeStatus0, Context, TypeDefn1, TypeDefn, !InvalidTypeSpecs), replace_type_ctor_defn(TypeCtor, TypeDefn, TypeTable0, TypeTable), module_info_set_type_table(TypeTable, !ModuleInfo) @@ -401,14 +392,14 @@ module_add_type_defn_foreign(TypeStatus0, TypeStatus1, TypeCtor, check_for_inconsistent_foreign_type_visibility(TypeCtor, old_defn_is_not_abstract, OldTypeStatus, OldContext, TypeStatus1, Context, TypeDefn2, TypeDefn, - !FoundInvalidType, !Specs), + !InvalidTypeSpecs), replace_type_ctor_defn(TypeCtor, TypeDefn, TypeTable0, TypeTable), module_info_set_type_table(TypeTable, !ModuleInfo) else % ... or not. maybe_report_multiply_defined_type(TypeStatus, TypeCtor, - Context, OldDefn, !FoundInvalidType, !Specs) + Context, OldDefn, !InvalidTypeSpecs) ) ) else @@ -419,8 +410,7 @@ module_add_type_defn_foreign(TypeStatus0, TypeStatus1, TypeCtor, [nl], ForeignDeclSpec = spec($pred, severity_error, phase_pt2h, Context, ForeignDeclPieces), - !:Specs = [ForeignDeclSpec | !.Specs], - !:FoundInvalidType = found_invalid_type + !:InvalidTypeSpecs = [ForeignDeclSpec | !.InvalidTypeSpecs] ). %---------------------------------------------------------------------------% @@ -633,11 +623,10 @@ merge_maybe(no, yes(T), yes(T)). :- pred maybe_report_multiply_defined_type(type_status::in, type_ctor::in, prog_context::in, hlds_type_defn::in, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. maybe_report_multiply_defined_type(TypeStatus, TypeCtor, Context, OldDefn, - !FoundInvalidType, !Specs) :- + !InvalidTypeSpecs) :- % Issue an error message if the second definition wasn't read % while reading .opt files. % XXX STATUS @@ -647,19 +636,18 @@ maybe_report_multiply_defined_type(TypeStatus, TypeCtor, Context, OldDefn, TypeCtor = type_ctor(SymName, Arity), hlds_data.get_type_defn_context(OldDefn, OldContext), report_multiply_defined("type", SymName, user_arity(Arity), - Context, OldContext, [], !Specs), - !:FoundInvalidType = found_invalid_type + Context, OldContext, [], Spec), + !:InvalidTypeSpecs = [Spec | !.InvalidTypeSpecs] ). %---------------------% :- pred check_for_invalid_user_defined_unify_compare(type_status::in, type_ctor::in, type_details_du::in, prog_context::in, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. check_for_invalid_user_defined_unify_compare(TypeStatus, TypeCtor, DetailsDu, - Context, !FoundInvalidType, !Specs) :- + Context, !InvalidTypeSpecs) :- DetailsDu = type_details_du(Ctors, MaybeCanon, _MaybeDirectArg), ( if MaybeCanon = noncanon(_), @@ -689,8 +677,7 @@ check_for_invalid_user_defined_unify_compare(TypeStatus, TypeCtor, DetailsDu, verbose_only(verbose_once, VerbosePieces)]), DummySpec = error_spec($pred, severity_error, phase_pt2h, [DummyMsg]), - !:Specs = [DummySpec | !.Specs], - !:FoundInvalidType = found_invalid_type + !:InvalidTypeSpecs = [DummySpec | !.InvalidTypeSpecs] else true ) @@ -702,11 +689,10 @@ check_for_invalid_user_defined_unify_compare(TypeStatus, TypeCtor, DetailsDu, :- pred check_for_polymorphic_eqv_type_with_monomorphic_body(type_status::in, type_ctor::in, list(type_param)::in, type_details_eqv::in, - prog_context::in, found_invalid_type::in, found_invalid_type::out, - list(error_spec)::in, list(error_spec)::out) is det. + prog_context::in, list(error_spec)::in, list(error_spec)::out) is det. check_for_polymorphic_eqv_type_with_monomorphic_body(TypeStatus, TypeCtor, - TypeParams, DetailsEqv, Context, !FoundInvalidType, !Specs) :- + TypeParams, DetailsEqv, Context, !InvalidTypeSpecs) :- DetailsEqv = type_details_eqv(EqvType), ( if % XXX We can't handle abstract exported polymorphic equivalence @@ -729,8 +715,7 @@ check_for_polymorphic_eqv_type_with_monomorphic_body(TypeStatus, TypeCtor, verbose_only(verbose_once, abstract_monotype_workaround)]), PolyEqvSpec = error_spec($pred, severity_error, phase_pt2h, [PolyEqvMsg]), - !:Specs = [PolyEqvSpec | !.Specs], - !:FoundInvalidType = found_invalid_type + !:InvalidTypeSpecs = [PolyEqvSpec | !.InvalidTypeSpecs] else true ). @@ -750,11 +735,10 @@ abstract_monotype_workaround = [ :- pred check_for_inconsistent_solver_nosolver_type(type_ctor::in, hlds_type_defn::in, hlds_type_body::in, prog_context::in, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. check_for_inconsistent_solver_nosolver_type(TypeCtor, OldDefn, NewBody, - NewContext, !FoundInvalidType, !Specs) :- + NewContext, !InvalidTypeSpecs) :- get_type_defn_body(OldDefn, OldBody), get_body_is_solver_type(OldBody, OldIsSolverType), get_body_is_solver_type(NewBody, NewIsSolverType), @@ -814,8 +798,7 @@ check_for_inconsistent_solver_nosolver_type(TypeCtor, OldDefn, NewBody, OldMsg = msg(OldContext, OldPieces), Spec = error_spec($pred, severity_error, phase_pt2h, [MainMsg, OldMsg]), - !:Specs = [Spec | !.Specs], - !:FoundInvalidType = found_invalid_type + !:InvalidTypeSpecs = [Spec | !.InvalidTypeSpecs] ). :- pred get_body_is_solver_type(hlds_type_body::in, is_solver_type::out) @@ -858,12 +841,11 @@ get_body_is_solver_type(Body, IsSolverType) :- old_defn_maybe_abstract::in, type_status::in, prog_context::in, type_status::in, prog_context::in, hlds_type_defn::in, hlds_type_defn::out, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. check_for_inconsistent_foreign_type_visibility(TypeCtor, OldIsAbstract, OldStatus, OldContext, NewStatus, NewContext, - !TypeDefn, !FoundInvalidType, !Specs) :- + !TypeDefn, !InvalidTypeSpecs) :- ( if ( OldIsAbstract = old_defn_is_abstract, @@ -905,9 +887,8 @@ check_for_inconsistent_foreign_type_visibility(TypeCtor, Context = OldContext ), Spec = spec($pred, severity_error, phase_pt2h, Context, Pieces), - !:Specs = [Spec | !.Specs], - !:FoundInvalidType = found_invalid_type, - set_type_defn_prev_errors(type_defn_prev_errors, !TypeDefn) + !:InvalidTypeSpecs = [Spec | !.InvalidTypeSpecs], + set_type_defn_prev_errors(type_defn_prev_errors(Spec), !TypeDefn) else true ). @@ -936,7 +917,7 @@ do_foreign_type_visibilities_match(OldStatus, NewStatus) :- %---------------------------------------------------------------------------% add_du_ctors_check_subtype_check_foreign_type(TypeTable, TypeCtor, TypeDefn, - !FoundInvalidType, !ModuleInfo, !Specs) :- + !ModuleInfo, !InvalidTypeSpecs, !Specs) :- get_type_defn_context(TypeDefn, Context), get_type_defn_tvarset(TypeDefn, TVarSet), get_type_defn_tparams(TypeDefn, TypeParams), @@ -955,7 +936,7 @@ add_du_ctors_check_subtype_check_foreign_type(TypeTable, TypeCtor, TypeDefn, ( MaybeSuperType = subtype_of(SuperType), check_subtype_defn(TypeTable, TVarSet, TypeCtor, TypeDefn, BodyDu, - SuperType, MaybeSetSubtypeNoncanon, !FoundInvalidType, !Specs), + SuperType, MaybeSetSubtypeNoncanon, !InvalidTypeSpecs, !Specs), ( MaybeSetSubtypeNoncanon = do_not_set_subtype_noncanon ; @@ -996,27 +977,13 @@ add_du_ctors_check_subtype_check_foreign_type(TypeTable, TypeCtor, TypeDefn, CtorAddSpecs1, CtorAddSpecs), module_info_set_cons_table(CtorMap, !ModuleInfo), module_info_set_ctor_field_table(CtorFieldMap, !ModuleInfo), - - ( - CtorAddSpecs = [] - ; - CtorAddSpecs = [_ | _], - !:FoundInvalidType = found_invalid_type, - !:Specs = CtorAddSpecs ++ !.Specs - ) + !:InvalidTypeSpecs = CtorAddSpecs ++ !.InvalidTypeSpecs ; Body = hlds_foreign_type(ForeignTypeBody), get_type_defn_prev_errors(TypeDefn, PrevErrors), check_foreign_type_for_current_target(!.ModuleInfo, TypeCtor, - ForeignTypeBody, PrevErrors, Context, - FoundInvalidTypeInForeignBody, !Specs), - ( - FoundInvalidTypeInForeignBody = found_invalid_type, - !:FoundInvalidType = found_invalid_type + ForeignTypeBody, PrevErrors, Context, !InvalidTypeSpecs) ; - FoundInvalidTypeInForeignBody = did_not_find_invalid_type - ) - ; ( Body = hlds_abstract_type(_) ; Body = hlds_solver_type(_) ; Body = hlds_eqv_type(_) @@ -1205,20 +1172,20 @@ do_add_ctor_field(FieldName, FieldNameDefn, ModuleName, !FieldNameTable) :- % :- pred check_foreign_type_for_current_target(module_info::in, type_ctor::in, foreign_type_body::in, type_defn_prev_errors::in, prog_context::in, - found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. check_foreign_type_for_current_target(ModuleInfo, TypeCtor, ForeignTypeBody, - PrevErrors, Context, FoundInvalidType, !Specs) :- + PrevErrors, Context, !InvalidTypeSpecs) :- module_info_get_globals(ModuleInfo, Globals), globals.get_target(Globals, Target), ( if have_foreign_type_for_backend(Target, ForeignTypeBody, yes) then - FoundInvalidType = did_not_find_invalid_type - else if PrevErrors = type_defn_prev_errors then + true + else if PrevErrors = type_defn_prev_errors(_Spec) then % The error message being generated below may be misleading, % since the relevant foreign language definition of this type - % may have been present, but in error. - FoundInvalidType = found_invalid_type + % may have been present, but in error. And we have already + % scheduled _Spec to be printed about this type definition. + true else LangStr = compilation_target_string(Target), MainPieces = [words("Error: the type")] ++ @@ -1234,8 +1201,7 @@ check_foreign_type_for_current_target(ModuleInfo, TypeCtor, ForeignTypeBody, Msg = simple_msg(Context, [always(MainPieces), verbose_only(verbose_always, VerbosePieces)]), Spec = error_spec($pred, severity_error, phase_pt2h, [Msg]), - !:Specs = [Spec | !.Specs], - FoundInvalidType = found_invalid_type + !:InvalidTypeSpecs = [Spec | !.InvalidTypeSpecs] ). %---------------------------------------------------------------------------% @@ -1248,11 +1214,11 @@ check_foreign_type_for_current_target(ModuleInfo, TypeCtor, ForeignTypeBody, :- pred check_subtype_defn(type_table::in, tvarset::in, type_ctor::in, hlds_type_defn::in, type_body_du::in, mer_type::in, maybe_set_subtype_noncanonical::out, - found_invalid_type::in, found_invalid_type::out, + list(error_spec)::in, list(error_spec)::out, list(error_spec)::in, list(error_spec)::out) is det. check_subtype_defn(TypeTable, TVarSet, TypeCtor, TypeDefn, TypeBodyDu, - SuperType, MaybeSetSubtypeNoncanon, !FoundInvalidType, !Specs) :- + SuperType, MaybeSetSubtypeNoncanon, !InvalidTypeSpecs, !Specs) :- ( if type_to_ctor_and_args(SuperType, SuperTypeCtor, SuperTypeArgs) then search_super_type_ctor_defn(TypeTable, TypeCtor, TypeDefn, SuperTypeCtor, [], SearchResult), @@ -1272,17 +1238,15 @@ check_subtype_defn(TypeTable, TVarSet, TypeCtor, TypeDefn, TypeBodyDu, ), check_subtype_ctors(TypeTable, TypeCtor, TypeDefn, TypeBodyDu, SuperTypeCtor, SuperTypeDefn, SuperTypeBodyDu, - SuperTypeArgs, !FoundInvalidType, !Specs) + SuperTypeArgs, !InvalidTypeSpecs, !Specs) ; MaybeBaseMaybeCanon = error1(UpToBaseSpecs), - !:Specs = UpToBaseSpecs ++ !.Specs, - !:FoundInvalidType = found_invalid_type, + !:InvalidTypeSpecs = UpToBaseSpecs ++ !.InvalidTypeSpecs, MaybeSetSubtypeNoncanon = do_not_set_subtype_noncanon ) ; SearchResult = error2(SearchSpecs), - !:Specs = SearchSpecs ++ !.Specs, - !:FoundInvalidType = found_invalid_type, + !:InvalidTypeSpecs = SearchSpecs ++ !.InvalidTypeSpecs, MaybeSetSubtypeNoncanon = do_not_set_subtype_noncanon ) else @@ -1294,8 +1258,7 @@ check_subtype_defn(TypeTable, TVarSet, TypeCtor, TypeDefn, TypeBodyDu, color_as_incorrect([quote(SuperTypeStr), suffix(".")]) ++ [nl], hlds_data.get_type_defn_context(TypeDefn, Context), Spec = spec($pred, severity_error, phase_pt2h, Context, Pieces), - !:Specs = [Spec | !.Specs], - !:FoundInvalidType = found_invalid_type, + !:InvalidTypeSpecs = [Spec | !.InvalidTypeSpecs], MaybeSetSubtypeNoncanon = do_not_set_subtype_noncanon ). @@ -1586,12 +1549,12 @@ describe_which_is_supertype_of_chain(First, OrigTypeCtor, SuperTypeCtors) :- pred check_subtype_ctors(type_table::in, type_ctor::in, hlds_type_defn::in, type_body_du::in, type_ctor::in, hlds_type_defn::in, type_body_du::in, - list(mer_type)::in, found_invalid_type::in, found_invalid_type::out, + list(mer_type)::in, list(error_spec)::in, list(error_spec)::out, list(error_spec)::in, list(error_spec)::out) is det. check_subtype_ctors(TypeTable, TypeCtor, TypeDefn, TypeBodyDu, SuperTypeCtor, SuperTypeDefn, SuperTypeBodyDu, SuperTypeArgs, - !FoundInvalidType, !Specs) :- + !InvalidTypeSpecs, !Specs) :- hlds_data.get_type_defn_tvarset(TypeDefn, TVarSet0), hlds_data.get_type_defn_status(TypeDefn, TypeStatus), hlds_data.get_type_defn_tvarset(SuperTypeDefn, SuperTVarSet), @@ -1615,10 +1578,10 @@ check_subtype_ctors(TypeTable, TypeCtor, TypeDefn, TypeBodyDu, % Check each subtype constructor against the supertype's constructors. TypeBodyDu = type_body_du(OoMCtors, _, _, _, _, _), Ctors = one_or_more_to_list(OoMCtors), - list.foldl2( + list.foldl( look_up_and_check_subtype_ctor(TypeTable, NewTVarSet, TypeStatus, SuperTypeCtor, SuperCtors), - Ctors, !FoundInvalidType, !Specs), + Ctors, !InvalidTypeSpecs), % Check order of subtype constructors relative to supertype constructors. hlds_data.get_type_defn_context(TypeDefn, Context), @@ -1627,11 +1590,10 @@ check_subtype_ctors(TypeTable, TypeCtor, TypeDefn, TypeBodyDu, :- pred look_up_and_check_subtype_ctor(type_table::in, tvarset::in, type_status::in, type_ctor::in, list(constructor)::in, constructor::in, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. look_up_and_check_subtype_ctor(TypeTable, TVarSet, TypeStatus, - SuperTypeCtor, SuperCtors, Ctor, !FoundInvalidType, !Specs) :- + SuperTypeCtor, SuperCtors, Ctor, !InvalidTypeSpecs) :- Ctor = ctor(_, _, CtorName, _, Arity, Context), UnqualCtorName = unqualify_name(CtorName), ( if @@ -1639,7 +1601,7 @@ look_up_and_check_subtype_ctor(TypeTable, TVarSet, TypeStatus, SuperCtor) then check_subtype_ctor(TypeTable, TVarSet, TypeStatus, Ctor, SuperCtor, - !FoundInvalidType, !Specs) + !InvalidTypeSpecs) else CtorSNA = sym_name_arity(CtorName, Arity), Pieces = [words("Error:")] ++ @@ -1649,8 +1611,7 @@ look_up_and_check_subtype_ctor(TypeTable, TVarSet, TypeStatus, color_as_subject([unqual_type_ctor(SuperTypeCtor), suffix(".")]) ++ [nl], Spec = spec($pred, severity_error, phase_pt2h, Context, Pieces), - !:Specs = [Spec | !.Specs], - !:FoundInvalidType = found_invalid_type + !:InvalidTypeSpecs = [Spec | !.InvalidTypeSpecs] ). :- pred search_ctor_by_unqual_name(list(constructor)::in, string::in, int::in, @@ -1670,11 +1631,10 @@ search_ctor_by_unqual_name([HeadCtor | TailCtors], UnqualName, Arity, Ctor) :- :- pred check_subtype_ctor(type_table::in, tvarset::in, type_status::in, constructor::in, constructor::in, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. check_subtype_ctor(TypeTable, TVarSet, TypeStatus, Ctor, SuperCtor, - !FoundInvalidType, !Specs) :- + !InvalidTypeSpecs) :- Ctor = ctor(_, MaybeExistConstraints, CtorSymName, Args, Arity, Context), SuperCtor = ctor(_, MaybeSuperExistConstraints, _SuperCtorName, SuperArgs, _SuperArity, _SuperContext), @@ -1683,21 +1643,14 @@ check_subtype_ctor(TypeTable, TVarSet, TypeStatus, Ctor, SuperCtor, MaybeExistConstraints, MaybeSuperExistConstraints, Result), ( Result = ok1(ExistQVarsMapping), - list.foldl3_corresponding( + list.foldl2_corresponding( check_subtype_ctor_arg(TypeTable, TVarSet, TypeStatus, CtorSymName, ExistQVarsMapping), Args, SuperArgs, - 1, _, did_not_find_invalid_type, FoundInvalidType, !Specs), - ( - FoundInvalidType = did_not_find_invalid_type - ; - FoundInvalidType = found_invalid_type, - !:FoundInvalidType = FoundInvalidType - ) + 1, _, !InvalidTypeSpecs) ; Result = error1(Spec), - !:Specs = [Spec | !.Specs], - !:FoundInvalidType = found_invalid_type + !:InvalidTypeSpecs = [Spec | !.InvalidTypeSpecs] ). %---------------------% @@ -1814,12 +1767,11 @@ check_subtype_ctor_exist_constraints(CtorSymNameArity, Context, :- pred check_subtype_ctor_arg(type_table::in, tvarset::in, type_status::in, sym_name::in, existq_tvar_mapping::in, constructor_arg::in, constructor_arg::in, int::in, int::out, - found_invalid_type::in, found_invalid_type::out, list(error_spec)::in, list(error_spec)::out) is det. check_subtype_ctor_arg(TypeTable, TVarSet, OrigTypeStatus, CtorSymName, ExistQVarsMapping, CtorArg, SuperCtorArg, ArgNum, ArgNum + 1, - !FoundInvalidType, !Specs) :- + !InvalidTypeSpecs) :- CtorArg = ctor_arg(_FieldName, ArgType, Context), SuperCtorArg = ctor_arg(_SuperFieldName, SuperArgType, _SuperContext), ( if @@ -1843,8 +1795,7 @@ check_subtype_ctor_arg(TypeTable, TVarSet, OrigTypeStatus, CtorSymName, color_as_correct([quote(SuperArgTypeStr)]) ++ [words("in the supertype."), nl], Spec = spec($pred, severity_error, phase_pt2h, Context, Pieces), - !:Specs = [Spec | !.Specs], - !:FoundInvalidType = found_invalid_type + !:InvalidTypeSpecs = [Spec | !.InvalidTypeSpecs] ). %---------------------% diff --git a/compiler/hlds_data.m b/compiler/hlds_data.m index 604877e87..c2a169f7f 100644 --- a/compiler/hlds_data.m +++ b/compiler/hlds_data.m @@ -25,6 +25,7 @@ :- import_module mdbcomp. :- import_module mdbcomp.sym_name. :- import_module parse_tree. +:- import_module parse_tree.error_spec. :- import_module parse_tree.prog_data. :- import_module assoc_list. @@ -727,9 +728,21 @@ map_foldl_over_type_ctor_defns_2(Pred, _Name, !TypeCtorTable, !Acc) :- :- interface. % Have we reported an error for this type definition yet? + % If we have, record the error_spec. If the type has more than one error, + % the recorded error_spec will be for the latest one. + % + % We don't need all the errors, because the only purpose we use this type + % for is to know whether we can omit a later diagnostic for the same type + % as being more likely to be confusing than helpful while being sure that + % + % - we report at least one diagnostic about the type definition, and + % - that this diagnostic counts as an invalid type definition, stopping + % the compiler from proceeding to passes that work only when all + % type definitions are trustworthy. + % :- type type_defn_prev_errors ---> type_defn_no_prev_errors - ; type_defn_prev_errors. + ; type_defn_prev_errors(error_spec). % An `hlds_type_body' holds the body of a type definition: % du = discriminated union, eqv_type = equivalence type (a type defined diff --git a/compiler/make_hlds_error.m b/compiler/make_hlds_error.m index 0aecccc6e..300a0b309 100644 --- a/compiler/make_hlds_error.m +++ b/compiler/make_hlds_error.m @@ -46,7 +46,7 @@ % :- pred report_multiply_defined(string::in, sym_name::in, user_arity::in, prog_context::in, prog_context::in, list(format_piece)::in, - list(error_spec)::in, list(error_spec)::out) is det. + error_spec::out) is det. % report_undefined_pred_or_func_error(MaybePorF, SymName, % UserArity, OtherUserArities, Context, DeclPieces, !Specs): @@ -65,8 +65,7 @@ :- pred report_undeclared_mode_error(module_info::in, pred_id::in, pred_info::in, prog_varset::in, list(mer_mode)::in, - list(format_piece)::in, prog_context::in, - list(error_spec)::in, list(error_spec)::out) is det. + list(format_piece)::in, prog_context::in, error_spec::out) is det. :- pred maybe_report_undefined_pred_error(module_info::in, pred_or_func::in, sym_name::in, pred_form_arity::in, pred_status::in, @@ -114,7 +113,7 @@ %---------------------------------------------------------------------------% report_multiply_defined(EntityKind, SymName, UserArity, Context, OrigContext, - ExtraPieces, !Specs) :- + ExtraPieces, Spec) :- % The flattening of source item blocks by modules.m puts % all items in a given section together. Since the original % source code may have had the contents of the different sections @@ -151,8 +150,7 @@ report_multiply_defined(EntityKind, SymName, UserArity, Context, OrigContext, ExtraMsgs = [msg(SecondContext, ExtraPieces)] ), Spec = error_spec($pred, severity_error, phase_pt2h, - [SecondDeclMsg, FirstDeclMsg | ExtraMsgs]), - !:Specs = [Spec | !.Specs]. + [SecondDeclMsg, FirstDeclMsg | ExtraMsgs]). report_undefined_pred_or_func_error(MaybePorF, SymName, UserArity, OtherUserArities, Context, DeclPieces, !Specs) :- @@ -201,7 +199,7 @@ report_undefined_pred_or_func_error(MaybePorF, SymName, %---------------------------------------------------------------------------% report_undeclared_mode_error(ModuleInfo, PredId, PredInfo, VarSet, ArgModes, - DescPieces, Context, !Specs) :- + DescPieces, Context, Spec) :- PredColonPieces = describe_one_pred_name(ModuleInfo, yes(color_subject), should_not_module_qualify, [suffix(":")], PredId), strip_module_names_from_mode_list(strip_builtin_module_name, @@ -245,8 +243,7 @@ report_undeclared_mode_error(ModuleInfo, PredId, PredInfo, VarSet, ArgModes, ), Msg = simple_msg(Context, [always(MainPieces), verbose_only(verbose_always, VerbosePieces)]), - Spec = error_spec($pred, severity_error, phase_pt2h, [Msg]), - !:Specs = [Spec | !.Specs]. + Spec = error_spec($pred, severity_error, phase_pt2h, [Msg]). :- func mode_decl_for_pred_info_to_pieces(pred_info, proc_id) = list(format_piece). diff --git a/compiler/make_hlds_passes.m b/compiler/make_hlds_passes.m index 1b16ecad4..a6655e9c6 100644 --- a/compiler/make_hlds_passes.m +++ b/compiler/make_hlds_passes.m @@ -16,7 +16,6 @@ :- interface. :- import_module hlds.hlds_module. -:- import_module hlds.make_hlds.make_hlds_types. :- import_module hlds.make_hlds.qual_info. :- import_module libs. :- import_module libs.globals. @@ -39,13 +38,13 @@ % parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, % DumpBaseFileName, MQInfo0, TypeEqvMap, % UsedEqvModules, UnusedInterfaceImports, - % QualInfo, InvalidType, InvalidInstOrMode, HLDS, Specs): + % QualInfo, HLDS, InvalidTypeSpecs, InvalidInstModeSpecs, Specs): % % Given MQInfo (returned by module_qual.m) and TypeEqvMap and UsedModules % (both returned by equiv_type.m), convert AugCompUnit to HLDS. % Return any errors found in Specs. - % Return InvalidType = yes if we found undefined types. - % Return InvalidInstOrMode = yes if we found undefined or cyclic + % Return nonempty InvalidTypeSpecs if we found undefined types. + % Return nonempty InvalidInstModeSpecs if we found undefined or cyclic % insts or modes. % QualInfo is an abstract type that check_typeclass.m will later pass % to produce_instance_method_clauses. @@ -53,8 +52,9 @@ :- pred parse_tree_to_hlds(io.text_output_stream::in, aug_compilation_unit::in, globals::in, string::in, mq_info::in, type_eqv_map::in, used_eqv_modules::in, set_tree234(module_name)::in, - qual_info::out, found_invalid_type::out, found_invalid_inst_or_mode::out, - module_info::out, list(error_spec)::out) is det. + qual_info::out, module_info::out, + list(error_spec)::out, list(error_spec)::out, + list(error_spec)::out) is det. %---------------------------------------------------------------------------% %---------------------------------------------------------------------------% @@ -79,6 +79,7 @@ :- import_module hlds.make_hlds.add_type. :- import_module hlds.make_hlds.check_field_access_functions. :- import_module hlds.make_hlds.make_hlds_separate_items. +:- import_module hlds.make_hlds.make_hlds_types. :- import_module hlds.make_hlds.make_hlds_warn. :- import_module hlds.pred_name. :- import_module hlds.pred_table. @@ -108,6 +109,7 @@ :- import_module cord. :- import_module map. :- import_module maybe. +:- import_module one_or_more_map. :- import_module pair. :- import_module require. :- import_module set. @@ -119,8 +121,8 @@ parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, DumpBaseFileName, MQInfo0, TypeEqvMap, UsedEqvModules, UnusedInterfaceImports, - !:QualInfo, !:FoundInvalidType, !:FoundInvalidInstOrMode, - !:ModuleInfo, !:Specs) :- + !:QualInfo, !:ModuleInfo, !:InvalidTypeSpecs, !:InvalidInstModeSpecs, + !:Specs) :- ParseTreeModuleSrc = AugCompUnit ^ acu_module_src, maybe_warn_include_and_non_include(Globals, ParseTreeModuleSrc, InclSpecs), ModuleName = ParseTreeModuleSrc ^ ptms_module_name, @@ -169,24 +171,8 @@ parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, DumpBaseFileName, extract_spec_phase(Spec, Phase), Phase = phase_tim_check_invalid_inst_mode ), - list.filter(IsInvalidTypeSpec, TypeSpecs, InvalidTypeSpecs), - list.filter(IsInvalidInstModeSpec, InstModeSpecs, InvalidInstModeSpecs), - TypeErrors = contains_errors(Globals, InvalidTypeSpecs), - InstModeErrors = contains_errors(Globals, InvalidInstModeSpecs), - ( - TypeErrors = no, - !:FoundInvalidType = did_not_find_invalid_type - ; - TypeErrors = yes, - !:FoundInvalidType = found_invalid_type - ), - ( - InstModeErrors = no, - !:FoundInvalidInstOrMode = did_not_find_invalid_inst_or_mode - ; - InstModeErrors = yes, - !:FoundInvalidInstOrMode = found_invalid_inst_or_mode - ), + list.filter(IsInvalidTypeSpec, TypeSpecs, !:InvalidTypeSpecs), + list.filter(IsInvalidInstModeSpec, InstModeSpecs, !:InvalidInstModeSpecs), % We used to add items to the HLDS in three passes. % Roughly, @@ -270,13 +256,13 @@ parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, DumpBaseFileName, % while usually returning abstract types, sometimes returns Mercury % types. add_type_defns(TypeDefnsAbstract, - !ModuleInfo, !FoundInvalidType, !Specs, !SolverPredDeclCord, + !ModuleInfo, !InvalidTypeSpecs, !Specs, !SolverPredDeclCord, !SolverForeignProcCord, !SolverMutableCord), add_type_defns(TypeDefnsMercury, - !ModuleInfo, !FoundInvalidType, !Specs, !SolverPredDeclCord, + !ModuleInfo, !InvalidTypeSpecs, !Specs, !SolverPredDeclCord, !SolverForeignProcCord, !SolverMutableCord), add_type_defns(TypeDefnsForeign, - !ModuleInfo, !FoundInvalidType, !Specs, !SolverPredDeclCord, + !ModuleInfo, !InvalidTypeSpecs, !Specs, !SolverPredDeclCord, !SolverForeignProcCord, !SolverMutableCord), % We use cords to record new predicate declarations, foreign_procs % and mutables. This preserves order without quadratic behavior. @@ -321,7 +307,7 @@ parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, DumpBaseFileName, add_inst_defns(InstDefns, !ModuleInfo, !Specs), check_inst_defns(!.ModuleInfo, InstDefns, - !FoundInvalidInstOrMode, !Specs), + !InvalidInstModeSpecs), % Mode definitions may refer to user defined insts. Since we have already % seen all inst definitions, we could check whether the newly defined @@ -329,7 +315,7 @@ parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, DumpBaseFileName, add_mode_defns(ModeDefns, !ModuleInfo, !Specs), check_mode_defns(!.ModuleInfo, ModeDefns, - !FoundInvalidInstOrMode, !Specs), + !InvalidInstModeSpecs), % We want to post-process the type table, after all the type definitions % have been added to it, to do several tasks. These include @@ -368,8 +354,9 @@ parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, DumpBaseFileName, % (Currently, we discover any such errors when we type and mode check % the automatically created unify and compare predicates, whose bodies % call the user-specified predicate names.) + InvalidTypesSoFar = contains_errors(Globals, !.InvalidTypeSpecs), ( - !.FoundInvalidType = did_not_find_invalid_type, + InvalidTypesSoFar = no, % Add constructors for du types to the HLDS, check subtype definitions, % and check that Mercury types defined solely by foreign types have a % definition that works for the current target backend. @@ -381,9 +368,9 @@ parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, DumpBaseFileName, module_info_get_type_table(!.ModuleInfo, TypeTable0), foldl3_over_type_ctor_defns( add_du_ctors_check_subtype_check_foreign_type(TypeTable0), - TypeTable0, !FoundInvalidType, !ModuleInfo, !Specs) + TypeTable0, !ModuleInfo, !InvalidTypeSpecs, !Specs) ; - !.FoundInvalidType = found_invalid_type + InvalidTypesSoFar = yes ), % A predicate declaration defines the type of the arguments of a predicate, @@ -418,7 +405,9 @@ parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, DumpBaseFileName, AllMutables = Mutables ++ SolverMutables, module_info_get_user_init_pred_target_names(!.ModuleInfo, InitPredTargetNames0), - mq_info_get_undef_insts(MQInfo0, MQUndefInsts0), + mq_info_get_undef_insts(MQInfo0, MQUndefInstSpecs0), + one_or_more_map.keys_as_set(MQUndefInstSpecs0, MQUndefInstsSet0), + MQUndefInsts0 = set_tree234.from_set(MQUndefInstsSet0), implement_mutables_if_local(!.ModuleInfo, MQUndefInsts0, AllMutables, MutablePredDecls, MutableClauses, MutableForeignProcs, MutableForeignDeclCodes, MutableForeignBodyCodes, FPEInfosCord1, @@ -631,28 +620,11 @@ parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, DumpBaseFileName, !QualInfo), qual_info_get_mq_info(!.QualInfo, MQInfo), - mq_info_get_undef_types(MQInfo, MQUndefTypes), - mq_info_get_undef_insts(MQInfo, MQUndefInsts), - mq_info_get_undef_modes(MQInfo, MQUndefModes), - mq_info_get_undef_typeclasses(MQInfo, MQUndefTypeClasses), - ( if - ( set_tree234.is_non_empty(MQUndefTypes) - ; set_tree234.is_non_empty(MQUndefTypeClasses) - ) - then - !:FoundInvalidType = found_invalid_type - else - true - ), - ( if - ( set_tree234.is_non_empty(MQUndefInsts) - ; set_tree234.is_non_empty(MQUndefModes) - ) - then - !:FoundInvalidInstOrMode = found_invalid_inst_or_mode - else - true - ). + get_error_specs_in_mq_info(MQInfo, + MQInvalidTypeSpecs, MQInvalidInstModeSpecs, MQNonBlockingUndefSpecs), + !:InvalidTypeSpecs = MQInvalidTypeSpecs ++ !.InvalidTypeSpecs, + !:InvalidInstModeSpecs = MQInvalidInstModeSpecs ++ !.InvalidInstModeSpecs, + !:Specs = MQNonBlockingUndefSpecs ++ !.Specs. %---------------------------------------------------------------------------% @@ -853,29 +825,29 @@ add_item_avail(ItemMercuryStatus, Avail, !ModuleInfo) :- :- pred add_type_defns(sec_list(item_type_defn_info)::in, module_info::in, module_info::out, - found_invalid_type::in, found_invalid_type::out, + list(error_spec)::in, list(error_spec)::out, list(error_spec)::in, list(error_spec)::out, sec_cord(item_pred_decl_info)::in, sec_cord(item_pred_decl_info)::out, ims_cord(item_foreign_proc_info)::in, ims_cord(item_foreign_proc_info)::out, sec_cord(item_mutable_info)::in, sec_cord(item_mutable_info)::out) is det. -add_type_defns([], !ModuleInfo, !FoundInvalidType, - !Specs, !PredDeclCord, !ForeignProcCord, !MutableCord). -add_type_defns([SecList | SecLists], !ModuleInfo, !FoundInvalidType, - !Specs, !PredDeclCord, !ForeignProcCord, !MutableCord) :- +add_type_defns([], !ModuleInfo, !InvalidTypeSpecs, !Specs, + !PredDeclCord, !ForeignProcCord, !MutableCord). +add_type_defns([SecList | SecLists], !ModuleInfo, !InvalidTypeSpecs, !Specs, + !PredDeclCord, !ForeignProcCord, !MutableCord) :- SecList = sec_sub_list(SectionInfo, TypeDefns), SectionInfo = sec_info(ItemMercuryStatus, _NeedQual), item_mercury_status_to_type_status(ItemMercuryStatus, TypeStatus), list.foldl6(add_type_defn(SectionInfo, TypeStatus), TypeDefns, - !ModuleInfo, !FoundInvalidType, - !Specs, !PredDeclCord, !ForeignProcCord, !MutableCord), - add_type_defns(SecLists, !ModuleInfo, !FoundInvalidType, - !Specs, !PredDeclCord, !ForeignProcCord, !MutableCord). + !ModuleInfo, !InvalidTypeSpecs, !Specs, + !PredDeclCord, !ForeignProcCord, !MutableCord), + add_type_defns(SecLists, !ModuleInfo, !InvalidTypeSpecs, !Specs, + !PredDeclCord, !ForeignProcCord, !MutableCord). :- pred add_type_defn(sec_info::in, type_status::in, item_type_defn_info::in, module_info::in, module_info::out, - found_invalid_type::in, found_invalid_type::out, + list(error_spec)::in, list(error_spec)::out, list(error_spec)::in, list(error_spec)::out, sec_cord(item_pred_decl_info)::in, sec_cord(item_pred_decl_info)::out, ims_cord(item_foreign_proc_info)::in, @@ -883,7 +855,7 @@ add_type_defns([SecList | SecLists], !ModuleInfo, !FoundInvalidType, sec_cord(item_mutable_info)::in, sec_cord(item_mutable_info)::out) is det. add_type_defn(SectionInfo, TypeStatus, TypeDefnInfo, - !ModuleInfo, !FoundInvalidType, !Specs, + !ModuleInfo, !InvalidTypeSpecs, !Specs, !PredDeclCord, !ForeignProcCord, !MutableCord) :- SectionInfo = sec_info(ItemMercuryStatus, NeedQual), TypeDefnInfo = item_type_defn_info(SymName, TypeParams, TypeDefn, @@ -932,7 +904,7 @@ add_type_defn(SectionInfo, TypeStatus, TypeDefnInfo, ) ), module_add_type_defn(TypeStatus, NeedQual, TypeDefnInfo, - !ModuleInfo, !FoundInvalidType, !Specs). + !ModuleInfo, !InvalidTypeSpecs, !Specs). %---------------------------------------------------------------------------% diff --git a/compiler/make_hlds_types.m b/compiler/make_hlds_types.m index 1a67728ff..a7f42be1a 100644 --- a/compiler/make_hlds_types.m +++ b/compiler/make_hlds_types.m @@ -25,14 +25,6 @@ %---------------------------------------------------------------------------% -:- type found_invalid_type - ---> did_not_find_invalid_type - ; found_invalid_type. - -:- type found_invalid_inst_or_mode - ---> did_not_find_invalid_inst_or_mode - ; found_invalid_inst_or_mode. - :- type ims_list(T) == list(ims_sub_list(T)). :- type ims_cord(T) == cord(ims_sub_list(T)). :- type ims_sub_list(T) diff --git a/compiler/mercury_compile_make_hlds.m b/compiler/mercury_compile_make_hlds.m index 62c7dc3ba..b48f0dfd9 100644 --- a/compiler/mercury_compile_make_hlds.m +++ b/compiler/mercury_compile_make_hlds.m @@ -34,12 +34,24 @@ :- import_module io. :- import_module maybe. +%---------------------------------------------------------------------------% + + % make_hlds_pass(ProgressStream, ErrorStream, Globals, + % OpModeAugment, InvokedByMMCMake, Baggage0, AugCompUnit0, + % HLDS0, QualInfo, MaybeTimestampMap, UndefTypes, UndefModes, + % PreHLDSErrors, !DumpInfo, !HaveReadModuleMaps, + % !MaybeWrittenSpecs, !IO): + % + % Every error_spec in MakeHLDSResults will also appear in + % !:MaybeWrittenSpecs. They are also returned separately in order + % to allow our caller to test for the presence of specific *kinds* + % of errors. + % :- pred make_hlds_pass(io.text_output_stream::in, io.text_output_stream::in, globals::in, op_mode_augment::in, op_mode_invoked_by_mmc_make::in, module_baggage::in, aug_compilation_unit::in, module_info::out, qual_info::out, maybe(module_timestamp_map)::out, - bool::out, bool::out, bool::out, - dump_info::in, dump_info::out, + bool::out, bool::out, bool::out, dump_info::in, dump_info::out, have_parse_tree_maps::in, have_parse_tree_maps::out, maybe_written_specs::in, maybe_written_specs::out, io::di, io::uo) is det. @@ -50,7 +62,6 @@ :- import_module hlds.hlds_defns. :- import_module hlds.make_hlds.make_hlds_passes. -:- import_module hlds.make_hlds.make_hlds_types. :- import_module libs.file_util. :- import_module libs.options. :- import_module make. @@ -93,9 +104,9 @@ make_hlds_pass(ProgressStream, ErrorStream, Globals, OpModeAugment, InvokedByMMCMake, Baggage0, AugCompUnit0, - HLDS0, QualInfo, MaybeTimestampMap, UndefTypes, UndefModes, - PreHLDSErrors, !DumpInfo, - !HaveReadModuleMaps, !MaybeWrittenSpecs, !IO) :- + HLDS0, QualInfo, MaybeTimestampMap, + UndefTypes, UndefModes, PreHLDSErrors, + !DumpInfo, !HaveReadModuleMaps, !MaybeWrittenSpecs, !IO) :- globals.lookup_bool_option(Globals, statistics, Stats), globals.lookup_bool_option(Globals, verbose, Verbose), ParseTreeModuleSrc = AugCompUnit0 ^ acu_module_src, @@ -103,6 +114,7 @@ make_hlds_pass(ProgressStream, ErrorStream, Globals, !MaybeWrittenSpecs), ModuleName = ParseTreeModuleSrc ^ ptms_module_name, + % ZZZ move this to a separate predicate ( ( OpModeAugment = opmau_typecheck_only ; OpModeAugment = opmau_front_and_middle(opfam_errorcheck_only) @@ -181,10 +193,10 @@ make_hlds_pass(ProgressStream, ErrorStream, Globals, "% Module qualifying items...\n", !IO), maybe_flush_output(ProgressStream, Verbose, !IO), module_qualify_aug_comp_unit(Globals, AugCompUnit1, AugCompUnit2, - EventSpecMap0, EventSpecMap1, EventSetFileName, MQInfo0, UnusedImports, - MQUndefTypes, MQUndefInsts, MQUndefModes, MQUndefTypeClasses, - [], QualifySpecs), - add_to_be_written_specs(QualifySpecs, !MaybeWrittenSpecs), + EventSpecMap0, EventSpecMap1, EventSetFileName, + MQInfo0, UnusedImports, UnusedImportsSpecsMap), + map.values(UnusedImportsSpecsMap, UnusedImportsSpecs), + add_to_be_written_specs(UnusedImportsSpecs, !MaybeWrittenSpecs), maybe_write_not_yet_written_specs(ErrorStream, Globals, Verbose, !MaybeWrittenSpecs, !IO), maybe_write_string(ProgressStream, Verbose, "% done.\n", !IO), @@ -209,7 +221,7 @@ make_hlds_pass(ProgressStream, ErrorStream, Globals, make_hlds(ProgressStream, ErrorStream, Globals, AugCompUnit, EventSet, MQInfo, TypeEqvMap, UsedEqvModules, UnusedImports, Verbose, Stats, HLDS0, QualInfo, - MakeHLDSFoundInvalidType, MakeHLDSFoundInvalidInstOrMode, + InvalidTypeSpecs, InvalidInstModeSpecs, FoundSemanticError, !MaybeWrittenSpecs, !IO), bool.or(FoundSemanticError, IntermodError, PreHLDSErrors), maybe_write_definitions(ProgressStream, @@ -220,23 +232,19 @@ make_hlds_pass(ProgressStream, ErrorStream, Globals, Verbose, Stats, HLDS0, !IO), ( if - set_tree234.is_empty(MQUndefTypes), - set_tree234.is_empty(MQUndefTypeClasses), + InvalidTypeSpecs = [], EventSetErrors = no, - ExpandErrors = no, - MakeHLDSFoundInvalidType = did_not_find_invalid_type + ExpandErrors = no then UndefTypes = no else UndefTypes = yes ), - ( if - set_tree234.is_empty(MQUndefInsts), - set_tree234.is_empty(MQUndefModes), - MakeHLDSFoundInvalidInstOrMode = did_not_find_invalid_inst_or_mode - then + ( + InvalidInstModeSpecs = [], UndefModes = no - else + ; + InvalidInstModeSpecs = [_ | _], UndefModes = yes ), @@ -616,17 +624,18 @@ maybe_grab_plain_and_trans_opt_files(ProgressStream, Globals, OpModeAugment, %---------------------% +% ZZZ inline :- pred make_hlds(io.text_output_stream::in, io.text_output_stream::in, globals::in, aug_compilation_unit::in, event_set::in, mq_info::in, type_eqv_map::in, used_eqv_modules::in, set_tree234(module_name)::in, bool::in, bool::in, module_info::out, qual_info::out, - found_invalid_type::out, found_invalid_inst_or_mode::out, bool::out, + list(error_spec)::out, list(error_spec)::out, bool::out, maybe_written_specs::in, maybe_written_specs::out, io::di, io::uo) is det. make_hlds(ProgressStream, ErrorStream, Globals, AugCompUnit, EventSet, MQInfo, TypeEqvMap, UsedEqvModules, UnusedImports, Verbose, Stats, !:HLDS, - QualInfo, FoundInvalidType, FoundInvalidInstOrMode, - FoundSemanticError, !MaybeWrittenSpecs, !IO) :- + QualInfo, InvalidTypeSpecs, InvalidInstModeSpecs, FoundSemanticError, + !MaybeWrittenSpecs, !IO) :- maybe_write_not_yet_written_specs(ErrorStream, Globals, Verbose, !MaybeWrittenSpecs, !IO), maybe_write_string(ProgressStream, Verbose, @@ -636,10 +645,13 @@ make_hlds(ProgressStream, ErrorStream, Globals, AugCompUnit, EventSet, MQInfo, module_name_to_cur_dir_file_name(ext_cur_user_hlds_dump, ModuleName, DumpBaseFileName), parse_tree_to_hlds(ProgressStream, AugCompUnit, Globals, DumpBaseFileName, - MQInfo, TypeEqvMap, UsedEqvModules, UnusedImports, QualInfo, - FoundInvalidType, FoundInvalidInstOrMode, !:HLDS, MakeSpecs), + MQInfo, TypeEqvMap, UsedEqvModules, UnusedImports, QualInfo, !:HLDS, + InvalidTypeSpecs, InvalidInstModeSpecs, MakeSpecs), + add_to_be_written_specs(InvalidTypeSpecs, !MaybeWrittenSpecs), + add_to_be_written_specs(InvalidInstModeSpecs, !MaybeWrittenSpecs), add_to_be_written_specs(MakeSpecs, !MaybeWrittenSpecs), module_info_set_event_set(EventSet, !HLDS), + % ZZZ io.get_exit_status(Status, !IO), SpecsSoFar = maybe_written_specs_to_specs(!.MaybeWrittenSpecs), SpecsErrors = contains_errors(Globals, SpecsSoFar), @@ -649,6 +661,7 @@ make_hlds(ProgressStream, ErrorStream, Globals, AugCompUnit, EventSet, MQInfo, ) then FoundSemanticError = yes, + % ZZZ io.set_exit_status(1, !IO) else FoundSemanticError = no diff --git a/compiler/module_qual.id_set.m b/compiler/module_qual.id_set.m index 18207b970..bebfb5327 100644 --- a/compiler/module_qual.id_set.m +++ b/compiler/module_qual.id_set.m @@ -15,7 +15,6 @@ :- import_module mdbcomp. :- import_module mdbcomp.sym_name. -:- import_module parse_tree.error_spec. :- import_module parse_tree.module_qual.mq_info. :- import_module parse_tree.module_qual.qual_errors. :- import_module parse_tree.prog_data. @@ -117,17 +116,20 @@ :- pred get_names_in_id_set(id_set::in, list(string)::out) is det. + % find_unique_match(InInt, ErrorContext, IdSet, IdType, Id0, SymName, + % !Info): + % % Find the unique match in the current name space for a given mq_id % from a list of ids. If none exists, either because no match was found - % or multiple matches were found, report an error. + % or multiple matches were found, generate an error report, and + % put this report into the appropriate fiels of !:Info. % % This predicate assumes that type_ids, inst_ids, mode_ids and % class_ids have the same representation. % :- pred find_unique_match(mq_in_interface::in, mq_error_context::in, id_set::in, qual_id_kind::in, mq_id::in, sym_name::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. %---------------------------------------------------------------------------% @@ -142,6 +144,7 @@ :- implementation. +:- import_module parse_tree.error_spec. :- import_module recompilation. :- import_module recompilation.item_types. :- import_module recompilation.record_uses. @@ -150,10 +153,10 @@ :- import_module bool. :- import_module map. :- import_module maybe. +:- import_module one_or_more_map. :- import_module pair. :- import_module require. :- import_module set. -:- import_module set_tree234. %---------------------------------------------------------------------------% @@ -292,8 +295,7 @@ get_names_in_id_set(IdSet, Names) :- %---------------------------------------------------------------------------% -find_unique_match(InInt, ErrorContext, IdSet, IdType, Id0, SymName, - !Info, !Specs) :- +find_unique_match(InInt, ErrorContext, IdSet, IdType, Id0, SymName, !Info) :- % Find all IDs which match the current id. Id0 = mq_id(SymName0, Arity), BaseName = unqualify_name(SymName0), @@ -306,13 +308,12 @@ find_unique_match(InInt, ErrorContext, IdSet, IdType, Id0, SymName, mq_info_get_should_report_errors(!.Info, ReportErrors), ( ReportErrors = should_report_errors, - mq_info_record_undef_mq_id(IdType, Id0, !Info), - mq_info_get_this_module(!.Info, ThisModuleName), id_set_search_sym(IdSet, SymName0, PossibleArities), report_undefined_mq_id(!.Info, ErrorContext, Id0, IdType, ThisModuleName, IntMismatches, QualMismatches, - PossibleArities, !Specs), + PossibleArities, Spec), + mq_info_record_undef_mq_id(IdType, Id0, Spec, !Info), % If a module defines an entity that this module refers to, % even without the required module qualification, then reporting @@ -334,10 +335,10 @@ find_unique_match(InInt, ErrorContext, IdSet, IdType, Id0, SymName, mq_info_get_should_report_errors(!.Info, ReportErrors), ( ReportErrors = should_report_errors, - mq_info_record_undef_mq_id(IdType, Id0, !Info), NonUsableModuleNames = IntMismatches ++ QualMismatches, report_ambiguous_match(ErrorContext, Id0, IdType, - Matches, NonUsableModuleNames, !Specs) + Matches, NonUsableModuleNames, Spec), + mq_info_record_undef_mq_id(IdType, Id0, Spec, !Info) ; ReportErrors = should_not_report_errors ) @@ -357,39 +358,43 @@ find_unique_match(InInt, ErrorContext, IdSet, IdType, Id0, SymName, record_used_item(UsedItemType, ItemName0, ItemName), !Info) ). -:- pred mq_info_record_undef_mq_id(qual_id_kind::in, mq_id::in, +:- pred mq_info_record_undef_mq_id(qual_id_kind::in, mq_id::in, error_spec::in, mq_info::in, mq_info::out) is det. -mq_info_record_undef_mq_id(IdType, Id, !Info) :- - mq_info_get_suppress_found_undef(!.Info, SuppressFoundUndef), +mq_info_record_undef_mq_id(IdType, Id, Spec, !Info) :- + mq_info_get_is_undef_blocking(!.Info, MaybeBlocking), ( - SuppressFoundUndef = suppress_found_undef + MaybeBlocking = undef_is_not_blocking, + mq_info_get_nonblocking_undef_specs(!.Info, Specs0), + Specs = [Spec | Specs0], + mq_info_set_nonblocking_undef_specs(Specs, !Info) ; - SuppressFoundUndef = do_not_suppress_found_undef, + MaybeBlocking = undef_is_blocking, Id = mq_id(SymName, Arity), ( IdType = qual_id_type, TypeCtor = type_ctor(SymName, Arity), mq_info_get_undef_types(!.Info, UndefTypes0), - set_tree234.insert(TypeCtor, UndefTypes0, UndefTypes), + one_or_more_map.add(TypeCtor, Spec, UndefTypes0, UndefTypes), mq_info_set_undef_types(UndefTypes, !Info) ; IdType = qual_id_inst, InstCtor = inst_ctor(SymName, Arity), mq_info_get_undef_insts(!.Info, UndefInsts0), - set_tree234.insert(InstCtor, UndefInsts0, UndefInsts), + one_or_more_map.add(InstCtor, Spec, UndefInsts0, UndefInsts), mq_info_set_undef_insts(UndefInsts, !Info) ; IdType = qual_id_mode, ModeCtor = mode_ctor(SymName, Arity), mq_info_get_undef_modes(!.Info, UndefModes0), - set_tree234.insert(ModeCtor, UndefModes0, UndefModes), + one_or_more_map.add(ModeCtor, Spec, UndefModes0, UndefModes), mq_info_set_undef_modes(UndefModes, !Info) ; IdType = qual_id_class, SNA = sym_name_arity(SymName, Arity), mq_info_get_undef_typeclasses(!.Info, UndefTypeclasses0), - set_tree234.insert(SNA, UndefTypeclasses0, UndefTypeclasses), + one_or_more_map.add(SNA, Spec, + UndefTypeclasses0, UndefTypeclasses), mq_info_set_undef_typeclasses(UndefTypeclasses, !Info) ) ). diff --git a/compiler/module_qual.mq_info.m b/compiler/module_qual.mq_info.m index 53c004c20..6834b3e96 100644 --- a/compiler/module_qual.mq_info.m +++ b/compiler/module_qual.mq_info.m @@ -19,6 +19,7 @@ :- import_module libs.globals. :- import_module mdbcomp. :- import_module mdbcomp.sym_name. +:- import_module parse_tree.error_spec. :- import_module parse_tree.module_qual.id_set. :- import_module parse_tree.prog_data. :- import_module parse_tree.prog_parse_tree. @@ -28,6 +29,7 @@ :- import_module bool. :- import_module list. :- import_module maybe. +:- import_module one_or_more_map. :- import_module set_tree234. %---------------------------------------------------------------------------% @@ -36,9 +38,11 @@ ---> should_not_report_errors ; should_report_errors. -:- type maybe_suppress_found_undef - ---> do_not_suppress_found_undef - ; suppress_found_undef. +:- type is_undef_blocking + ---> undef_is_blocking + ; undef_is_not_blocking. + +:- type undef_specs(T) == one_or_more_map(T, error_spec). %---------------------------------------------------------------------------% @@ -66,15 +70,17 @@ set_tree234(module_name)::out) is det. :- pred mq_info_get_exported_instances_flag(mq_info::in, bool::out) is det. :- pred mq_info_get_undef_types(mq_info::in, - set_tree234(type_ctor)::out) is det. + undef_specs(type_ctor)::out) is det. :- pred mq_info_get_undef_insts(mq_info::in, - set_tree234(inst_ctor)::out) is det. + undef_specs(inst_ctor)::out) is det. :- pred mq_info_get_undef_modes(mq_info::in, - set_tree234(mode_ctor)::out) is det. + undef_specs(mode_ctor)::out) is det. :- pred mq_info_get_undef_typeclasses(mq_info::in, - set_tree234(sym_name_arity)::out) is det. -:- pred mq_info_get_suppress_found_undef(mq_info::in, - maybe_suppress_found_undef::out) is det. + undef_specs(sym_name_arity)::out) is det. +:- pred mq_info_get_is_undef_blocking(mq_info::in, + is_undef_blocking::out) is det. +:- pred mq_info_get_nonblocking_undef_specs(mq_info::in, + list(error_spec)::out) is det. :- pred mq_info_get_should_report_errors(mq_info::in, maybe_should_report_errors::out) is det. @@ -99,15 +105,17 @@ mq_info::in, mq_info::out) is det. :- pred mq_info_set_exported_instances_flag(bool::in, mq_info::in, mq_info::out) is det. -:- pred mq_info_set_undef_types(set_tree234(type_ctor)::in, +:- pred mq_info_set_undef_types(undef_specs(type_ctor)::in, mq_info::in, mq_info::out) is det. -:- pred mq_info_set_undef_insts(set_tree234(inst_ctor)::in, +:- pred mq_info_set_undef_insts(undef_specs(inst_ctor)::in, mq_info::in, mq_info::out) is det. -:- pred mq_info_set_undef_modes(set_tree234(mode_ctor)::in, +:- pred mq_info_set_undef_modes(undef_specs(mode_ctor)::in, mq_info::in, mq_info::out) is det. -:- pred mq_info_set_undef_typeclasses(set_tree234(sym_name_arity)::in, +:- pred mq_info_set_undef_typeclasses(undef_specs(sym_name_arity)::in, mq_info::in, mq_info::out) is det. -:- pred mq_info_set_suppress_found_undef(maybe_suppress_found_undef::in, +:- pred mq_info_set_is_undef_blocking(is_undef_blocking::in, + mq_info::in, mq_info::out) is det. +:- pred mq_info_set_nonblocking_undef_specs(list(error_spec)::in, mq_info::in, mq_info::out) is det. %---------------------------------------------------------------------------% @@ -160,6 +168,15 @@ :- pred mq_info_set_module_used(mq_in_interface::in, module_name::in, mq_info::in, mq_info::out) is det. +%---------------------------------------------------------------------------% + + % get_error_specs_in_mq_info(Info, + % InvalidTypeSpecs, InvalidInstModeSpecs, NonBlockingUndefSpecs) + % +:- pred get_error_specs_in_mq_info(mq_info::in, + list(error_spec)::out, list(error_spec)::out, list(error_spec)::out) + is det. + %---------------------------------------------------------------------------% %---------------------------------------------------------------------------% @@ -220,17 +237,18 @@ mqsi_exported_instances_flag :: bool, % What types, insts, modes or typeclasses are undefined? - mqsi_undef_types :: set_tree234(type_ctor), - mqsi_undef_insts :: set_tree234(inst_ctor), - mqsi_undef_modes :: set_tree234(mode_ctor), - mqsi_undef_typeclasses :: set_tree234(sym_name_arity), + mqsi_undef_types :: undef_specs(type_ctor), + mqsi_undef_insts :: undef_specs(inst_ctor), + mqsi_undef_modes :: undef_specs(mode_ctor), + mqsi_undef_typeclasses :: undef_specs(sym_name_arity), - % Do we want to suppress the recording of an undef type, inst, - % mode or typeclass, as such? We sometimes do, when the error - % won't prevent us from continuing on to later compiler passes. - % (We still generate error messages in such instances, of - % course.) - mqsi_suppress_found_undef :: maybe_suppress_found_undef, + % When we find undefined type, inst, mode or typeclass, + % do we want to record is blocking (meaning we record it + % in one of the four fields above, where its presence will + % prevent the compiler to proceeding to some passes), + % or as nonblocking (meaning we record it in the field below). + mqsi_is_undef_blocking :: is_undef_blocking, + mqsi_nonblocking_undef_specs :: list(error_spec), % Do we want to report errors. mqsi_should_report_errors :: maybe_should_report_errors, @@ -258,8 +276,9 @@ init_mq_info(Globals, ModuleName, ReportErrors, Info) :- set_tree234.make_singleton_set(mercury_public_builtin_module), SubInfo = mq_sub_info(ModuleName, ImportedOrUsedModules, InstanceModules, ExportedInstancesFlag, - set_tree234.init, set_tree234.init, set_tree234.init, set_tree234.init, - do_not_suppress_found_undef, ReportErrors, 0), + one_or_more_map.init, one_or_more_map.init, + one_or_more_map.init, one_or_more_map.init, + undef_is_blocking, [], ReportErrors, 0), id_set_init(ModuleIdSet), id_set_init(TypeIdSet), @@ -313,8 +332,10 @@ mq_info_get_undef_modes(Info, X) :- X = Info ^ mqi_sub_info ^ mqsi_undef_modes. mq_info_get_undef_typeclasses(Info, X) :- X = Info ^ mqi_sub_info ^ mqsi_undef_typeclasses. -mq_info_get_suppress_found_undef(Info, X) :- - X = Info ^ mqi_sub_info ^ mqsi_suppress_found_undef. +mq_info_get_is_undef_blocking(Info, X) :- + X = Info ^ mqi_sub_info ^ mqsi_is_undef_blocking. +mq_info_get_nonblocking_undef_specs(Info, X) :- + X = Info ^ mqi_sub_info ^ mqsi_nonblocking_undef_specs. mq_info_get_should_report_errors(Info, X) :- X = Info ^ mqi_sub_info ^ mqsi_should_report_errors. @@ -347,8 +368,10 @@ mq_info_set_undef_modes(X, !Info) :- !Info ^ mqi_sub_info ^ mqsi_undef_modes := X. mq_info_set_undef_typeclasses(X, !Info) :- !Info ^ mqi_sub_info ^ mqsi_undef_typeclasses := X. -mq_info_set_suppress_found_undef(X, !Info) :- - !Info ^ mqi_sub_info ^ mqsi_suppress_found_undef := X. +mq_info_set_is_undef_blocking(X, !Info) :- + !Info ^ mqi_sub_info ^ mqsi_is_undef_blocking := X. +mq_info_set_nonblocking_undef_specs(X, !Info) :- + !Info ^ mqi_sub_info ^ mqsi_nonblocking_undef_specs := X. %---------------------------------------------------------------------------% @@ -433,6 +456,22 @@ mq_info_set_module_used(InInt, ModuleName, !Info) :- InInt = mq_not_used_in_interface ). +%---------------------------------------------------------------------------% + +get_error_specs_in_mq_info(Info, + InvalidTypeSpecs, InvalidInstModeSpecs, NonBlockingUndefSpecs) :- + mq_info_get_undef_types(Info, UndefTypesMap), + mq_info_get_undef_insts(Info, UndefInstsMap), + mq_info_get_undef_modes(Info, UndefModesMap), + mq_info_get_undef_typeclasses(Info, UndefTypeClassesMap), + one_or_more_map.values(UndefTypesMap, UndefTypeSpecs), + one_or_more_map.values(UndefInstsMap, UndefInstSpecs), + one_or_more_map.values(UndefModesMap, UndefModeSpecs), + one_or_more_map.values(UndefTypeClassesMap, UndefTypeClassSpecs), + InvalidTypeSpecs = UndefTypeSpecs ++ UndefTypeClassSpecs, + InvalidInstModeSpecs = UndefInstSpecs ++ UndefModeSpecs, + mq_info_get_nonblocking_undef_specs(Info, NonBlockingUndefSpecs). + %---------------------------------------------------------------------------% :- end_module parse_tree.module_qual.mq_info. %---------------------------------------------------------------------------% diff --git a/compiler/module_qual.qual_errors.m b/compiler/module_qual.qual_errors.m index e4a786a47..55cef8894 100644 --- a/compiler/module_qual.qual_errors.m +++ b/compiler/module_qual.qual_errors.m @@ -25,7 +25,6 @@ :- import_module list. :- import_module maybe. :- import_module one_or_more. -:- import_module pair. :- import_module set. %---------------------------------------------------------------------------% @@ -176,32 +175,36 @@ %---------------------------------------------------------------------------% - % Report an undefined type, inst or mode. + % report_undefined_mq_id(Info, ErrorContext, Id, IdType, ThisModuleName, + % IntMismatches0, QualMismatches0, PossibleAritiesSet, Spec): + % + % Report an undefined type, inst, mode, or typeclass. % :- pred report_undefined_mq_id(mq_info::in, mq_error_context::in, mq_id::in, qual_id_kind::in, module_name::in, list(module_name)::in, list(module_name)::in, set(int)::in, - list(error_spec)::in, list(error_spec)::out) is det. + error_spec::out) is det. - % Report an error where a type, inst, mode or typeclass had + % report_ambiguous_match(ErrorContext, Id, IdType, + % UsableModuleNames, UnusableModuleNames, !Specs): + % + % Report an error where a type, inst, mode. or typeclass had % multiple possible matches. % :- pred report_ambiguous_match(mq_error_context::in, mq_id::in, qual_id_kind::in, - list(module_name)::in, list(module_name)::in, - list(error_spec)::in, list(error_spec)::out) is det. + list(module_name)::in, list(module_name)::in, error_spec::out) is det. % Output an error message about an ill-formed user_inst. % :- pred report_invalid_user_inst(sym_name::in, list(mer_inst)::in, - mq_error_context::in, list(error_spec)::in, list(error_spec)::out) is det. + mq_error_context::in, error_spec::out) is det. % Warn about a module imported in the interface that is not used % in the interface. % :- pred warn_unused_interface_import(module_name::in, - pair(module_name, one_or_more(prog_context))::in, - list(error_spec)::in, list(error_spec)::out) is det. + module_name::in, one_or_more(prog_context)::in, error_spec::out) is det. %---------------------------------------------------------------------------% @@ -219,7 +222,7 @@ %---------------------------------------------------------------------------% report_undefined_mq_id(Info, ErrorContext, Id, IdType, ThisModuleName, - IntMismatches0, QualMismatches0, PossibleAritiesSet, !Specs) :- + IntMismatches0, QualMismatches0, PossibleAritiesSet, Spec) :- mq_error_context_to_pieces(ErrorContext, Context, ShouldUnqualId, ErrorContextPieces), InPieces = [words("In")] ++ ErrorContextPieces ++ [suffix(":"), nl, @@ -389,8 +392,7 @@ report_undefined_mq_id(Info, ErrorContext, Id, IdType, ThisModuleName, AllPieces = InPieces ++ UndefPieces ++ ThisIntPieces ++ OtherIntPieces ++ QualPieces ++ NonImportedPieces ++ OtherArityPieces ++ DidYouMeanPieces, - Spec = spec($pred, severity_error, phase_pt2h, Context, AllPieces), - !:Specs = [Spec | !.Specs]. + Spec = spec($pred, severity_error, phase_pt2h, Context, AllPieces). :- func module_name_matches_some(module_name, list(module_name)) = bool. @@ -404,7 +406,7 @@ module_name_matches_some(SearchModuleName, [ModuleName | ModuleNames]) = ). report_ambiguous_match(ErrorContext, Id, IdType, - UsableModuleNames, UnusableModuleNames, !Specs) :- + UsableModuleNames, UnusableModuleNames, Spec) :- mq_error_context_to_pieces(ErrorContext, Context, _ShouldUnqualId, ErrorContextPieces), qual_id_kind_to_string(IdType, IdTypeStr), @@ -443,12 +445,11 @@ report_ambiguous_match(ErrorContext, Id, IdType, Msg = simple_msg(Context, [always(MainPieces), always(UnusablePieces), verbose_only(verbose_always, VerbosePieces)]), - Spec = error_spec($pred, severity_error, phase_pt2h, [Msg]), - !:Specs = [Spec | !.Specs]. + Spec = error_spec($pred, severity_error, phase_pt2h, [Msg]). %---------------------------------------------------------------------------% -report_invalid_user_inst(_SymName, _Insts, ErrorContext, !Specs) :- +report_invalid_user_inst(_SymName, _Insts, ErrorContext, Spec) :- mq_error_context_to_pieces(ErrorContext, Context, _ShouldUnqualId, ErrorContextPieces), % XXX It would be nice to print the name of the variable. @@ -470,13 +471,12 @@ report_invalid_user_inst(_SymName, _Insts, ErrorContext, !Specs) :- [words("got a")] ++ color_as_incorrect([words("variable.")]) ++ [nl], - Spec = spec($pred, severity_error, phase_pt2h, Context, Pieces), - !:Specs = [Spec | !.Specs]. + Spec = spec($pred, severity_error, phase_pt2h, Context, Pieces). %---------------------------------------------------------------------------% warn_unused_interface_import(ParentModuleName, - ImportedModuleName - ImportContexts, !Specs) :- + ImportedModuleName, ImportContexts, Spec) :- % UNUSED_IMPORT Harmonize the operation of this predicate with % the operation of generate_unused_warning in unused_imports.m. % @@ -498,8 +498,7 @@ warn_unused_interface_import(ParentModuleName, % and it will be more precise than we can do here, because it will know % whether the imported module is used in the *implementation* section. Severity = severity_warning(warn_unused_interface_imports), - Spec = spec($pred, Severity, phase_pt2h, HeadContext, HeadPieces), - !:Specs = [Spec | !.Specs]. + Spec = spec($pred, Severity, phase_pt2h, HeadContext, HeadPieces). %---------------------------------------------------------------------------% %---------------------------------------------------------------------------% diff --git a/compiler/module_qual.qualify_items.m b/compiler/module_qual.qualify_items.m index d6f9fb6c0..2465b3180 100644 --- a/compiler/module_qual.qualify_items.m +++ b/compiler/module_qual.qualify_items.m @@ -29,14 +29,14 @@ :- import_module parse_tree.prog_parse_tree. :- import_module list. +:- import_module map. :- import_module set_tree234. %---------------------------------------------------------------------------% % module_qualify_aug_comp_unit(Globals, AugCompUnit0, AugCompUnit, % EventSpecMap0, EventSpecMap, MaybeContext, EventSpecFileName, MQ_Info, - % UnusedImportsSet, UndefTypes, UndefInsts, UndefModes, - % UndefTypeClasses, !Specs): + % UnusedImportsSet, UnusedImportsSpecsMap): % % AugCompUnit is AugCompUnit0 with all items module qualified % as much as possible; likewise for EventSpecMap0 and EventSpecMap. @@ -46,10 +46,7 @@ :- pred module_qualify_aug_comp_unit(globals::in, aug_compilation_unit::in, aug_compilation_unit::out, event_spec_map::in, event_spec_map::out, string::in, mq_info::out, - set_tree234(module_name)::out, - set_tree234(type_ctor)::out, set_tree234(inst_ctor)::out, - set_tree234(mode_ctor)::out, set_tree234(sym_name_arity)::out, - list(error_spec)::in, list(error_spec)::out) is det. + set_tree234(module_name)::out, map(module_name, error_spec)::out) is det. :- pred module_qualify_aug_make_int_unit(globals::in, aug_make_int_unit::in, aug_make_int_unit::out, @@ -70,22 +67,19 @@ % This is called from qual_info.m to qualify explicit type qualifications. % :- pred qualify_type_qualification(mq_in_interface::in, prog_context::in, - mer_type::in, mer_type::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mer_type::in, mer_type::out, mq_info::in, mq_info::out) is det. % This is called from add_clause.m to qualify the modes % in mode-specific clauses. % :- pred qualify_clause_mode_list(mq_in_interface::in, prog_context::in, - list(mer_mode)::in, list(mer_mode)::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + list(mer_mode)::in, list(mer_mode)::out, mq_info::in, mq_info::out) is det. % This is called from superhomogeneous.m to qualify the modes of arguments % in lambda expressions. % :- pred qualify_lambda_mode(mq_in_interface::in, prog_context::in, - mer_mode::in, mer_mode::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mer_mode::in, mer_mode::out, mq_info::in, mq_info::out) is det. %---------------------------------------------------------------------------% @@ -106,9 +100,9 @@ :- import_module assoc_list. :- import_module bool. :- import_module int. -:- import_module map. :- import_module maybe. :- import_module one_or_more. +:- import_module one_or_more_map. :- import_module pair. :- import_module require. :- import_module term_context. @@ -117,8 +111,7 @@ module_qualify_aug_comp_unit(Globals, AugCompUnit0, AugCompUnit, EventSpecMap0, EventSpecMap, EventSpecFileName, !:Info, - UnusedImportsSet, UndefTypes, UndefInsts, UndefModes, - UndefTypeClasses, !Specs) :- + UnusedImportsSet, UnusedImportsSpecsMap) :- AugCompUnit0 = aug_compilation_unit(ParseTreeModuleSrc0, AncestorIntSpecs, DirectInt1Specs, IndirectInt2Specs, PlainOptSpecs, TransOptSpecs, IntForOptSpecs, TypeRepnSpecs, @@ -132,20 +125,22 @@ module_qualify_aug_comp_unit(Globals, AugCompUnit0, AugCompUnit, list.foldl(collect_mq_info_in_direct_int1_spec, map.values(DirectInt1Specs), !Info), qualify_parse_tree_module_src(ParseTreeModuleSrc0, ParseTreeModuleSrc, - !Info, !Specs), + !Info), AugCompUnit = aug_compilation_unit(ParseTreeModuleSrc, AncestorIntSpecs, DirectInt1Specs, IndirectInt2Specs, PlainOptSpecs, TransOptSpecs, IntForOptSpecs, TypeRepnSpecs, ModuleVersionNumbers), + % Note that unlike module_qualify_aug_make_int_unit, we do not call + % get_error_specs_in_mq_info here. This is because we want to retrieve + % the errors not from the current version !.Info, but from the version + % that parse_tree_to_hlds has built on top of !.Info by adding all + % the contents of AugCompUnit to the HLDS. Therefore that call + % will occur at the end of the body of inparse_tree_to_hlds. map.to_assoc_list(EventSpecMap0, EventSpecList0), qualify_event_specs(mq_not_used_in_interface, EventSpecFileName, - EventSpecList0, EventSpecList, !Info, !Specs), + EventSpecList0, EventSpecList, !Info), map.from_assoc_list(EventSpecList, EventSpecMap), - mq_info_get_undef_types(!.Info, UndefTypes), - mq_info_get_undef_insts(!.Info, UndefInsts), - mq_info_get_undef_modes(!.Info, UndefModes), - mq_info_get_undef_typeclasses(!.Info, UndefTypeClasses), globals.lookup_bool_option(Globals, warn_unused_interface_imports, WarnUnusedInterfaceImports), @@ -156,23 +151,25 @@ module_qualify_aug_comp_unit(Globals, AugCompUnit0, AugCompUnit, ; WarnUnusedImports = yes ) then - get_unused_imports_map(!.Info, UnusedImportsMap), - map.keys(UnusedImportsMap, UnusedImports), + get_unused_imports_map(!.Info, UnusedImportsContextMap), + map.keys(UnusedImportsContextMap, UnusedImports), set_tree234.sorted_list_to_set(UnusedImports, UnusedImportsSet), ( - WarnUnusedImports = yes + WarnUnusedImports = yes, % The unused imports will be reported later by unused_imports.m. % That is why we return UnusedImportsSet to our caller, to be % stored in the HLDS until unused_imports.m can look at it. + map.init(UnusedImportsSpecsMap) ; WarnUnusedImports = no, % We can get here only if WarnUnusedInterfaceImports is yes. - map.to_assoc_list(UnusedImportsMap, UnusedImportsAL), - list.foldl(warn_unused_interface_import(ModuleName), - UnusedImportsAL, !Specs) + get_unused_imports_map(!.Info, UnusedImportsContextsMap), + map.map_values(warn_unused_interface_import(ModuleName), + UnusedImportsContextsMap, UnusedImportsSpecsMap) ) else - UnusedImportsSet = set_tree234.init + UnusedImportsSet = set_tree234.init, + map.init(UnusedImportsSpecsMap) ). %---------------------% @@ -192,20 +189,26 @@ module_qualify_aug_make_int_unit(Globals, AugMakeIntUnit0, AugMakeIntUnit, list.foldl(collect_mq_info_in_direct_int3_spec, map.values(DirectInt3Specs), !Info), qualify_parse_tree_module_src(ParseTreeModuleSrc0, ParseTreeModuleSrc, - !Info, !Specs), + !Info), AugMakeIntUnit = aug_make_int_unit(ParseTreeModuleSrc, DelayedSpecs0, AncestorInt0s, DirectInt3Specs, IndirectInt3Specs, ModuleVersionNumbers), + get_error_specs_in_mq_info(!.Info, + InvalidTypeSpecs, InvalidInstModeSpecs, NonBlockingUndefSpecs), + !:Specs = InvalidTypeSpecs ++ InvalidInstModeSpecs ++ + NonBlockingUndefSpecs ++ !.Specs, + globals.lookup_bool_option(Globals, warn_unused_interface_imports, WarnInterfaceImports), ( WarnInterfaceImports = no ; WarnInterfaceImports = yes, - get_unused_imports_map(!.Info, UnusedImportsMap), - map.to_assoc_list(UnusedImportsMap, UnusedImports), - list.foldl(warn_unused_interface_import(ModuleName), UnusedImports, - !Specs) + get_unused_imports_map(!.Info, UnusedImportsContextsMap), + map.map_values(warn_unused_interface_import(ModuleName), + UnusedImportsContextsMap, UnusedImportsSpecsMap), + map.values(UnusedImportsSpecsMap, UnusedImportsSpecs), + !:Specs = UnusedImportsSpecs ++ !.Specs ) ). @@ -262,7 +265,11 @@ module_qualify_parse_tree_int3(Globals, OrigParseTreeInt3, ParseTreeInt3, collect_mq_info_in_parse_tree_int3(int3_as_src, OrigParseTreeInt3, Info0, Info1), qualify_parse_tree_int3(OrigParseTreeInt3, ParseTreeInt3, - Info1, _Info, !Specs). + Info1, Info), + get_error_specs_in_mq_info(Info, + InvalidTypeSpecs, InvalidInstModeSpecs, NonBlockingUndefSpecs), + !:Specs = InvalidTypeSpecs ++ InvalidInstModeSpecs ++ + NonBlockingUndefSpecs ++ !.Specs. %---------------------------------------------------------------------------% @@ -270,11 +277,10 @@ module_qualify_parse_tree_int3(Globals, OrigParseTreeInt3, ParseTreeInt3, % :- pred qualify_parse_tree_module_src( parse_tree_module_src::in, parse_tree_module_src::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_parse_tree_module_src(ParseTreeModuleSrc0, ParseTreeModuleSrc, - !Info, !Specs) :- + !Info) :- ParseTreeModuleSrc0 = parse_tree_module_src(ModuleName, ModuleNameContext, InclMap, ImportUseMap, IntFIMSpecMap, ImpFIMSpecMap, IntSelfFIMLangs, ImpSelfFIMLangs, @@ -290,52 +296,52 @@ qualify_parse_tree_module_src(ParseTreeModuleSrc0, ParseTreeModuleSrc, ImpDeclPragmas0, ImpDeclMarkers0, ImpImplPragmas0, ImpImplMarkers0, ImpPromises0, ImpInitialises0, ImpFinalises0, ImpMutables0), - map.map_values_foldl2(module_qualify_type_ctor_checked_defn, - TypeCtorCheckedMap0, TypeCtorCheckedMap, !Info, !Specs), - map.map_values_foldl2(module_qualify_inst_ctor_checked_defn, - InstCtorCheckedMap0, InstCtorCheckedMap, !Info, !Specs), - map.map_values_foldl2(module_qualify_mode_ctor_checked_defn, - ModeCtorCheckedMap0, ModeCtorCheckedMap, !Info, !Specs), + map.map_values_foldl(module_qualify_type_ctor_checked_defn, + TypeCtorCheckedMap0, TypeCtorCheckedMap, !Info), + map.map_values_foldl(module_qualify_inst_ctor_checked_defn, + InstCtorCheckedMap0, InstCtorCheckedMap, !Info), + map.map_values_foldl(module_qualify_mode_ctor_checked_defn, + ModeCtorCheckedMap0, ModeCtorCheckedMap, !Info), InInt = mq_used_in_interface, - list.map_foldl2(module_qualify_item_typeclass(InInt), - IntTypeClasses0, IntTypeClasses, !Info, !Specs), - list.map_foldl2(module_qualify_item_instance(InInt), - IntInstances0, IntInstances, !Info, !Specs), - list.map_foldl2(module_qualify_item_pred_decl(InInt), - IntPredDecls0, IntPredDecls, !Info, !Specs), - list.map_foldl2(module_qualify_item_mode_decl(InInt), - IntModeDecls0, IntModeDecls, !Info, !Specs), - list.map_foldl2(module_qualify_item_decl_pragma(InInt), - IntDeclPragmas0, IntDeclPragmas, !Info, !Specs), + list.map_foldl(module_qualify_item_typeclass(InInt), + IntTypeClasses0, IntTypeClasses, !Info), + list.map_foldl(module_qualify_item_instance(InInt), + IntInstances0, IntInstances, !Info), + list.map_foldl(module_qualify_item_pred_decl(InInt), + IntPredDecls0, IntPredDecls, !Info), + list.map_foldl(module_qualify_item_mode_decl(InInt), + IntModeDecls0, IntModeDecls, !Info), + list.map_foldl(module_qualify_item_decl_pragma(InInt), + IntDeclPragmas0, IntDeclPragmas, !Info), % Promises don't need to be qualified. IntPromises = IntPromises0, InImp = mq_not_used_in_interface, - list.map_foldl2(module_qualify_item_typeclass(InImp), - ImpTypeClasses0, ImpTypeClasses, !Info, !Specs), - list.map_foldl2(module_qualify_item_instance(InImp), - ImpInstances0, ImpInstances, !Info, !Specs), - list.map_foldl2(module_qualify_item_pred_decl(InImp), - ImpPredDecls0, ImpPredDecls, !Info, !Specs), - list.map_foldl2(module_qualify_item_mode_decl(InImp), - ImpModeDecls0, ImpModeDecls, !Info, !Specs), + list.map_foldl(module_qualify_item_typeclass(InImp), + ImpTypeClasses0, ImpTypeClasses, !Info), + list.map_foldl(module_qualify_item_instance(InImp), + ImpInstances0, ImpInstances, !Info), + list.map_foldl(module_qualify_item_pred_decl(InImp), + ImpPredDecls0, ImpPredDecls, !Info), + list.map_foldl(module_qualify_item_mode_decl(InImp), + ImpModeDecls0, ImpModeDecls, !Info), % Clauses don't need to be qualified. ImpClauses = ImpClauses0, - list.map_foldl2(module_qualify_item_foreign_proc(InImp), - ImpForeignProcs0, ImpForeignProcs, !Info, !Specs), - list.map_foldl2(module_qualify_item_foreign_export_enum(InImp), - ImpForeignExportEnums0, ImpForeignExportEnums, !Info, !Specs), - list.map_foldl2(module_qualify_item_decl_pragma(InImp), - ImpDeclPragmas0, ImpDeclPragmas, !Info, !Specs), - list.map_foldl2(module_qualify_item_impl_pragma(InImp), - ImpImplPragmas0, ImpImplPragmas, !Info, !Specs), + list.map_foldl(module_qualify_item_foreign_proc(InImp), + ImpForeignProcs0, ImpForeignProcs, !Info), + list.map_foldl(module_qualify_item_foreign_export_enum(InImp), + ImpForeignExportEnums0, ImpForeignExportEnums, !Info), + list.map_foldl(module_qualify_item_decl_pragma(InImp), + ImpDeclPragmas0, ImpDeclPragmas, !Info), + list.map_foldl(module_qualify_item_impl_pragma(InImp), + ImpImplPragmas0, ImpImplPragmas, !Info), % Initialise and finalise items and promises don't need to be qualified. ImpInitialises = ImpInitialises0, ImpFinalises = ImpFinalises0, ImpPromises = ImpPromises0, - list.map_foldl2(module_qualify_item_mutable(InImp), - ImpMutables0, ImpMutables, !Info, !Specs), + list.map_foldl(module_qualify_item_mutable(InImp), + ImpMutables0, ImpMutables, !Info), ParseTreeModuleSrc = parse_tree_module_src(ModuleName, ModuleNameContext, InclMap, ImportUseMap, @@ -355,28 +361,27 @@ qualify_parse_tree_module_src(ParseTreeModuleSrc0, ParseTreeModuleSrc, %---------------------------------------------------------------------------% :- pred qualify_parse_tree_int3(parse_tree_int3::in, parse_tree_int3::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_parse_tree_int3(OrigParseTreeInt3, ParseTreeInt3, !Info, !Specs) :- +qualify_parse_tree_int3(OrigParseTreeInt3, ParseTreeInt3, !Info) :- OrigParseTreeInt3 = parse_tree_int3(ModuleName, ModuleNameContext, InclMap, ImportUseMap, IntTypeDefnMap0, IntInstDefnMap0, IntModeDefnMap0, IntTypeClasses0, IntInstances0, IntTypeRepns0), InInt = mq_used_in_interface, - map.map_values_foldl2(module_qualify_type_ctor_checked_defn, - IntTypeDefnMap0, IntTypeDefnMap, !Info, !Specs), - map.map_values_foldl2(module_qualify_inst_ctor_checked_defn, - IntInstDefnMap0, IntInstDefnMap, !Info, !Specs), - map.map_values_foldl2(module_qualify_mode_ctor_checked_defn, - IntModeDefnMap0, IntModeDefnMap, !Info, !Specs), - list.map_foldl2(module_qualify_item_abstract_typeclass(InInt), - IntTypeClasses0, IntTypeClasses, !Info, !Specs), - list.map_foldl2(module_qualify_item_abstract_instance(InInt), - IntInstances0, IntInstances, !Info, !Specs), - map.map_values_foldl2(module_qualify_item_type_repn(ModuleName, InInt), - IntTypeRepns0, IntTypeRepns, !Info, !Specs), + map.map_values_foldl(module_qualify_type_ctor_checked_defn, + IntTypeDefnMap0, IntTypeDefnMap, !Info), + map.map_values_foldl(module_qualify_inst_ctor_checked_defn, + IntInstDefnMap0, IntInstDefnMap, !Info), + map.map_values_foldl(module_qualify_mode_ctor_checked_defn, + IntModeDefnMap0, IntModeDefnMap, !Info), + list.map_foldl(module_qualify_item_abstract_typeclass(InInt), + IntTypeClasses0, IntTypeClasses, !Info), + list.map_foldl(module_qualify_item_abstract_instance(InInt), + IntInstances0, IntInstances, !Info), + map.map_values_foldl(module_qualify_item_type_repn(ModuleName, InInt), + IntTypeRepns0, IntTypeRepns, !Info), ParseTreeInt3 = parse_tree_int3(ModuleName, ModuleNameContext, InclMap, ImportUseMap, @@ -425,11 +430,9 @@ qualify_parse_tree_int3(OrigParseTreeInt3, ParseTreeInt3, !Info, !Specs) :- :- pred module_qualify_type_ctor_checked_defn( type_ctor_checked_defn::in, type_ctor_checked_defn::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_type_ctor_checked_defn(CheckedDefn0, CheckedDefn, - !Info, !Specs) :- +module_qualify_type_ctor_checked_defn(CheckedDefn0, CheckedDefn, !Info) :- ( CheckedDefn0 = checked_defn_solver(SolverDefn0, SrcDefns0), ( @@ -442,15 +445,15 @@ module_qualify_type_ctor_checked_defn(CheckedDefn0, CheckedDefn, % section. InInt = mq_not_used_in_interface, module_qualify_item_type_defn(qualify_type_defn_solver, - InInt, FullDefn0, FullDefn, !Info, !Specs), + InInt, FullDefn0, FullDefn, !Info), SolverDefn = solver_type_full(MaybeAbsDefn0, FullDefn) ), SrcDefns0 = src_defns_solver(MaybeIntDefn0, MaybeImpDefn0), QualifyPred = module_qualify_item_type_defn(qualify_type_defn), maybe_qualify_defn(QualifyPred, mq_used_in_interface, - MaybeIntDefn0, MaybeIntDefn, !Info, !Specs), + MaybeIntDefn0, MaybeIntDefn, !Info), maybe_qualify_defn(QualifyPred, mq_not_used_in_interface, - MaybeImpDefn0, MaybeImpDefn, !Info, !Specs), + MaybeImpDefn0, MaybeImpDefn, !Info), SrcDefns = src_defns_solver(MaybeIntDefn, MaybeImpDefn), CheckedDefn = checked_defn_solver(SolverDefn, SrcDefns) ; @@ -459,20 +462,20 @@ module_qualify_type_ctor_checked_defn(CheckedDefn0, CheckedDefn, StdDefn0 = std_mer_type_eqv(EqvStatus, EqvDefn0), InInt = std_eqv_status_section(EqvStatus), module_qualify_item_type_defn(qualify_type_defn_eqv, - InInt, EqvDefn0, EqvDefn, !Info, !Specs), + InInt, EqvDefn0, EqvDefn, !Info), StdDefn = std_mer_type_eqv(EqvStatus, EqvDefn) ; StdDefn0 = std_mer_type_subtype(SubStatus, SubDefn0), InInt = std_sub_status_section(SubStatus), module_qualify_item_type_defn(qualify_type_defn_sub, - InInt, SubDefn0, SubDefn, !Info, !Specs), + InInt, SubDefn0, SubDefn, !Info), StdDefn = std_mer_type_subtype(SubStatus, SubDefn) ; StdDefn0 = std_mer_type_du_all_plain_constants(DuStatus, DuDefn0, HeadCtor, TailCtors, CJCsDefnOrEnum), InInt = std_du_status_section(DuStatus), module_qualify_item_type_defn(qualify_type_defn_du, - InInt, DuDefn0, DuDefn, !Info, !Specs), + InInt, DuDefn0, DuDefn, !Info), % Foreign types and foreign enums need no qualification. StdDefn = std_mer_type_du_all_plain_constants(DuStatus, DuDefn, HeadCtor, TailCtors, CJCsDefnOrEnum) @@ -481,7 +484,7 @@ module_qualify_type_ctor_checked_defn(CheckedDefn0, CheckedDefn, DuDefn0, CJCsDefnOrEnum), InInt = std_du_status_section(DuStatus), module_qualify_item_type_defn(qualify_type_defn_du, - InInt, DuDefn0, DuDefn, !Info, !Specs), + InInt, DuDefn0, DuDefn, !Info), % Foreign types and foreign enums need no qualification. StdDefn = std_mer_type_du_not_all_plain_constants(DuStatus, DuDefn, CJCsDefnOrEnum) @@ -493,84 +496,78 @@ module_qualify_type_ctor_checked_defn(CheckedDefn0, CheckedDefn, StdDefn = StdDefn0 ), SrcDefns0 = src_defns_std(IntDefns0, ImpDefns0, ImpForeignEnums0), - list.map_foldl2( + list.map_foldl( module_qualify_item_type_defn(qualify_type_defn, mq_used_in_interface), - IntDefns0, IntDefns, !Info, !Specs), - list.map_foldl2( + IntDefns0, IntDefns, !Info), + list.map_foldl( module_qualify_item_type_defn(qualify_type_defn, mq_not_used_in_interface), - ImpDefns0, ImpDefns, !Info, !Specs), - list.map_foldl2( + ImpDefns0, ImpDefns, !Info), + list.map_foldl( module_qualify_item_foreign_enum(mq_not_used_in_interface), - ImpForeignEnums0, ImpForeignEnums, !Info, !Specs), + ImpForeignEnums0, ImpForeignEnums, !Info), SrcDefns = src_defns_std(IntDefns, ImpDefns, ImpForeignEnums), CheckedDefn = checked_defn_std(StdDefn, SrcDefns) ). :- pred module_qualify_inst_ctor_checked_defn( inst_ctor_checked_defn::in, inst_ctor_checked_defn::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_inst_ctor_checked_defn(CheckedDefn0, CheckedDefn, - !Info, !Specs) :- +module_qualify_inst_ctor_checked_defn(CheckedDefn0, CheckedDefn, !Info) :- CheckedDefn0 = checked_defn_inst(StdInstDefn0, SrcDefns0), StdInstDefn0 = std_inst_defn(Status, MaybeAbstractDefn0), % Because of the inst_for_type_constructor field, % even abstract inst definitions need qualifying. InInt = std_inst_status_section(Status), module_qualify_item_inst_defn(qualify_inst_defn, InInt, - MaybeAbstractDefn0, MaybeAbstractDefn, !Info, !Specs), + MaybeAbstractDefn0, MaybeAbstractDefn, !Info), StdInstDefn = std_inst_defn(Status, MaybeAbstractDefn), SrcDefns0 = src_defns_inst(MaybeIntDefn0, MaybeImpDefn0), QualifyPred = module_qualify_item_inst_defn(qualify_inst_defn), maybe_qualify_defn(QualifyPred, mq_used_in_interface, - MaybeIntDefn0, MaybeIntDefn, !Info, !Specs), + MaybeIntDefn0, MaybeIntDefn, !Info), maybe_qualify_defn(QualifyPred, mq_not_used_in_interface, - MaybeImpDefn0, MaybeImpDefn, !Info, !Specs), + MaybeImpDefn0, MaybeImpDefn, !Info), SrcDefns = src_defns_inst(MaybeIntDefn, MaybeImpDefn), CheckedDefn = checked_defn_inst(StdInstDefn, SrcDefns). :- pred module_qualify_mode_ctor_checked_defn( mode_ctor_checked_defn::in, mode_ctor_checked_defn::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_mode_ctor_checked_defn(CheckedDefn0, CheckedDefn, - !Info, !Specs) :- +module_qualify_mode_ctor_checked_defn(CheckedDefn0, CheckedDefn, !Info) :- CheckedDefn0 = checked_defn_mode(StdModeDefn0, SrcDefns0), StdModeDefn0 = std_mode_defn(Status, MaybeAbstractDefn0), % Abstract mode definitions don't need qualifying NOW, but will % in the future when we add a new mode_for_type_constructor field. InInt = std_mode_status_section(Status), module_qualify_item_mode_defn(qualify_mode_defn, InInt, - MaybeAbstractDefn0, MaybeAbstractDefn, !Info, !Specs), + MaybeAbstractDefn0, MaybeAbstractDefn, !Info), StdModeDefn = std_mode_defn(Status, MaybeAbstractDefn), SrcDefns0 = src_defns_mode(MaybeIntDefn0, MaybeImpDefn0), QualifyPred = module_qualify_item_mode_defn(qualify_mode_defn), maybe_qualify_defn(QualifyPred, mq_used_in_interface, - MaybeIntDefn0, MaybeIntDefn, !Info, !Specs), + MaybeIntDefn0, MaybeIntDefn, !Info), maybe_qualify_defn(QualifyPred, mq_not_used_in_interface, - MaybeImpDefn0, MaybeImpDefn, !Info, !Specs), + MaybeImpDefn0, MaybeImpDefn, !Info), SrcDefns = src_defns_mode(MaybeIntDefn, MaybeImpDefn), CheckedDefn = checked_defn_mode(StdModeDefn, SrcDefns). :- pred maybe_qualify_defn( - pred(mq_in_interface, T, T, mq_info, mq_info, - list(error_spec), list(error_spec)) - :: in(pred(in, in, out, in, out, in, out) is det), - mq_in_interface::in, - maybe(T)::in, maybe(T)::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + pred(mq_in_interface, T, T, mq_info, mq_info) + :: in(pred(in, in, out, in, out) is det), + mq_in_interface::in, maybe(T)::in, maybe(T)::out, + mq_info::in, mq_info::out) is det. -maybe_qualify_defn(QualifyPred, InInt, MaybeDefn0, MaybeDefn, !Info, !Specs) :- +maybe_qualify_defn(QualifyPred, InInt, MaybeDefn0, MaybeDefn, !Info) :- ( MaybeDefn0 = no, MaybeDefn = no ; MaybeDefn0 = yes(Defn0), - QualifyPred(InInt, Defn0, Defn, !Info, !Specs), + QualifyPred(InInt, Defn0, Defn, !Info), MaybeDefn = yes(Defn) ). @@ -613,46 +610,42 @@ std_mode_status_section(std_mode_all_private) = mq_not_used_in_interface. %---------------------------------------------------------------------------% :- pred module_qualify_item_type_defn( - pred(mq_in_interface, prog_context, type_ctor, T, T, - mq_info, mq_info, list(error_spec), list(error_spec)) - :: in(pred(in, in, in, in, out, in, out, in, out) is det), + pred(mq_in_interface, prog_context, type_ctor, T, T, mq_info, mq_info) + :: in(pred(in, in, in, in, out, in, out) is det), mq_in_interface::in, item_type_defn_info_general(T)::in, item_type_defn_info_general(T)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. module_qualify_item_type_defn(QualDefn, InInt, ItemTypeDefn0, ItemTypeDefn, - !Info, !Specs) :- + !Info) :- ItemTypeDefn0 = item_type_defn_info(SymName, Params, TypeDefn0, TVarSet, Context, SeqNum), list.length(Params, Arity), TypeCtor = type_ctor(SymName, Arity), - QualDefn(InInt, Context, TypeCtor, TypeDefn0, TypeDefn, !Info, !Specs), + QualDefn(InInt, Context, TypeCtor, TypeDefn0, TypeDefn, !Info), ItemTypeDefn = item_type_defn_info(SymName, Params, TypeDefn, TVarSet, Context, SeqNum). :- pred module_qualify_item_inst_defn( - pred(mq_in_interface, prog_context, inst_ctor, T, T, - mq_info, mq_info, list(error_spec), list(error_spec)) - :: in(pred(in, in, in, in, out, in, out, in, out) is det), + pred(mq_in_interface, prog_context, inst_ctor, T, T, mq_info, mq_info) + :: in(pred(in, in, in, in, out, in, out) is det), mq_in_interface::in, item_inst_defn_info_general(T)::in, item_inst_defn_info_general(T)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. module_qualify_item_inst_defn(QualDefn, InInt, ItemInstDefn0, ItemInstDefn, - !Info, !Specs) :- + !Info) :- ItemInstDefn0 = item_inst_defn_info(SymName, Params, MaybeForTypeCtor0, MaybeAbstractInstDefn0, InstVarSet, Context, SeqNum), list.length(Params, Arity), InstCtor = inst_ctor(SymName, Arity), ErrorContext = mqec_inst_defn(Context, InstCtor), QualDefn(InInt, Context, InstCtor, - MaybeAbstractInstDefn0, MaybeAbstractInstDefn, !Info, !Specs), + MaybeAbstractInstDefn0, MaybeAbstractInstDefn, !Info), ( MaybeForTypeCtor0 = yes(ForTypeCtor0), qualify_type_ctor(InInt, ErrorContext, ForTypeCtor0, ForTypeCtor, - !Info, !Specs), + !Info), MaybeForTypeCtor = yes(ForTypeCtor) ; MaybeForTypeCtor0 = no, @@ -662,32 +655,28 @@ module_qualify_item_inst_defn(QualDefn, InInt, ItemInstDefn0, ItemInstDefn, MaybeAbstractInstDefn, InstVarSet, Context, SeqNum). :- pred module_qualify_item_mode_defn( - pred(mq_in_interface, prog_context, mode_ctor, T, T, - mq_info, mq_info, list(error_spec), list(error_spec)) - :: in(pred(in, in, in, in, out, in, out, in, out) is det), + pred(mq_in_interface, prog_context, mode_ctor, T, T, mq_info, mq_info) + :: in(pred(in, in, in, in, out, in, out) is det), mq_in_interface::in, item_mode_defn_info_general(T)::in, item_mode_defn_info_general(T)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. module_qualify_item_mode_defn(QualDefn, InInt, ItemModeDefn0, ItemModeDefn, - !Info, !Specs) :- + !Info) :- ItemModeDefn0 = item_mode_defn_info(SymName, Params, MaybeAbstractModeDefn0, InstVarSet, Context, SeqNum), list.length(Params, Arity), ModeCtor = mode_ctor(SymName, Arity), QualDefn(InInt, Context, ModeCtor, - MaybeAbstractModeDefn0, MaybeAbstractModeDefn, !Info, !Specs), + MaybeAbstractModeDefn0, MaybeAbstractModeDefn, !Info), ItemModeDefn = item_mode_defn_info(SymName, Params, MaybeAbstractModeDefn, InstVarSet, Context, SeqNum). :- pred module_qualify_item_typeclass(mq_in_interface::in, item_typeclass_info::in, item_typeclass_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_item_typeclass(InInt, ItemTypeClass0, ItemTypeClass, - !Info, !Specs) :- +module_qualify_item_typeclass(InInt, ItemTypeClass0, ItemTypeClass, !Info) :- % The definition of this predicate differs from the definition % of module_qualify_item_abstract_typeclass only in that it updates % Interface. @@ -697,14 +686,14 @@ module_qualify_item_typeclass(InInt, ItemTypeClass0, ItemTypeClass, ClassId = class_id(Name, Arity), ConstraintErrorContext = mqcec_class_defn(Context, ClassId), qualify_prog_constraint_list(InInt, ConstraintErrorContext, - Constraints0, Constraints, !Info, !Specs), + Constraints0, Constraints, !Info), ( Interface0 = class_interface_abstract, Interface = class_interface_abstract ; Interface0 = class_interface_concrete(Methods0), qualify_class_decls(InInt, ClassId, Methods0, Methods, - !Info, !Specs), + !Info), Interface = class_interface_concrete(Methods) ), ItemTypeClass = item_typeclass_info(Name, Vars, Constraints, FunDeps, @@ -712,11 +701,10 @@ module_qualify_item_typeclass(InInt, ItemTypeClass0, ItemTypeClass, :- pred module_qualify_item_abstract_typeclass(mq_in_interface::in, item_abstract_typeclass_info::in, item_abstract_typeclass_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. module_qualify_item_abstract_typeclass(InInt, ItemTypeClass0, ItemTypeClass, - !Info, !Specs) :- + !Info) :- % The definition of this predicate differs from the definition % of module_qualify_item_typeclass only in that it does not update % Interface. @@ -726,20 +714,18 @@ module_qualify_item_abstract_typeclass(InInt, ItemTypeClass0, ItemTypeClass, ClassId = class_id(Name, Arity), ConstraintErrorContext = mqcec_class_defn(Context, ClassId), qualify_prog_constraint_list(InInt, ConstraintErrorContext, - Constraints0, Constraints, !Info, !Specs), + Constraints0, Constraints, !Info), ItemTypeClass = item_typeclass_info(Name, Vars, Constraints, FunDeps, Interface0, VarSet, Context, SeqNum). :- pred module_qualify_item_instance(mq_in_interface::in, item_instance_info::in, item_instance_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_item_instance(InInt, ItemInstance0, ItemInstance, - !Info, !Specs) :- +module_qualify_item_instance(InInt, ItemInstance0, ItemInstance, !Info) :- % The definition of this predicate differs from the definition % of module_qualify_item_abstract_instance only in that it updates Body. - ItemInstance0 = item_instance_info(Name0, Types0, OriginalTypes0, + ItemInstance0 = item_instance_info(Name0, Types0, OrigTypes0, Constraints0, Body0, VarSet, ModName, Context, SeqNum), list.length(Types0, Arity), ErrorContext = mqec_instance(Context, class_id(Name0, Arity)), @@ -751,12 +737,11 @@ module_qualify_item_instance(InInt, ItemInstance0, ItemInstance, ), % We don't qualify the implementation yet, since that requires % us to resolve overloading. - ConstraintErrorContext = mqcec_instance_defn(Context, Name0, - OriginalTypes0), + ConstraintErrorContext = mqcec_instance_defn(Context, Name0, OrigTypes0), qualify_prog_constraint_list(InInt, ConstraintErrorContext, - Constraints0, Constraints, !Info, !Specs), + Constraints0, Constraints, !Info), Id0 = mq_id(Name0, Arity), - qualify_class_name(InInt, ErrorContext, Id0, Name, !Info, !Specs), + qualify_class_name(InInt, ErrorContext, Id0, Name, !Info), % XXX We don't want to keep the errors from the expansion of both % forms of the instance types, since printing two error messages about % one instance definition that make apparently contradictory @@ -764,23 +749,22 @@ module_qualify_item_instance(InInt, ItemInstance0, ItemInstance, % or not would be confusing. However, I (zs) cannot think of any % compelling reason right now for preferring the error messages % from one version of the types over the other. - qualify_type_list(InInt, ErrorContext, Types0, Types, !Info, !Specs), - qualify_type_list(InInt, ErrorContext, OriginalTypes0, OriginalTypes, - !Info, !.Specs, _), + qualify_type_list(InInt, ErrorContext, Types0, Types, !Info), + % WAS_IGNORED We used to ignore error_specs from OrigTypes. + qualify_type_list(InInt, ErrorContext, OrigTypes0, OrigTypes, !Info), qualify_instance_body(Name, Body0, Body), - ItemInstance = item_instance_info(Name, Types, OriginalTypes, + ItemInstance = item_instance_info(Name, Types, OrigTypes, Constraints, Body, VarSet, ModName, Context, SeqNum). :- pred module_qualify_item_abstract_instance(mq_in_interface::in, item_abstract_instance_info::in, item_abstract_instance_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. module_qualify_item_abstract_instance(InInt, ItemInstance0, ItemInstance, - !Info, !Specs) :- + !Info) :- % The definition of this predicate differs from the definition % of module_qualify_item_instance only in that it does not update Body. - ItemInstance0 = item_instance_info(Name0, Types0, OriginalTypes0, + ItemInstance0 = item_instance_info(Name0, Types0, OrigTypes0, Constraints0, Body, VarSet, ModName, Context, SeqNum), list.length(Types0, Arity), ErrorContext = mqec_instance(Context, class_id(Name0, Arity)), @@ -792,12 +776,11 @@ module_qualify_item_abstract_instance(InInt, ItemInstance0, ItemInstance, ), % We don't qualify the implementation yet, since that requires % us to resolve overloading. - ConstraintErrorContext = mqcec_instance_defn(Context, Name0, - OriginalTypes0), + ConstraintErrorContext = mqcec_instance_defn(Context, Name0, OrigTypes0), qualify_prog_constraint_list(InInt, ConstraintErrorContext, - Constraints0, Constraints, !Info, !Specs), + Constraints0, Constraints, !Info), Id0 = mq_id(Name0, Arity), - qualify_class_name(InInt, ErrorContext, Id0, Name, !Info, !Specs), + qualify_class_name(InInt, ErrorContext, Id0, Name, !Info), % XXX We don't want to keep the errors from the expansion of both % forms of the instance types, since printing two error messages about % one instance definition that make apparently contradictory @@ -805,19 +788,17 @@ module_qualify_item_abstract_instance(InInt, ItemInstance0, ItemInstance, % or not would be confusing. However, I (zs) cannot think of any % compelling reason right now for preferring the error messages % from one version of the types over the other. - qualify_type_list(InInt, ErrorContext, Types0, Types, !Info, !Specs), - qualify_type_list(InInt, ErrorContext, OriginalTypes0, OriginalTypes, - !Info, !.Specs, _), - ItemInstance = item_instance_info(Name, Types, OriginalTypes, + qualify_type_list(InInt, ErrorContext, Types0, Types, !Info), + % WAS_IGNORED We used to ignore error_specs from OrigTypes. + qualify_type_list(InInt, ErrorContext, OrigTypes0, OrigTypes, !Info), + ItemInstance = item_instance_info(Name, Types, OrigTypes, Constraints, Body, VarSet, ModName, Context, SeqNum). :- pred module_qualify_item_pred_decl(mq_in_interface::in, item_pred_decl_info::in, item_pred_decl_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_item_pred_decl(InInt, ItemPredDecl0, ItemPredDecl, - !Info, !Specs) :- +module_qualify_item_pred_decl(InInt, ItemPredDecl0, ItemPredDecl, !Info) :- ItemPredDecl0 = item_pred_decl_info(SymName, PredOrFunc, TypesAndMaybeModes0, MaybeWithType0, MaybeWithInst0, MaybeDetism, Origin, TypeVarSet, InstVarSet, ExistQVars, Purity, @@ -828,15 +809,15 @@ module_qualify_item_pred_decl(InInt, ItemPredDecl0, ItemPredDecl, ErrorContext = mqec_pred_or_func(Context, PredOrFunc, mq_id(SymName, PredFormArityInt)), qualify_types_and_maybe_modes(InInt, ErrorContext, - TypesAndMaybeModes0, TypesAndMaybeModes, !Info, !Specs), + TypesAndMaybeModes0, TypesAndMaybeModes, !Info), ConstraintErrorContext = mqcec_pred_decl(Context, PFSymNameArity), qualify_prog_constraints(InInt, ConstraintErrorContext, - Constraints0, Constraints, !Info, !Specs), + Constraints0, Constraints, !Info), ( MaybeWithType0 = yes(WithType0), % XXX We could pass a more specific error context. qualify_type(InInt, ErrorContext, WithType0, WithType, - !Info, !Specs), + !Info), MaybeWithType = yes(WithType) ; MaybeWithType0 = no, @@ -845,7 +826,7 @@ module_qualify_item_pred_decl(InInt, ItemPredDecl0, ItemPredDecl, ( MaybeWithInst0 = yes(WithInst0), % XXX We could pass a more specific error context. - qualify_inst(InInt, ErrorContext, WithInst0, WithInst, !Info, !Specs), + qualify_inst(InInt, ErrorContext, WithInst0, WithInst, !Info), MaybeWithInst = yes(WithInst) ; MaybeWithInst0 = no, @@ -858,21 +839,19 @@ module_qualify_item_pred_decl(InInt, ItemPredDecl0, ItemPredDecl, :- pred module_qualify_item_mode_decl(mq_in_interface::in, item_mode_decl_info::in, item_mode_decl_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_item_mode_decl(InInt, ItemModeDecl0, ItemModeDecl, - !Info, !Specs) :- +module_qualify_item_mode_decl(InInt, ItemModeDecl0, ItemModeDecl, !Info) :- ItemModeDecl0 = item_mode_decl_info(SymName, PredOrFunc, Modes0, MaybeWithInst0, MaybeDetism, InstVarSet, Context, SeqNum), list.length(Modes0, Arity), ErrorContext = mqec_pred_or_func_mode(Context, PredOrFunc, mq_id(SymName, Arity)), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info, !Specs), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info), ( MaybeWithInst0 = yes(WithInst0), % XXX We could pass a more specific error context. - qualify_inst(InInt, ErrorContext, WithInst0, WithInst, !Info, !Specs), + qualify_inst(InInt, ErrorContext, WithInst0, WithInst, !Info), MaybeWithInst = yes(WithInst) ; MaybeWithInst0 = no, @@ -883,49 +862,45 @@ module_qualify_item_mode_decl(InInt, ItemModeDecl0, ItemModeDecl, :- pred module_qualify_item_foreign_proc(mq_in_interface::in, item_foreign_proc_info::in, item_foreign_proc_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_item_foreign_proc(InInt, FPInfo0, FPInfo, !Info, !Specs) :- +module_qualify_item_foreign_proc(InInt, FPInfo0, FPInfo, !Info) :- FPInfo0 = item_foreign_proc_info(Attrs0, Name, PredOrFunc, Vars0, Varset, InstVarset, Impl, Context, SeqNum), ErrorContext = mqec_foreign_proc(Context), - qualify_pragma_vars(InInt, ErrorContext, Vars0, Vars, !Info, !Specs), + qualify_pragma_vars(InInt, ErrorContext, Vars0, Vars, !Info), UserSharing0 = get_user_annotated_sharing(Attrs0), qualify_user_sharing(InInt, ErrorContext, UserSharing0, UserSharing, - !Info, !Specs), + !Info), set_user_annotated_sharing(UserSharing, Attrs0, Attrs), FPInfo = item_foreign_proc_info(Attrs, Name, PredOrFunc, Vars, Varset, InstVarset, Impl, Context, SeqNum). :- pred module_qualify_item_foreign_enum(mq_in_interface::in, item_foreign_enum_info::in, item_foreign_enum_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. module_qualify_item_foreign_enum(InInt, ItemForeignEnum0, ItemForeignEnum, - !Info, !Specs) :- + !Info) :- ItemForeignEnum0 = item_foreign_enum_info(Lang, TypeCtor0, Values, Context, SeqNum), ErrorContext = mqec_foreign_enum(Context), - qualify_type_ctor(InInt, ErrorContext, TypeCtor0, TypeCtor, !Info, !Specs), + qualify_type_ctor(InInt, ErrorContext, TypeCtor0, TypeCtor, !Info), ItemForeignEnum = item_foreign_enum_info(Lang, TypeCtor, Values, Context, SeqNum). :- pred module_qualify_item_foreign_export_enum(mq_in_interface::in, item_foreign_export_enum_info::in, item_foreign_export_enum_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_item_foreign_export_enum(InInt, ItemFEE0, ItemFEE, - !Info, !Specs) :- +module_qualify_item_foreign_export_enum(InInt, ItemFEE0, ItemFEE, !Info) :- ItemFEE0 = item_foreign_export_enum_info(Lang, TypeCtor0, Attributes, Overrides, Context, SeqNum), ErrorContext = mqec_foreign_export_enum(Context), - mq_info_get_suppress_found_undef(!.Info, OldSuppressUndef), - mq_info_set_suppress_found_undef(suppress_found_undef, !Info), - qualify_type_ctor(InInt, ErrorContext, TypeCtor0, TypeCtor, !Info, !Specs), - mq_info_set_suppress_found_undef(OldSuppressUndef, !Info), + mq_info_get_is_undef_blocking(!.Info, OldUndefBlocking), + mq_info_set_is_undef_blocking(undef_is_not_blocking, !Info), + qualify_type_ctor(InInt, ErrorContext, TypeCtor0, TypeCtor, !Info), + mq_info_set_is_undef_blocking(OldUndefBlocking, !Info), ItemFEE = item_foreign_export_enum_info(Lang, TypeCtor, Attributes, Overrides, Context, SeqNum). @@ -933,11 +908,10 @@ module_qualify_item_foreign_export_enum(InInt, ItemFEE0, ItemFEE, :- pred module_qualify_item_type_repn(module_name::in, mq_in_interface::in, item_type_repn_info::in, item_type_repn_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. module_qualify_item_type_repn(ModuleName, InInt, - ItemTypeRepnInfo0, ItemTypeRepnInfo, !Info, !Specs) :- + ItemTypeRepnInfo0, ItemTypeRepnInfo, !Info) :- ItemTypeRepnInfo0 = item_type_repn_info(TypeCtorSymName0, ArgTVars, RepInfo0, TVarSet, Context, SeqNum), % We currently put type constructors names into type_repn items @@ -962,7 +936,7 @@ module_qualify_item_type_repn(ModuleName, InInt, list.length(ArgTVars, TypeCtorArity), TypeCtor = type_ctor(TypeCtorSymName, TypeCtorArity), ErrorContext = mqec_type_repn(Context, TypeCtor), - qualify_type(InInt, ErrorContext, EqvType0, EqvType, !Info, !Specs), + qualify_type(InInt, ErrorContext, EqvType0, EqvType, !Info), RepInfo = tcrepn_is_eqv_to(EqvType) ; RepInfo0 = tcrepn_is_subtype_of(SuperTypeCtor0), @@ -970,7 +944,7 @@ module_qualify_item_type_repn(ModuleName, InInt, TypeCtor = type_ctor(TypeCtorSymName, TypeCtorArity), ErrorContext = mqec_type_repn(Context, TypeCtor), qualify_type_ctor(InInt, ErrorContext, SuperTypeCtor0, SuperTypeCtor, - !Info, !Specs), + !Info), RepInfo = tcrepn_is_subtype_of(SuperTypeCtor) ), ItemTypeRepnInfo = item_type_repn_info(TypeCtorSymName, ArgTVars, @@ -986,30 +960,28 @@ module_qualify_item_type_repn(ModuleName, InInt, % :- pred qualify_type_defn(mq_in_interface::in, prog_context::in, type_ctor::in, type_defn::in, type_defn::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_type_defn(InInt, Context, TypeCtor, TypeDefn0, TypeDefn, - !Info, !Specs) :- +qualify_type_defn(InInt, Context, TypeCtor, TypeDefn0, TypeDefn, !Info) :- ( TypeDefn0 = parse_tree_solver_type(DetailsSolver0), qualify_type_defn_solver(InInt, Context, TypeCtor, - DetailsSolver0, DetailsSolver, !Info, !Specs), + DetailsSolver0, DetailsSolver, !Info), TypeDefn = parse_tree_solver_type(DetailsSolver) ; TypeDefn0 = parse_tree_eqv_type(DetailsEqv0), qualify_type_defn_eqv(InInt, Context, TypeCtor, - DetailsEqv0, DetailsEqv, !Info, !Specs), + DetailsEqv0, DetailsEqv, !Info), TypeDefn = parse_tree_eqv_type(DetailsEqv) ; TypeDefn0 = parse_tree_du_type(DetailsDu0), qualify_type_defn_du(InInt, Context, TypeCtor, - DetailsDu0, DetailsDu, !Info, !Specs), + DetailsDu0, DetailsDu, !Info), TypeDefn = parse_tree_du_type(DetailsDu) ; TypeDefn0 = parse_tree_sub_type(DetailsSub0), qualify_type_defn_sub(InInt, Context, TypeCtor, - DetailsSub0, DetailsSub, !Info, !Specs), + DetailsSub0, DetailsSub, !Info), TypeDefn = parse_tree_sub_type(DetailsSub) ; ( TypeDefn0 = parse_tree_abstract_type(_) @@ -1020,59 +992,54 @@ qualify_type_defn(InInt, Context, TypeCtor, TypeDefn0, TypeDefn, :- pred qualify_type_defn_solver(mq_in_interface::in, prog_context::in, type_ctor::in, type_details_solver::in, type_details_solver::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_type_defn_solver(InInt, Context, TypeCtor, - DetailsSolver0, DetailsSolver, !Info, !Specs) :- + DetailsSolver0, DetailsSolver, !Info) :- DetailsSolver0 = type_details_solver(SolverTypeDetails0, MaybeUserEqComp), SolverTypeDetails0 = solver_type_details(RepnType0, GroundInst0, AnyInst0, Mutables0), ErrorContext = mqec_type_defn(Context, TypeCtor), - qualify_type(InInt, ErrorContext, RepnType0, RepnType, !Info, !Specs), - qualify_inst(InInt, ErrorContext, GroundInst0, GroundInst, !Info, !Specs), - qualify_inst(InInt, ErrorContext, AnyInst0, AnyInst, !Info, !Specs), - qualify_constraint_stores(InInt, Mutables0, Mutables, !Info, !Specs), + qualify_type(InInt, ErrorContext, RepnType0, RepnType, !Info), + qualify_inst(InInt, ErrorContext, GroundInst0, GroundInst, !Info), + qualify_inst(InInt, ErrorContext, AnyInst0, AnyInst, !Info), + qualify_constraint_stores(InInt, Mutables0, Mutables, !Info), SolverTypeDetails = solver_type_details(RepnType, GroundInst, AnyInst, Mutables), DetailsSolver = type_details_solver(SolverTypeDetails, MaybeUserEqComp). :- pred qualify_constraint_stores(mq_in_interface::in, list(item_mutable_info)::in, list(item_mutable_info)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_constraint_stores(_InInt, [], [], !Info, !Specs). +qualify_constraint_stores(_InInt, [], [], !Info). qualify_constraint_stores(InInt, - [Mutable0 | Mutables0], [Mutable | Mutables], !Info, !Specs) :- - module_qualify_item_mutable(InInt, Mutable0, Mutable, !Info, !Specs), - qualify_constraint_stores(InInt, Mutables0, Mutables, !Info, !Specs). + [Mutable0 | Mutables0], [Mutable | Mutables], !Info) :- + module_qualify_item_mutable(InInt, Mutable0, Mutable, !Info), + qualify_constraint_stores(InInt, Mutables0, Mutables, !Info). :- pred qualify_type_defn_eqv(mq_in_interface::in, prog_context::in, type_ctor::in, type_details_eqv::in, type_details_eqv::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_type_defn_eqv(InInt, Context, TypeCtor, DetailsEqv0, DetailsEqv, - !Info, !Specs) :- + !Info) :- DetailsEqv0 = type_details_eqv(Type0), ErrorContext = mqec_type_defn(Context, TypeCtor), - qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs), + qualify_type(InInt, ErrorContext, Type0, Type, !Info), DetailsEqv = type_details_eqv(Type). :- pred qualify_type_defn_du(mq_in_interface::in, prog_context::in, type_ctor::in, type_details_du::in, type_details_du::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_type_defn_du(InInt, _Context, TypeCtor, DetailsDu0, DetailsDu, - !Info, !Specs) :- + !Info) :- DetailsDu0 = type_details_du(OoMCtors0, MaybeUserEqComp0, MaybeDirectArgCtors0), OoMCtors0 = one_or_more(HeadCtor0, TailCtors0), - qualify_constructor(InInt, TypeCtor, HeadCtor0, HeadCtor, !Info, !Specs), - qualify_constructors(InInt, TypeCtor, TailCtors0, TailCtors, - !Info, !Specs), + qualify_constructor(InInt, TypeCtor, HeadCtor0, HeadCtor, !Info), + qualify_constructors(InInt, TypeCtor, TailCtors0, TailCtors, !Info), OoMCtors = one_or_more(HeadCtor, TailCtors), % User-defined equality pred names will be converted into predicate % calls and then module-qualified after type analysis (during mode @@ -1085,44 +1052,38 @@ qualify_type_defn_du(InInt, _Context, TypeCtor, DetailsDu0, DetailsDu, :- pred qualify_type_defn_sub(mq_in_interface::in, prog_context::in, type_ctor::in, type_details_sub::in, type_details_sub::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_type_defn_sub(InInt, Context, TypeCtor, DetailsSub0, DetailsSub, - !Info, !Specs) :- + !Info) :- DetailsSub0 = type_details_sub(SuperType0, OoMCtors0), ErrorContext = mqec_type_defn(Context, TypeCtor), % Note that this will not prevent a subtype defined in an interface % section from referring to an abstract type as its supertype. % That will be checked while checking other subtype conditions. qualify_type(InInt, ErrorContext, SuperType0, SuperType, - !Info, !Specs), + !Info), OoMCtors0 = one_or_more(HeadCtor0, TailCtors0), - qualify_constructor(InInt, TypeCtor, HeadCtor0, HeadCtor, !Info, !Specs), - qualify_constructors(InInt, TypeCtor, TailCtors0, TailCtors, - !Info, !Specs), + qualify_constructor(InInt, TypeCtor, HeadCtor0, HeadCtor, !Info), + qualify_constructors(InInt, TypeCtor, TailCtors0, TailCtors, !Info), OoMCtors = one_or_more(HeadCtor, TailCtors), DetailsSub = type_details_sub(SuperType, OoMCtors). :- pred qualify_constructors(mq_in_interface::in, type_ctor::in, list(constructor)::in, list(constructor)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_constructors(_InInt, _ContainingTypeCtor, [], [], !Info, !Specs). +qualify_constructors(_InInt, _ContainingTypeCtor, [], [], !Info). qualify_constructors(InInt, ContainingTypeCtor, - [Ctor0 | Ctors0], [Ctor | Ctors], !Info, !Specs) :- - qualify_constructor(InInt, ContainingTypeCtor, Ctor0, Ctor, - !Info, !Specs), - qualify_constructors(InInt, ContainingTypeCtor, Ctors0, Ctors, - !Info, !Specs). + [Ctor0 | Ctors0], [Ctor | Ctors], !Info) :- + qualify_constructor(InInt, ContainingTypeCtor, Ctor0, Ctor, !Info), + qualify_constructors(InInt, ContainingTypeCtor, Ctors0, Ctors, !Info). :- pred qualify_constructor(mq_in_interface::in, type_ctor::in, constructor::in, constructor::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_constructor(InInt, ContainingTypeCtor, Ctor0, Ctor, !Info, !Specs) :- +qualify_constructor(InInt, ContainingTypeCtor, Ctor0, Ctor, !Info) :- Ctor0 = ctor(Ordinal, MaybeExistConstraints0, FunctionSymbolSymName, Args0, Arity, Context), FunctionSymbolName = unqualify_name(FunctionSymbolSymName), @@ -1136,65 +1097,62 @@ qualify_constructor(InInt, ContainingTypeCtor, Ctor0, Ctor, !Info, !Specs) :- ConstraintErrorContext = mqcec_type_defn_constructor(Context, ContainingTypeCtor, FunctionSymbolName, Arity), qualify_prog_constraint_list(InInt, ConstraintErrorContext, - Constraints0, Constraints, !Info, !Specs), + Constraints0, Constraints, !Info), ExistConstraints = cons_exist_constraints(ExistQVars, Constraints, UnconstrainedExistQVars, ConstrainedExistQVars), MaybeExistConstraints = exist_constraints(ExistConstraints) ), qualify_constructor_args(InInt, ContainingTypeCtor, FunctionSymbolName, - 0, Args0, Args, !Info, !Specs), + 0, Args0, Args, !Info), Ctor = ctor(Ordinal, MaybeExistConstraints, FunctionSymbolSymName, Args, Arity, Context). :- pred qualify_constructor_args(mq_in_interface::in, type_ctor::in, string::in, int::in, list(constructor_arg)::in, list(constructor_arg)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_constructor_args(_InInt, _, _, _, [], [], !Info, !Specs). +qualify_constructor_args(_InInt, _, _, _, [], [], !Info). qualify_constructor_args(InInt, ContainingTypeCtor, FunctionSymbol, - LastArgNum, [Arg0 | Args0], [Arg | Args], !Info, !Specs) :- + LastArgNum, [Arg0 | Args0], [Arg | Args], !Info) :- CurArgNum = LastArgNum + 1, qualify_constructor_arg(InInt, ContainingTypeCtor, FunctionSymbol, - CurArgNum, Arg0, Arg, !Info, !Specs), + CurArgNum, Arg0, Arg, !Info), qualify_constructor_args(InInt, ContainingTypeCtor, FunctionSymbol, - CurArgNum, Args0, Args, !Info, !Specs). + CurArgNum, Args0, Args, !Info). :- pred qualify_constructor_arg(mq_in_interface::in, type_ctor::in, string::in, int::in, - constructor_arg::in, constructor_arg::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + constructor_arg::in, constructor_arg::out, + mq_info::in, mq_info::out) is det. qualify_constructor_arg(InInt, ContainingTypeCtor, FunctionSymbol, ArgNum, - Arg0, Arg, !Info, !Specs) :- + Arg0, Arg, !Info) :- Arg0 = ctor_arg(MaybeFieldName, Type0, Context), ErrorContext = mqec_constructor_arg(Context, ContainingTypeCtor, FunctionSymbol, ArgNum, MaybeFieldName), - qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs), + qualify_type(InInt, ErrorContext, Type0, Type, !Info), Arg = ctor_arg(MaybeFieldName, Type, Context). :- pred qualify_type_list(mq_in_interface::in, mq_error_context::in, - list(mer_type)::in, list(mer_type)::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + list(mer_type)::in, list(mer_type)::out, mq_info::in, mq_info::out) is det. -qualify_type_list(_InInt, _ErrorContext, [], [], !Info, !Specs). +qualify_type_list(_InInt, _ErrorContext, [], [], !Info). qualify_type_list(InInt, ErrorContext, [Type0 | Types0], [Type | Types], - !Info, !Specs) :- - qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs), - qualify_type_list(InInt, ErrorContext, Types0, Types, !Info, !Specs). + !Info) :- + qualify_type(InInt, ErrorContext, Type0, Type, !Info), + qualify_type_list(InInt, ErrorContext, Types0, Types, !Info). -qualify_type_qualification(InInt, Context, Type0, Type, !Info, !Specs) :- +qualify_type_qualification(InInt, Context, Type0, Type, !Info) :- ErrorContext = mqec_type_qual(Context), - qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs). + qualify_type(InInt, ErrorContext, Type0, Type, !Info). % Qualify a type and its argument types. % :- pred qualify_type(mq_in_interface::in, mq_error_context::in, - mer_type::in, mer_type::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mer_type::in, mer_type::out, mq_info::in, mq_info::out) is det. -qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs) :- +qualify_type(InInt, ErrorContext, Type0, Type, !Info) :- ( Type0 = type_variable(_Var, _Kind), Type = Type0 @@ -1204,9 +1162,9 @@ qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs) :- TypeCtorId0 = mq_id(SymName0, Arity), mq_info_get_types(!.Info, Types), find_unique_match(InInt, ErrorContext, Types, qual_id_type, - TypeCtorId0, SymName, !Info, !Specs), + TypeCtorId0, SymName, !Info), % XXX We could pass a more specific error context. - qualify_type_list(InInt, ErrorContext, Args0, Args, !Info, !Specs), + qualify_type_list(InInt, ErrorContext, Args0, Args, !Info), Type = defined_type(SymName, Args, Kind) ; Type0 = builtin_type(BuiltinType), @@ -1234,34 +1192,32 @@ qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs) :- ; Type0 = higher_order_type(PorF, Args0, HOInstInfo0, Purity), % XXX We could pass a more specific error context. - qualify_type_list(InInt, ErrorContext, Args0, Args, !Info, !Specs), + qualify_type_list(InInt, ErrorContext, Args0, Args, !Info), % XXX We could pass a more specific error context. qualify_ho_inst_info(InInt, ErrorContext, HOInstInfo0, HOInstInfo, - !Info, !Specs), + !Info), Type = higher_order_type(PorF, Args, HOInstInfo, Purity) ; Type0 = tuple_type(Args0, Kind), % XXX We could pass a more specific error context. - qualify_type_list(InInt, ErrorContext, Args0, Args, !Info, !Specs), + qualify_type_list(InInt, ErrorContext, Args0, Args, !Info), Type = tuple_type(Args, Kind) ; Type0 = apply_n_type(Var, Args0, Kind), % XXX We could pass a more specific error context. - qualify_type_list(InInt, ErrorContext, Args0, Args, !Info, !Specs), + qualify_type_list(InInt, ErrorContext, Args0, Args, !Info), Type = apply_n_type(Var, Args, Kind) ; Type0 = kinded_type(SubType0, Kind), % XXX We could pass a more specific error context. - qualify_type(InInt, ErrorContext, SubType0, SubType, !Info, !Specs), + qualify_type(InInt, ErrorContext, SubType0, SubType, !Info), Type = kinded_type(SubType, Kind) ). :- pred qualify_type_ctor(mq_in_interface::in, mq_error_context::in, - type_ctor::in, type_ctor::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + type_ctor::in, type_ctor::out, mq_info::in, mq_info::out) is det. -qualify_type_ctor(InInt, ErrorContext, TypeCtor0, TypeCtor, - !Info, !Specs) :- +qualify_type_ctor(InInt, ErrorContext, TypeCtor0, TypeCtor, !Info) :- TypeCtor0 = type_ctor(SymName0, Arity), ( if is_builtin_atomic_type(TypeCtor0) then TypeCtor = TypeCtor0 @@ -1270,7 +1226,7 @@ qualify_type_ctor(InInt, ErrorContext, TypeCtor0, TypeCtor, mq_info_get_types(!.Info, Types), % XXX We could pass a more specific error context. find_unique_match(InInt, ErrorContext, Types, qual_id_type, - TypeCtorId0, SymName, !Info, !Specs), + TypeCtorId0, SymName, !Info), TypeCtor = type_ctor(SymName, Arity) ). @@ -1293,12 +1249,10 @@ is_builtin_atomic_type(TypeCtor) :- % :- pred qualify_inst_defn(mq_in_interface::in, prog_context::in, inst_ctor::in, maybe_abstract_inst_defn::in, maybe_abstract_inst_defn::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_inst_defn(InInt, Context, InstCtor, - MaybeAbstractInstDefn0, MaybeAbstractInstDefn, - !Info, !Specs) :- + MaybeAbstractInstDefn0, MaybeAbstractInstDefn, !Info) :- ( MaybeAbstractInstDefn0 = abstract_inst_defn, MaybeAbstractInstDefn = abstract_inst_defn @@ -1306,7 +1260,7 @@ qualify_inst_defn(InInt, Context, InstCtor, MaybeAbstractInstDefn0 = nonabstract_inst_defn(InstDefn0), ErrorContext = mqec_inst_defn(Context, InstCtor), InstDefn0 = eqv_inst(Inst0), - qualify_inst(InInt, ErrorContext, Inst0, Inst, !Info, !Specs), + qualify_inst(InInt, ErrorContext, Inst0, Inst, !Info), InstDefn = eqv_inst(Inst), MaybeAbstractInstDefn = nonabstract_inst_defn(InstDefn) ). @@ -1314,14 +1268,13 @@ qualify_inst_defn(InInt, Context, InstCtor, % Qualify a single inst. % :- pred qualify_inst(mq_in_interface::in, mq_error_context::in, - mer_inst::in, mer_inst::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mer_inst::in, mer_inst::out, mq_info::in, mq_info::out) is det. -qualify_inst(InInt, ErrorContext, Inst0, Inst, !Info, !Specs) :- +qualify_inst(InInt, ErrorContext, Inst0, Inst, !Info) :- ( Inst0 = any(Uniq, HOInstInfo0), qualify_ho_inst_info(InInt, ErrorContext, HOInstInfo0, HOInstInfo, - !Info, !Specs), + !Info), Inst = any(Uniq, HOInstInfo) ; ( Inst0 = free @@ -1341,47 +1294,43 @@ qualify_inst(InInt, ErrorContext, Inst0, Inst, !Info, !Specs) :- ), % XXX We could pass a more specific error context. qualify_bound_functors(InInt, ErrorContext, - BoundFunctors0, BoundFunctors, !Info, !Specs), + BoundFunctors0, BoundFunctors, !Info), Inst = bound(Uniq, InstResults0, BoundFunctors) ; Inst0 = ground(Uniq, HOInstInfo0), % XXX We could pass a more specific error context. qualify_ho_inst_info(InInt, ErrorContext, HOInstInfo0, HOInstInfo, - !Info, !Specs), + !Info), Inst = ground(Uniq, HOInstInfo) ; Inst0 = constrained_inst_vars(Vars, SubInst0), % XXX We could pass a more specific error context. - qualify_inst(InInt, ErrorContext, SubInst0, SubInst, !Info, !Specs), + qualify_inst(InInt, ErrorContext, SubInst0, SubInst, !Info), Inst = constrained_inst_vars(Vars, SubInst) ; Inst0 = defined_inst(InstName0), % XXX We could pass a more specific error context. - qualify_inst_name(InInt, ErrorContext, InstName0, InstName, - !Info, !Specs), + qualify_inst_name(InInt, ErrorContext, InstName0, InstName, !Info), Inst = defined_inst(InstName) ). :- pred qualify_inst_list(mq_in_interface::in, mq_error_context::in, - list(mer_inst)::in, list(mer_inst)::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + list(mer_inst)::in, list(mer_inst)::out, mq_info::in, mq_info::out) is det. -qualify_inst_list(_InInt, _ErrorContext, [], [], !Info, !Specs). +qualify_inst_list(_InInt, _ErrorContext, [], [], !Info). qualify_inst_list(InInt, ErrorContext, [Inst0 | Insts0], [Inst | Insts], - !Info, !Specs) :- - qualify_inst(InInt, ErrorContext, Inst0, Inst, !Info, !Specs), - qualify_inst_list(InInt, ErrorContext, Insts0, Insts, !Info, !Specs). + !Info) :- + qualify_inst(InInt, ErrorContext, Inst0, Inst, !Info), + qualify_inst_list(InInt, ErrorContext, Insts0, Insts, !Info). :- pred qualify_ho_inst_info(mq_in_interface::in, mq_error_context::in, - ho_inst_info::in, ho_inst_info::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + ho_inst_info::in, ho_inst_info::out, mq_info::in, mq_info::out) is det. -qualify_ho_inst_info(InInt, ErrorContext, HOInstInfo0, HOInstInfo, - !Info, !Specs) :- +qualify_ho_inst_info(InInt, ErrorContext, HOInstInfo0, HOInstInfo, !Info) :- ( HOInstInfo0 = higher_order(pred_inst_info(PredOrFunc, Modes0, MaybeArgRegs, Detism)), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info, !Specs), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info), HOInstInfo = higher_order(pred_inst_info(PredOrFunc, Modes, MaybeArgRegs, Detism)) ; @@ -1393,30 +1342,27 @@ qualify_ho_inst_info(InInt, ErrorContext, HOInstInfo0, HOInstInfo, % the argument insts. % :- pred qualify_inst_name(mq_in_interface::in, mq_error_context::in, - inst_name::in, inst_name::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + inst_name::in, inst_name::out, mq_info::in, mq_info::out) is det. -qualify_inst_name(InInt, ErrorContext, InstName0, InstName, - !Info, !Specs) :- +qualify_inst_name(InInt, ErrorContext, InstName0, InstName, !Info) :- ( InstName0 = user_inst(SymName0, Insts0), - qualify_inst_list(InInt, ErrorContext, Insts0, Insts, - !Info, !Specs), + qualify_inst_list(InInt, ErrorContext, Insts0, Insts, !Info), ( if % Check for a variable inst constructor. SymName0 = unqualified("") then - report_invalid_user_inst(SymName0, Insts, ErrorContext, !Specs), + report_invalid_user_inst(SymName0, Insts, ErrorContext, Spec), InstCtor = inst_ctor(SymName0, list.length(Insts0)), mq_info_get_undef_insts(!.Info, UndefInsts0), - set_tree234.insert(InstCtor, UndefInsts0, UndefInsts), + one_or_more_map.add(InstCtor, Spec, UndefInsts0, UndefInsts), mq_info_set_undef_insts(UndefInsts, !Info), SymName = SymName0 else list.length(Insts0, Arity), mq_info_get_insts(!.Info, InstIdSet), find_unique_match(InInt, ErrorContext, InstIdSet, qual_id_inst, - mq_id(SymName0, Arity), SymName, !Info, !Specs) + mq_id(SymName0, Arity), SymName, !Info) ), InstName = user_inst(SymName, Insts) ; @@ -1434,26 +1380,24 @@ qualify_inst_name(InInt, ErrorContext, InstName0, InstName, :- pred qualify_bound_functors(mq_in_interface::in, mq_error_context::in, list(bound_functor)::in, list(bound_functor)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_bound_functors(_InInt, _ErrorContext, [], [], !Info, !Specs). +qualify_bound_functors(_InInt, _ErrorContext, [], [], !Info). qualify_bound_functors(InInt, ErrorContext, [BoundFunctor0 | BoundFunctors0], [BoundFunctor | BoundFunctors], - !Info, !Specs) :- + !Info) :- qualify_bound_functor(InInt, ErrorContext, BoundFunctor0, BoundFunctor, - !Info, !Specs), + !Info), qualify_bound_functors(InInt, ErrorContext, BoundFunctors0, BoundFunctors, - !Info, !Specs). + !Info). % Qualify an inst of the form bound(functor(...)). % :- pred qualify_bound_functor(mq_in_interface::in, mq_error_context::in, - bound_functor::in, bound_functor::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + bound_functor::in, bound_functor::out, mq_info::in, mq_info::out) is det. qualify_bound_functor(InInt, ErrorContext, BoundFunctor0, BoundFunctor, - !Info, !Specs) :- + !Info) :- BoundFunctor0 = bound_functor(ConsId, Insts0), ( ConsId = du_data_ctor(du_ctor(Name, Arity, _)), @@ -1480,7 +1424,7 @@ qualify_bound_functor(InInt, ErrorContext, BoundFunctor0, BoundFunctor, ; ConsId = deep_profiling_proc_layout(_) ) ), - qualify_inst_list(InInt, ErrorContext, Insts0, Insts, !Info, !Specs), + qualify_inst_list(InInt, ErrorContext, Insts0, Insts, !Info), BoundFunctor = bound_functor(ConsId, Insts). %---------------------------------------------------------------------------% @@ -1492,11 +1436,10 @@ qualify_bound_functor(InInt, ErrorContext, BoundFunctor0, BoundFunctor, % :- pred qualify_mode_defn(mq_in_interface::in, prog_context::in, mode_ctor::in, maybe_abstract_mode_defn::in, maybe_abstract_mode_defn::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_mode_defn(InInt, Context, ModeCtor, - MaybeAbstractModeDefn0, MaybeAbstractModeDefn, !Info, !Specs) :- + MaybeAbstractModeDefn0, MaybeAbstractModeDefn, !Info) :- ( MaybeAbstractModeDefn0 = abstract_mode_defn, MaybeAbstractModeDefn = abstract_mode_defn @@ -1504,46 +1447,44 @@ qualify_mode_defn(InInt, Context, ModeCtor, MaybeAbstractModeDefn0 = nonabstract_mode_defn(ModeDefn0), ErrorContext = mqec_mode_defn(Context, ModeCtor), ModeDefn0 = eqv_mode(Mode0), - qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info, !Specs), + qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info), ModeDefn = eqv_mode(Mode), MaybeAbstractModeDefn = nonabstract_mode_defn(ModeDefn) ). -qualify_clause_mode_list(InInt, Context, Modes0, Modes, !Info, !Specs) :- +qualify_clause_mode_list(InInt, Context, Modes0, Modes, !Info) :- ErrorContext = mqec_clause_mode_annotation(Context), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info, !Specs). + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info). :- pred qualify_mode_list(mq_in_interface::in, mq_error_context::in, - list(mer_mode)::in, list(mer_mode)::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + list(mer_mode)::in, list(mer_mode)::out, mq_info::in, mq_info::out) is det. -qualify_mode_list(_InInt, _ErrorContext, [], [], !Info, !Specs). +qualify_mode_list(_InInt, _ErrorContext, [], [], !Info). qualify_mode_list(InInt, ErrorContext, [Mode0 | Modes0], [Mode | Modes], - !Info, !Specs) :- - qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info, !Specs), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info, !Specs). + !Info) :- + qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info). -qualify_lambda_mode(InInt, Context, Mode0, Mode, !Info, !Specs) :- +qualify_lambda_mode(InInt, Context, Mode0, Mode, !Info) :- ErrorContext = mqec_lambda_expr(Context), - qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info, !Specs). + qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info). :- pred qualify_mode(mq_in_interface::in, mq_error_context::in, - mer_mode::in, mer_mode::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mer_mode::in, mer_mode::out, mq_info::in, mq_info::out) is det. -qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info, !Specs) :- +qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info) :- ( Mode0 = from_to_mode(InstA0, InstB0), - qualify_inst(InInt, ErrorContext, InstA0, InstA, !Info, !Specs), - qualify_inst(InInt, ErrorContext, InstB0, InstB, !Info, !Specs), + qualify_inst(InInt, ErrorContext, InstA0, InstA, !Info), + qualify_inst(InInt, ErrorContext, InstB0, InstB, !Info), Mode = from_to_mode(InstA, InstB) ; Mode0 = user_defined_mode(SymName0, Insts0), - qualify_inst_list(InInt, ErrorContext, Insts0, Insts, !Info, !Specs), + qualify_inst_list(InInt, ErrorContext, Insts0, Insts, !Info), list.length(Insts, Arity), mq_info_get_modes(!.Info, Modes), find_unique_match(InInt, ErrorContext, Modes, qual_id_mode, - mq_id(SymName0, Arity), SymName, !Info, !Specs), + mq_id(SymName0, Arity), SymName, !Info), Mode = user_defined_mode(SymName, Insts) ). @@ -1555,63 +1496,58 @@ qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info, !Specs) :- :- pred qualify_types_and_maybe_modes(mq_in_interface::in, mq_error_context::in, types_and_maybe_modes::in, types_and_maybe_modes::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_types_and_maybe_modes(InInt, ErrorContext, - TypesAndMaybeModes0, TypesAndMaybeModes, !Info, !Specs) :- + TypesAndMaybeModes0, TypesAndMaybeModes, !Info) :- ( TypesAndMaybeModes0 = no_types_arity_zero, TypesAndMaybeModes = no_types_arity_zero ; TypesAndMaybeModes0 = types_only(Types0), - qualify_types(InInt, ErrorContext, Types0, Types, !Info, !Specs), + qualify_types(InInt, ErrorContext, Types0, Types, !Info), TypesAndMaybeModes = types_only(Types) ; TypesAndMaybeModes0 = types_and_modes(TypesAndModes0), qualify_types_and_modes(InInt, ErrorContext, - TypesAndModes0, TypesAndModes, !Info, !Specs), + TypesAndModes0, TypesAndModes, !Info), TypesAndMaybeModes = types_and_modes(TypesAndModes) ). % Qualify a list of types. % :- pred qualify_types(mq_in_interface::in, mq_error_context::in, - list(mer_type)::in, list(mer_type)::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + list(mer_type)::in, list(mer_type)::out, mq_info::in, mq_info::out) is det. -qualify_types(_InInt, _ErrorContext, [], [], !Info, !Specs). -qualify_types(InInt, ErrorContext, [Type0 | Types0], [Type | Types], - !Info, !Specs) :- - qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs), - qualify_types(InInt, ErrorContext, Types0, Types, !Info, !Specs). +qualify_types(_InInt, _ErrorContext, [], [], !Info). +qualify_types(InInt, ErrorContext, [Type0 | Types0], [Type | Types], !Info) :- + qualify_type(InInt, ErrorContext, Type0, Type, !Info), + qualify_types(InInt, ErrorContext, Types0, Types, !Info). % Qualify a list of items of the form Type::Mode, as in a % predicate declaration. % :- pred qualify_types_and_modes(mq_in_interface::in, mq_error_context::in, list(type_and_mode)::in, list(type_and_mode)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_types_and_modes(_InInt, _ErrorContext, [], [], !Info, !Specs). +qualify_types_and_modes(_InInt, _ErrorContext, [], [], !Info). qualify_types_and_modes(InInt, ErrorContext, [TypeAndMode0 | TypesAndModes0], [TypeAndMode | TypesAndModes], - !Info, !Specs) :- + !Info) :- qualify_type_and_mode(InInt, ErrorContext, - TypeAndMode0, TypeAndMode, !Info, !Specs), + TypeAndMode0, TypeAndMode, !Info), qualify_types_and_modes(InInt, ErrorContext, - TypesAndModes0, TypesAndModes, !Info, !Specs). + TypesAndModes0, TypesAndModes, !Info). :- pred qualify_type_and_mode(mq_in_interface::in, mq_error_context::in, - type_and_mode::in, type_and_mode::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + type_and_mode::in, type_and_mode::out, mq_info::in, mq_info::out) is det. qualify_type_and_mode(InInt, ErrorContext, TypeAndMode0, TypeAndMode, - !Info, !Specs) :- + !Info) :- TypeAndMode0 = type_and_mode(Type0, Mode0), - qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs), - qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info, !Specs), + qualify_type(InInt, ErrorContext, Type0, Type, !Info), + qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info), TypeAndMode = type_and_mode(Type, Mode). %---------------------------------------------------------------------------% @@ -1623,17 +1559,16 @@ qualify_type_and_mode(InInt, ErrorContext, TypeAndMode0, TypeAndMode, :- pred qualify_prog_constraints(mq_in_interface::in, mq_constraint_error_context::in, univ_exist_constraints::in, univ_exist_constraints::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_prog_constraints(InInt, ConstraintErrorContext, - Constraints0, Constraints, !Info, !Specs) :- + Constraints0, Constraints, !Info) :- Constraints0 = univ_exist_constraints(UnivCs0, ExistCs0), % XXX We could pass a more specific error context. qualify_prog_constraint_list(InInt, ConstraintErrorContext, - UnivCs0, UnivCs, !Info, !Specs), + UnivCs0, UnivCs, !Info), qualify_prog_constraint_list(InInt, ConstraintErrorContext, - ExistCs0, ExistCs, !Info, !Specs), + ExistCs0, ExistCs, !Info), Constraints = univ_exist_constraints(UnivCs, ExistCs). %---------------------% @@ -1641,34 +1576,32 @@ qualify_prog_constraints(InInt, ConstraintErrorContext, :- pred qualify_prog_constraint_list(mq_in_interface::in, mq_constraint_error_context::in, list(prog_constraint)::in, list(prog_constraint)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_prog_constraint_list(_InInt, _ConstraintErrorContext, - [], [], !Info, !Specs). + [], [], !Info). qualify_prog_constraint_list(InInt, ConstraintErrorContext, - [Constraint0 | Constraints0], [Constraint | Constraints], - !Info, !Specs) :- + [Constraint0 | Constraints0], [Constraint | Constraints], !Info) :- qualify_prog_constraint(InInt, ConstraintErrorContext, - Constraint0, Constraint, !Info, !Specs), + Constraint0, Constraint, !Info), qualify_prog_constraint_list(InInt, ConstraintErrorContext, - Constraints0, Constraints, !Info, !Specs). + Constraints0, Constraints, !Info). :- pred qualify_prog_constraint(mq_in_interface::in, mq_constraint_error_context::in, - prog_constraint::in, prog_constraint::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + prog_constraint::in, prog_constraint::out, + mq_info::in, mq_info::out) is det. qualify_prog_constraint(InInt, ContainingErrorContext, - Constraint0, Constraint, !Info, !Specs) :- + Constraint0, Constraint, !Info) :- Constraint0 = constraint(ClassName0, Types0), list.length(Types0, Arity), OutsideContext = mqec_typeclass_constraint_name(ContainingErrorContext), qualify_class_name(InInt, OutsideContext, - mq_id(ClassName0, Arity), ClassName, !Info, !Specs), + mq_id(ClassName0, Arity), ClassName, !Info), ErrorContext = mqec_typeclass_constraint(ClassName0, Arity, ContainingErrorContext), - qualify_type_list(InInt, ErrorContext, Types0, Types, !Info, !Specs), + qualify_type_list(InInt, ErrorContext, Types0, Types, !Info), Constraint = constraint(ClassName, Types). %---------------------% @@ -1676,54 +1609,50 @@ qualify_prog_constraint(InInt, ContainingErrorContext, :- pred qualify_var_or_ground_constraint_list(mq_in_interface::in, mq_constraint_error_context::in, list(var_or_ground_constraint)::in, list(var_or_ground_constraint)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_var_or_ground_constraint_list(_InInt, _ConstraintErrorContext, - [], [], !Info, !Specs). + [], [], !Info). qualify_var_or_ground_constraint_list(InInt, ConstraintErrorContext, - [Constraint0 | Constraints0], [Constraint | Constraints], - !Info, !Specs) :- + [Constraint0 | Constraints0], [Constraint | Constraints], !Info) :- qualify_var_or_ground_constraint(InInt, ConstraintErrorContext, - Constraint0, Constraint, !Info, !Specs), + Constraint0, Constraint, !Info), qualify_var_or_ground_constraint_list(InInt, ConstraintErrorContext, - Constraints0, Constraints, !Info, !Specs). + Constraints0, Constraints, !Info). :- pred qualify_var_or_ground_constraint(mq_in_interface::in, mq_constraint_error_context::in, var_or_ground_constraint::in, var_or_ground_constraint::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. qualify_var_or_ground_constraint(InInt, ContainingErrorContext, - Constraint0, Constraint, !Info, !Specs) :- + Constraint0, Constraint, !Info) :- Constraint0 = var_or_ground_constraint(ClassName0, Types0, Context), list.length(Types0, Arity), OutsideContext = mqec_typeclass_constraint_name(ContainingErrorContext), qualify_class_name(InInt, OutsideContext, - mq_id(ClassName0, Arity), ClassName, !Info, !Specs), + mq_id(ClassName0, Arity), ClassName, !Info), ErrorContext = mqec_typeclass_constraint(ClassName0, Arity, ContainingErrorContext), qualify_var_or_ground_type_list(InInt, ErrorContext, Types0, Types, - !Info, !Specs), + !Info), Constraint = var_or_ground_constraint(ClassName, Types, Context). :- pred qualify_var_or_ground_type_list(mq_in_interface::in, mq_error_context::in, list(var_or_ground_type)::in, list(var_or_ground_type)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_var_or_ground_type_list(_, _, [], [], !Info, !Specs). +qualify_var_or_ground_type_list(_, _, [], [], !Info). qualify_var_or_ground_type_list(InInt, ErrorContext, - [Arg0 | Args0], [Arg | Args], !Info, !Specs) :- + [Arg0 | Args0], [Arg | Args], !Info) :- ( Arg0 = type_var_name(_, _), Arg = Arg0 ; Arg0 = ground_type(GroundType0), Type0 = coerce(GroundType0), - qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs), + qualify_type(InInt, ErrorContext, Type0, Type, !Info), ( if type_is_ground(Type, GroundType) then Arg = ground_type(GroundType) else @@ -1731,39 +1660,33 @@ qualify_var_or_ground_type_list(InInt, ErrorContext, ) ), qualify_var_or_ground_type_list(InInt, ErrorContext, - Args0, Args, !Info, !Specs). + Args0, Args, !Info). %---------------------% :- pred qualify_class_name(mq_in_interface::in, mq_error_context::in, - mq_id::in, sym_name::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_id::in, sym_name::out, mq_info::in, mq_info::out) is det. -qualify_class_name(InInt, ErrorContext, Class0, Name, !Info, !Specs) :- +qualify_class_name(InInt, ErrorContext, Class0, Name, !Info) :- mq_info_get_classes(!.Info, ClassIdSet), find_unique_match(InInt, ErrorContext, ClassIdSet, qual_id_class, - Class0, Name, !Info, !Specs). + Class0, Name, !Info). %---------------------% :- pred qualify_class_decls(mq_in_interface::in, class_id::in, list(class_decl)::in, list(class_decl)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_class_decls(_InInt, _ClassId, [], [], !Info, !Specs). -qualify_class_decls(InInt, ClassId, - [Decl0 | Decls0], [Decl | Decls], !Info, !Specs) :- - qualify_class_decl(InInt, ClassId, Decl0, Decl, - !Info, !Specs), - qualify_class_decls(InInt, ClassId, Decls0, Decls, - !Info, !Specs). +qualify_class_decls(_InInt, _ClassId, [], [], !Info). +qualify_class_decls(InInt, ClassId, [Decl0 | Decls0], [Decl | Decls], !Info) :- + qualify_class_decl(InInt, ClassId, Decl0, Decl, !Info), + qualify_class_decls(InInt, ClassId, Decls0, Decls, !Info). :- pred qualify_class_decl(mq_in_interface::in, class_id::in, - class_decl::in, class_decl::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + class_decl::in, class_decl::out, mq_info::in, mq_info::out) is det. -qualify_class_decl(InInt, ClassId, Decl0, Decl, !Info, !Specs) :- +qualify_class_decl(InInt, ClassId, Decl0, Decl, !Info) :- % There is no need to qualify the method name, since that is done % when the item is parsed. ( @@ -1793,16 +1716,15 @@ qualify_class_decl(InInt, ClassId, Decl0, Decl, !Info, !Specs) :- ErrorContext = mqec_class_method(Context, ClassId, PredOrFunc, Name, UserArityIfKnown), qualify_types_and_maybe_modes(InInt, ErrorContext, - TypesAndMaybeModes0, TypesAndMaybeModes, !Info, !Specs), + TypesAndMaybeModes0, TypesAndMaybeModes, !Info), ConstraintErrorContext = mqcec_class_method(Context, ClassId, PredOrFunc, Name, UserArityIfKnown), qualify_prog_constraints(InInt, ConstraintErrorContext, - Constraints0, Constraints, !Info, !Specs), + Constraints0, Constraints, !Info), ( MaybeWithType0 = yes(WithType0), % XXX We could pass a more specific error context. - qualify_type(InInt, ErrorContext, WithType0, WithType, - !Info, !Specs), + qualify_type(InInt, ErrorContext, WithType0, WithType, !Info), MaybeWithType = yes(WithType) ; MaybeWithType0 = no, @@ -1811,8 +1733,7 @@ qualify_class_decl(InInt, ClassId, Decl0, Decl, !Info, !Specs) :- ( MaybeWithInst0 = yes(WithInst0), % XXX We could pass a more specific error context. - qualify_inst(InInt, ErrorContext, WithInst0, WithInst, - !Info, !Specs), + qualify_inst(InInt, ErrorContext, WithInst0, WithInst, !Info), MaybeWithInst = yes(WithInst) ; MaybeWithInst0 = no, @@ -1845,12 +1766,12 @@ qualify_class_decl(InInt, ClassId, Decl0, Decl, !Info, !Specs) :- ), ErrorContext = mqec_class_method_mode(Context, ClassId, MaybePredOrFunc, Name, UserArityIfKnown), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info, !Specs), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info), ( MaybeWithInst0 = yes(WithInst0), % XXX We could pass a more specific error context. qualify_inst(InInt, ErrorContext, WithInst0, WithInst, - !Info, !Specs), + !Info), MaybeWithInst = yes(WithInst) ; MaybeWithInst0 = no, @@ -1931,10 +1852,9 @@ qualify_instance_method(DefaultModuleName, InstanceMethod0, InstanceMethod) :- :- pred module_qualify_item_decl_pragma(mq_in_interface::in, item_decl_pragma_info::in, item_decl_pragma_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- +module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info) :- ( Pragma0 = decl_pragma_type_spec_constr(TypeSpecConstrInfo0), TypeSpecConstrInfo0 = decl_pragma_type_spec_constr_info(ModuleName, @@ -1943,16 +1863,15 @@ module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- ConstraintErrorContext = mqcec_type_spec_constr(Context, ModuleName), OoMConstraints0 = one_or_more(HeadConstraint0, TailConstraints0), qualify_var_or_ground_constraint(InInt, ConstraintErrorContext, - HeadConstraint0, HeadConstraint, !Info, !Specs), + HeadConstraint0, HeadConstraint, !Info), qualify_var_or_ground_constraint_list(InInt, ConstraintErrorContext, - TailConstraints0, TailConstraints, !Info, !Specs), + TailConstraints0, TailConstraints, !Info), OoMConstraints = one_or_more(HeadConstraint, TailConstraints), ErrorContext = mqec_pragma_decl(Context, Pragma0), OoMSubsts0 = one_or_more(HeadSubst0, TailSubsts0), - qualify_type_subst(InInt, ErrorContext, - HeadSubst0, HeadSubst, !Info, !Specs), - list.map_foldl2(qualify_type_subst(InInt, ErrorContext), - TailSubsts0, TailSubsts, !Info, !Specs), + qualify_type_subst(InInt, ErrorContext, HeadSubst0, HeadSubst, !Info), + list.map_foldl(qualify_type_subst(InInt, ErrorContext), + TailSubsts0, TailSubsts, !Info), OoMSubsts = one_or_more(HeadSubst, TailSubsts), TypeSpecConstrInfo = decl_pragma_type_spec_constr_info(ModuleName, OoMConstraints, ApplyToSupers, OoMSubsts, TVarSet, Items, @@ -1967,8 +1886,7 @@ module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- PFUMM0 = pfumm_predicate(ModesOrArity0), ( ModesOrArity0 = moa_modes(Modes0), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, - !Info, !Specs), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info), ModesOrArity = moa_modes(Modes), PFUMM = pfumm_predicate(ModesOrArity) ; @@ -1979,8 +1897,7 @@ module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- PFUMM0 = pfumm_function(ModesOrArity0), ( ModesOrArity0 = moa_modes(Modes0), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, - !Info, !Specs), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info), ModesOrArity = moa_modes(Modes), PFUMM = pfumm_function(ModesOrArity) ; @@ -1991,7 +1908,7 @@ module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- PFUMM0 = pfumm_unknown(_Arity), PFUMM = PFUMM0 ), - qualify_type_subst(InInt, ErrorContext, Subst0, Subst, !Info, !Specs), + qualify_type_subst(InInt, ErrorContext, Subst0, Subst, !Info), TypeSpecInfo = decl_pragma_type_spec_info(PFUMM, PredName, SpecPredName, Subst, TVarSet, Items, Context, SeqNum), Pragma = decl_pragma_type_spec(TypeSpecInfo) @@ -2002,7 +1919,7 @@ module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- % XXX Preds ErrorContext = mqec_pragma_decl(Context, Pragma0), qualify_type_ctor(InInt, ErrorContext, TypeCtor0, TypeCtor, - !Info, !Specs), + !Info), OISUInfo = decl_pragma_oisu_info(TypeCtor, CreatorPreds, MutatorPreds, DestructorPreds, Context, SeqNum), Pragma = decl_pragma_oisu(OISUInfo) @@ -2012,7 +1929,7 @@ module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- Context, SeqNum), PredNameModesPF0 = proc_pf_name_modes(PredOrFunc, SymName, Modes0), ErrorContext = mqec_pragma_decl(Context, Pragma0), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info, !Specs), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info), PredNameModesPF = proc_pf_name_modes(PredOrFunc, SymName, Modes), TermInfo = decl_pragma_termination_info(PredNameModesPF, Args, Term, Context, SeqNum), @@ -2023,7 +1940,7 @@ module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- SuccessArgs, FailureArgs, Term, Context, SeqNum), PredNameModesPF0 = proc_pf_name_modes(PredOrFunc, SymName, Modes0), ErrorContext = mqec_pragma_decl(Context, Pragma0), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info, !Specs), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info), PredNameModesPF = proc_pf_name_modes(PredOrFunc, SymName, Modes), Term2Info = decl_pragma_termination2_info(PredNameModesPF, SuccessArgs, FailureArgs, Term, Context, SeqNum), @@ -2035,7 +1952,7 @@ module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- Context, SeqNum), PredNameModesPF0 = proc_pf_name_modes(PredOrFunc, SymName, Modes0), ErrorContext = mqec_pragma_decl(Context, Pragma0), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info, !Specs), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info), PredNameModesPF = proc_pf_name_modes(PredOrFunc, SymName, Modes), SharingInfo = decl_pragma_struct_sharing_info(PredNameModesPF, HeadVars, HeadVarTypes, VarSet, TVarSet, MaybeSharing, @@ -2048,7 +1965,7 @@ module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- Context, SeqNum), PredNameModesPF0 = proc_pf_name_modes(PredOrFunc, SymName, Modes0), ErrorContext = mqec_pragma_decl(Context, Pragma0), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info, !Specs), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info), PredNameModesPF = proc_pf_name_modes(PredOrFunc, SymName, Modes), ReuseInfo = decl_pragma_struct_reuse_info(PredNameModesPF, HeadVars, HeadVarTypes, VarSet, TVarSet, MaybeReuse, @@ -2064,10 +1981,9 @@ module_qualify_item_decl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- :- pred module_qualify_item_impl_pragma(mq_in_interface::in, item_impl_pragma_info::in, item_impl_pragma_info::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -module_qualify_item_impl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- +module_qualify_item_impl_pragma(InInt, Pragma0, Pragma, !Info) :- ( ( Pragma0 = impl_pragma_foreign_decl(_) ; Pragma0 = impl_pragma_foreign_code(_) @@ -2090,7 +2006,7 @@ module_qualify_item_impl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- ModesOrArity0 = moa_modes(Modes0), ErrorContext = mqec_pragma_impl(Context, Pragma0), qualify_mode_list(InInt, ErrorContext, Modes0, Modes, - !Info, !Specs), + !Info), ModesOrArity = moa_modes(Modes), PFUMM = pfumm_predicate(ModesOrArity) ; @@ -2103,7 +2019,7 @@ module_qualify_item_impl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- ModesOrArity0 = moa_modes(Modes0), ErrorContext = mqec_pragma_impl(Context, Pragma0), qualify_mode_list(InInt, ErrorContext, Modes0, Modes, - !Info, !Specs), + !Info), ModesOrArity = moa_modes(Modes), PFUMM = pfumm_function(ModesOrArity) ; @@ -2124,7 +2040,7 @@ module_qualify_item_impl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- PredNameModesPF0, CFunc, VarSet, Context, SeqNum), PredNameModesPF0 = proc_pf_name_modes(PredOrFunc, Name, Modes0), ErrorContext = mqec_pragma_impl(Context, Pragma0), - qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info, !Specs), + qualify_mode_list(InInt, ErrorContext, Modes0, Modes, !Info), PredNameModesPF = proc_pf_name_modes(PredOrFunc, Name, Modes), FPEInfo = impl_pragma_fproc_export_info(Origin, Lang, PredNameModesPF, CFunc, VarSet, Context, SeqNum), @@ -2132,49 +2048,44 @@ module_qualify_item_impl_pragma(InInt, Pragma0, Pragma, !Info, !Specs) :- ). :- pred qualify_pragma_vars(mq_in_interface::in, mq_error_context::in, - list(pragma_var)::in, list(pragma_var)::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + list(pragma_var)::in, list(pragma_var)::out, + mq_info::in, mq_info::out) is det. -qualify_pragma_vars(_InInt, _ErrorContext, [], [], !Info, !Specs). +qualify_pragma_vars(_InInt, _ErrorContext, [], [], !Info). qualify_pragma_vars(InInt, ErrorContext, - [PragmaVar0 | PragmaVars0], [PragmaVar | PragmaVars], !Info, !Specs) :- + [PragmaVar0 | PragmaVars0], [PragmaVar | PragmaVars], !Info) :- % XXX We could pass a more specific error context. - qualify_pragma_var(InInt, ErrorContext, PragmaVar0, PragmaVar, - !Info, !Specs), - qualify_pragma_vars(InInt, ErrorContext, PragmaVars0, PragmaVars, - !Info, !Specs). + qualify_pragma_var(InInt, ErrorContext, PragmaVar0, PragmaVar, !Info), + qualify_pragma_vars(InInt, ErrorContext, PragmaVars0, PragmaVars, !Info). :- pred qualify_pragma_var(mq_in_interface::in, mq_error_context::in, - pragma_var::in, pragma_var::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + pragma_var::in, pragma_var::out, mq_info::in, mq_info::out) is det. -qualify_pragma_var(InInt, ErrorContext, PragmaVar0, PragmaVar, - !Info, !Specs) :- +qualify_pragma_var(InInt, ErrorContext, PragmaVar0, PragmaVar, !Info) :- PragmaVar0 = pragma_var(Var, Name, Mode0, Box), % XXX We could pass a more specific error context. - qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info, !Specs), + qualify_mode(InInt, ErrorContext, Mode0, Mode, !Info), PragmaVar = pragma_var(Var, Name, Mode, Box). :- pred qualify_type_subst(mq_in_interface::in, mq_error_context::in, - type_subst::in, type_subst::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + type_subst::in, type_subst::out, mq_info::in, mq_info::out) is det. -qualify_type_subst(InInt, ErrorContext, Subst0, Subst, !Info, !Specs) :- +qualify_type_subst(InInt, ErrorContext, Subst0, Subst, !Info) :- Subst0 = one_or_more(HeadSubst0, TailSubsts0), qualify_tvar_substs(InInt, ErrorContext, - HeadSubst0, HeadSubst, TailSubsts0, TailSubsts, !Info, !Specs), + HeadSubst0, HeadSubst, TailSubsts0, TailSubsts, !Info), Subst = one_or_more(HeadSubst, TailSubsts). :- pred qualify_tvar_substs(mq_in_interface::in, mq_error_context::in, tvar_subst::in, tvar_subst::out, - list(tvar_subst)::in, list(tvar_subst)::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + list(tvar_subst)::in, list(tvar_subst)::out, + mq_info::in, mq_info::out) is det. qualify_tvar_substs(InInt, ErrorContext, - HeadSubst0, HeadSubst, TailSubsts0, TailSubsts, !Info, !Specs) :- + HeadSubst0, HeadSubst, TailSubsts0, TailSubsts, !Info) :- HeadSubst0 = tvar_subst(Var, Type0), % XXX We could pass a more specific error context. - qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs), + qualify_type(InInt, ErrorContext, Type0, Type, !Info), HeadSubst = tvar_subst(Var, Type), ( TailSubsts0 = [], @@ -2183,17 +2094,15 @@ qualify_tvar_substs(InInt, ErrorContext, TailSubsts0 = [HeadTailSubst0 | TailTailSubsts0], qualify_tvar_substs(InInt, ErrorContext, HeadTailSubst0, HeadTailSubst, TailTailSubsts0, TailTailSubsts, - !Info, !Specs), + !Info), TailSubsts = [HeadTailSubst | TailTailSubsts] ). :- pred qualify_user_sharing(mq_in_interface::in, mq_error_context::in, user_annotated_sharing::in, user_annotated_sharing::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_user_sharing(InInt, ErrorContext, UserSharing0, UserSharing, - !Info, !Specs) :- +qualify_user_sharing(InInt, ErrorContext, UserSharing0, UserSharing, !Info) :- ( UserSharing0 = no_user_annotated_sharing, UserSharing = UserSharing0 @@ -2201,8 +2110,7 @@ qualify_user_sharing(InInt, ErrorContext, UserSharing0, UserSharing, UserSharing0 = user_sharing(Sharing, MaybeTypes0), ( MaybeTypes0 = yes(user_type_info(Types0, TVarset)), - qualify_type_list(InInt, ErrorContext, Types0, Types, - !Info, !Specs), + qualify_type_list(InInt, ErrorContext, Types0, Types, !Info), MaybeTypes = yes(user_type_info(Types, TVarset)), UserSharing = user_sharing(Sharing, MaybeTypes) ; @@ -2217,17 +2125,19 @@ qualify_user_sharing(InInt, ErrorContext, UserSharing0, UserSharing, % :- pred module_qualify_item_mutable(mq_in_interface::in, - item_mutable_info::in, item_mutable_info::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + item_mutable_info::in, item_mutable_info::out, + mq_info::in, mq_info::out) is det. -module_qualify_item_mutable(InInt, ItemMutable0, ItemMutable, !Info, !Specs) :- +module_qualify_item_mutable(InInt, ItemMutable0, ItemMutable, !Info) :- ItemMutable0 = item_mutable_info(Name, OrigType0, Type0, OrigInst0, Inst0, InitTerm, Attrs, Varset, Context, SeqNum), ErrorContext = mqec_mutable(Context, Name), - qualify_type(InInt, ErrorContext, OrigType0, OrigType, !Info, [], _), - qualify_type(InInt, ErrorContext, Type0, Type, !Info, !Specs), - qualify_inst(InInt, ErrorContext, OrigInst0, OrigInst, !Info, [], _), - qualify_inst(InInt, ErrorContext, Inst0, Inst, !Info, !Specs), + % WAS_IGNORED We used to ignore error_specs from OrigType. + qualify_type(InInt, ErrorContext, OrigType0, OrigType, !Info), + qualify_type(InInt, ErrorContext, Type0, Type, !Info), + % WAS_IGNORED We used to ignore error_specs from OrigInst. + qualify_inst(InInt, ErrorContext, OrigInst0, OrigInst, !Info), + qualify_inst(InInt, ErrorContext, Inst0, Inst, !Info), ItemMutable = item_mutable_info(Name, OrigType, Type, OrigInst, Inst, InitTerm, Attrs, Varset, Context, SeqNum). @@ -2240,43 +2150,39 @@ module_qualify_item_mutable(InInt, ItemMutable0, ItemMutable, !Info, !Specs) :- % :- pred qualify_event_specs(mq_in_interface::in, string::in, assoc_list(string, event_spec)::in, assoc_list(string, event_spec)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_event_specs(_InInt, _, [], [], !Info, !Specs). +qualify_event_specs(_InInt, _, [], [], !Info). qualify_event_specs(InInt, FileName, - [Name - Spec0 | NameSpecs0], [Name - Spec | NameSpecs], - !Info, !Specs) :- - qualify_event_spec(InInt, FileName, Spec0, Spec, !Info, !Specs), - qualify_event_specs(InInt, FileName, NameSpecs0, NameSpecs, !Info, !Specs). + [Name - Spec0 | NameSpecs0], [Name - Spec | NameSpecs], !Info) :- + qualify_event_spec(InInt, FileName, Spec0, Spec, !Info), + qualify_event_specs(InInt, FileName, NameSpecs0, NameSpecs, !Info). :- pred qualify_event_spec(mq_in_interface::in, string::in, - event_spec::in, event_spec::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + event_spec::in, event_spec::out, mq_info::in, mq_info::out) is det. -qualify_event_spec(InInt, FileName, EventSpec0, EventSpec, - !Info, !Specs) :- +qualify_event_spec(InInt, FileName, EventSpec0, EventSpec, !Info) :- EventSpec0 = event_spec(EventNumber, EventName, EventLineNumber, Attrs0, SynthAttrNumOrder), - list.map_foldl2( + list.map_foldl( qualify_event_attr(InInt, EventName, FileName, EventLineNumber), - Attrs0, Attrs, !Info, !Specs), + Attrs0, Attrs, !Info), EventSpec = event_spec(EventNumber, EventName, EventLineNumber, Attrs, SynthAttrNumOrder). :- pred qualify_event_attr(mq_in_interface::in, string::in, string::in, int::in, - event_attribute::in, event_attribute::out, mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + event_attribute::in, event_attribute::out, + mq_info::in, mq_info::out) is det. qualify_event_attr(InInt, EventName, FileName, LineNumber, - Attr0, Attr, !Info, !Specs) :- + Attr0, Attr, !Info) :- Attr0 = event_attribute(AttrNum, AttrName, AttrType0, AttrMode0, MaybeSynthCall), Context = context(FileName, LineNumber), ErrorContext = mqec_event_spec_attr(Context, EventName, AttrName), - qualify_type(InInt, ErrorContext, AttrType0, AttrType, !Info, !Specs), - qualify_mode(InInt, ErrorContext, AttrMode0, AttrMode, !Info, !Specs), + qualify_type(InInt, ErrorContext, AttrType0, AttrType, !Info), + qualify_mode(InInt, ErrorContext, AttrMode0, AttrMode, !Info), Attr = event_attribute(AttrNum, AttrName, AttrType, AttrMode, MaybeSynthCall). diff --git a/compiler/qual_info.m b/compiler/qual_info.m index 541d4f9a1..f57b6ccaa 100644 --- a/compiler/qual_info.m +++ b/compiler/qual_info.m @@ -228,7 +228,7 @@ process_type_qualification(Var, Type0, VarSet, Context, !QualInfo, !Specs) :- MaybeOptImported = is_not_opt_imported, % Type qualifications cannot appear in the interface of a module. qualify_type_qualification(mq_not_used_in_interface, Context, - Type0, Type1, MQInfo0, MQInfo, !Specs) + Type0, Type1, MQInfo0, MQInfo) ), % Find any new type variables introduced by this type, and diff --git a/compiler/superhomogeneous_lambda.m b/compiler/superhomogeneous_lambda.m index 23441bf27..c3e48f0a3 100644 --- a/compiler/superhomogeneous_lambda.m +++ b/compiler/superhomogeneous_lambda.m @@ -961,11 +961,9 @@ qualify_lambda_arg_modes_if_not_opt_imported(LambdaArgs0, LambdaArgs, InInt = mq_not_used_in_interface, qual_info_get_mq_info(QualInfo0, MQInfo0), qualify_lambda_arg_modes(InInt, LambdaArgs0, LambdaArgs, Modes, - MQInfo0, MQInfo, [], Specs), + MQInfo0, MQInfo), qual_info_set_mq_info(MQInfo, QualInfo0, QualInfo), - !UrInfo ^ ui_qual_info := QualInfo, - % Note: Specs will almost always be []. - add_unravel_specs(Specs, !UrInfo) + !UrInfo ^ ui_qual_info := QualInfo ; MaybeOptImported = is_opt_imported, % The modes in `.opt' files are already fully module qualified. @@ -975,19 +973,18 @@ qualify_lambda_arg_modes_if_not_opt_imported(LambdaArgs0, LambdaArgs, :- pred qualify_lambda_arg_modes(mq_in_interface::in, list(lambda_arg)::in, list(lambda_arg)::out, list(mer_mode)::out, - mq_info::in, mq_info::out, - list(error_spec)::in, list(error_spec)::out) is det. + mq_info::in, mq_info::out) is det. -qualify_lambda_arg_modes(_InInt, [], [], [], !MQInfo, !Specs). +qualify_lambda_arg_modes(_InInt, [], [], [], !MQInfo). qualify_lambda_arg_modes(InInt, [LambdaArg0 | LambdaArgs0], - [LambdaArg | LambdaArgs], [Mode | Modes], !MQInfo, !Specs) :- + [LambdaArg | LambdaArgs], [Mode | Modes], !MQInfo) :- LambdaArg0 = lambda_arg(ArgNum, ProgArgTerm, LambdaVar, Kind, PresentOrAbsent, Mode0, ModeContext), - qualify_lambda_mode(InInt, ModeContext, Mode0, Mode, !MQInfo, !Specs), + qualify_lambda_mode(InInt, ModeContext, Mode0, Mode, !MQInfo), LambdaArg = lambda_arg(ArgNum, ProgArgTerm, LambdaVar, Kind, PresentOrAbsent, Mode, ModeContext), qualify_lambda_arg_modes(InInt, LambdaArgs0, - LambdaArgs, Modes, !MQInfo, !Specs). + LambdaArgs, Modes, !MQInfo). %---------------------------------------------------------------------------% :- end_module hlds.make_hlds.superhomogeneous_lambda.