Disable module patterns in comprehensions (#131)

* Disable module patterns in comprehensions, and add a test

* Copy tests to all three of array, iarray, list

* Add a more correct fix, that avoids the [in] body re-enabling allow_modules mode

* Relocate tests to more sensible place, and add a test to check the re-enabling of allow_modules mode

* fix formatting

Author: ncik-roberts

testsuite/tests/comprehensions/array_comprehensions_pure.ml

@@ -311,6 +311,58 @@ Error: This expression has type float but an expression was expected of type
        because it is in a range-based for iterator start index in a comprehension
 |}];;
 
+(* Using first-class module patterns isn't supported yet *)
+
+module type S = sig
+  type t
+  val x : t
+end;;
+
+let t = (module struct
+  type t = int
+  let x = 3
+end : S);;
+[%%expect {|
+module type S = sig type t val x : t end
+val t : (module S) = <module>
+|}];;
+
+[| M.x for (module M : S) in [| t |] |];;
+[%%expect {|
+Line 1, characters 19-20:
+1 | [| M.x for (module M : S) in [| t |] |];;
+                       ^
+Error: Modules are not allowed in this pattern.
+|}];;
+
+[| M.x
+   for (module M : S) in
+   [| (module struct
+         type t = int
+         let x = 3
+       end : S)
+   |]
+|];;
+[%%expect {|
+Line 2, characters 15-16:
+2 |    for (module M : S) in
+                   ^
+Error: Modules are not allowed in this pattern.
+|}];;
+
+[| M.x
+   for (module M : S) in
+   [| (let t = t in
+       t)
+   |]
+|];;
+[%%expect {|
+Line 2, characters 15-16:
+2 |    for (module M : S) in
+                   ^
+Error: Modules are not allowed in this pattern.
+|}];;
+
 (* No duplicating variables in a for-and clause *)
 
 [|i for i = 1 to 3 and i = 3 downto 1|];;

testsuite/tests/comprehensions/iarray_comprehensions_pure.ml

@@ -409,6 +409,58 @@ Error: This expression has type float but an expression was expected of type
        because it is in a range-based for iterator start index in a comprehension
 |}];;
 
+(* Using first-class module patterns isn't supported yet *)
+
+module type S = sig
+  type t
+  val x : t
+end;;
+
+let t = (module struct
+  type t = int
+  let x = 3
+end : S);;
+[%%expect {|
+module type S = sig type t val x : t end
+val t : (module S) = <module>
+|}];;
+
+[: M.x for (module M : S) in [: t :] :];;
+[%%expect {|
+Line 1, characters 19-20:
+1 | [: M.x for (module M : S) in [: t :] :];;
+                       ^
+Error: Modules are not allowed in this pattern.
+|}];;
+
+[: M.x
+   for (module M : S) in
+   [: (module struct
+         type t = int
+         let x = 3
+       end : S)
+   :]
+:];;
+[%%expect {|
+Line 2, characters 15-16:
+2 |    for (module M : S) in
+                   ^
+Error: Modules are not allowed in this pattern.
+|}];;
+
+[: M.x
+   for (module M : S) in
+   [: (let t = t in
+       t)
+   :]
+:];;
+[%%expect {|
+Line 2, characters 15-16:
+2 |    for (module M : S) in
+                   ^
+Error: Modules are not allowed in this pattern.
+|}];;
+
 (* No duplicating variables in a for-and clause *)
 
 [:i for i = 1 to 3 and i = 3 downto 1:];;

testsuite/tests/comprehensions/list_comprehensions_pure.ml

@@ -303,6 +303,58 @@ Error: This expression has type float but an expression was expected of type
        because it is in a range-based for iterator start index in a comprehension
 |}];;
 
+(* Using first-class module patterns isn't supported yet *)
+
+module type S = sig
+  type t
+  val x : t
+end;;
+
+let t = (module struct
+  type t = int
+  let x = 3
+end : S);;
+[%%expect {|
+module type S = sig type t val x : t end
+val t : (module S) = <module>
+|}];;
+
+[ M.x for (module M : S) in [ t ] ];;
+[%%expect {|
+Line 1, characters 18-19:
+1 | [ M.x for (module M : S) in [ t ] ];;
+                      ^
+Error: Modules are not allowed in this pattern.
+|}];;
+
+[ M.x
+  for (module M : S) in
+  [ (module struct
+        type t = int
+        let x = 3
+      end : S)
+  ]
+];;
+[%%expect {|
+Line 2, characters 14-15:
+2 |   for (module M : S) in
+                  ^
+Error: Modules are not allowed in this pattern.
+|}];;
+
+[ M.x
+  for (module M : S) in
+  [ (let t = t in
+      t)
+  ]
+];;
+[%%expect {|
+Line 2, characters 14-15:
+2 |   for (module M : S) in
+                  ^
+Error: Modules are not allowed in this pattern.
+|}];;
+
 (* No duplicating variables in a for-and clause *)
 
 [i for i = 1 to 3 and i = 3 downto 1];;

typing/typecore.ml

@@ -7137,6 +7137,9 @@ and type_comprehension_iterator
              ~explanation:(Comprehension_in_iterator comprehension_type)
              seq_ty)
       in
+      (* TODO: fix handling of first-class module patterns so we can remove
+       * this line. *)
+      allow_modules := false;
       let pattern =
         (* To understand why we can currently only provide [global] bindings for
            the contents of sequences comprehensions iterate over, see "What