Keep the module type comparison around a permutation of its fields

Why:
    Codex review of #9140: when two module types have the same fields in
    another order, the innermost symptom is the permutation, which shows no
    declarations, and leaving out the module type comparison around it left
    only "Illegal permutation of structure fields". A comparison is now left
    out only when a later symptom shows the declarations that differ.

    The parser gave a module type declaration in a signature no location,
    unlike one in a structure, so the expected side printed without a
    position. It now spans from the name to the end, as in a structure.

Diagnostic modified (fields of a module type in another order):
Example:
    module M: {
      module type T = {
        let a: int
        let b: int
      }
    } = {
      module type T = {
        let b: int
        let a: int
      }
    }
Before (diagnostic):
    Signature mismatch:

    In module type T:

    Illegal permutation of structure fields
After (diagnostic):
    Signature mismatch:

    Actual declaration (include_modtype_permutation.res:7:15-10:3):
      module type T = {
        let b: int
        let a: int
      }

    Expected declaration (include_modtype_permutation.res:2:15-5:3):
      module type T = {
        let a: int
        let b: int
      }

    In module type T:

    Illegal permutation of structure fields

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Kbf3gLpf7RN1MiRcubPgRn
Signed-off-by: Christoph Knittel <ck@cca.io>

Author: cknitt

compiler/ml/includemod.ml

@@ -681,10 +681,22 @@ let include_err ~show_context ppf (cxt, env, err) =
    differ. The modules on the way are left out, as the items at the end say
    what differs, each under the position it is at. *)
 let report_error ppf errs =
+  (* Whether a symptom shows the declarations that differ. A permutation of
+     fields doesn't, so the comparison of the module types around it stays. *)
+  let shows_declarations (_, _, symptom) =
+    match symptom with
+    | Missing_field _ | Value_descriptions _ | Type_declarations _
+    | Extension_constructors _ | Module_types _ | Modtype_infos _ ->
+      true
+    | Modtype_permutation | Interface_mismatch _ | Unbound_modtype_path _
+    | Unbound_module_path _ | Invalid_module_alias _ ->
+      false
+  in
   let rec shown = function
     | [] -> []
-    | [err] -> [err]
-    | (_, _, (Module_types _ | Modtype_infos _)) :: rest -> shown rest
+    | (_, _, (Module_types _ | Modtype_infos _)) :: rest
+      when List.exists shows_declarations rest ->
+      shown rest
     | err :: rest -> err :: shown rest
   in
   let rec print ppf previous_cxt = function

compiler/syntax/src/res_core.ml

@@ -7244,6 +7244,7 @@ and parse_module_declaration_or_alias ~attrs p =
 
 and parse_module_type_declaration ~attrs ~start_pos p =
   Parser.expect Typ p;
+  let name_start = Parser.start_pos p in
   let module_name =
     match Parser.peek p with
     | Uident ident ->
@@ -7265,7 +7266,12 @@ and parse_module_type_declaration ~attrs ~start_pos p =
       Some (parse_module_type p)
     | _ -> None
   in
-  let module_decl = Ast_helper.Mtd.mk ~attrs ?typ module_name in
+  (* From the name, like a module type declaration in a structure *)
+  let module_decl =
+    Ast_helper.Mtd.mk ~attrs
+      ~loc:(mk_loc name_start (Parser.position p))
+      ?typ module_name
+  in
   Ast_helper.Sig.modtype ~loc:(mk_loc start_pos (Parser.position p)) module_decl
 
 and parse_sign_let_desc ~attrs p =

tests/build_tests/super_errors/expected/include_modtype_permutation.res.expected

@@ -13,6 +13,18 @@
 
   Signature mismatch:
 
+  Actual declaration (/.../fixtures/include_modtype_permutation.res:7:15-10:3):
+    module type T = {
+      let b: int
+      let a: int
+    }
+  
+  Expected declaration (/.../fixtures/include_modtype_permutation.res:2:15-5:3):
+    module type T = {
+      let a: int
+      let b: int
+    }
+  
   In module type T:
 
   Illegal permutation of structure fields