Fix DisallowModule rule missing Pexp_ident — pipe calls with no extra args (#15) (#16)

* Fix DisallowModule rule missing Pexp_ident — pipe calls with no extra args now caught (#15)

Replace Pexp_apply-only matching with Pexp_ident matching in
lintExpression so bare module references (e.g. x->Belt.List.toArray)
are detected. Adds tests for the bug case and verifies all existing
Pexp_apply scenarios still pass.

Bump version to 0.4.3.

* Apply dune fmt formatting to test file

Author: LTibbetts

Changelog.md

@@ -1,5 +1,10 @@
 # ReScript Linter Changelog
 
+### 2026-02-26 - v0.4.3
+* Fixed DisallowModule rule missing `Pexp_ident` — pipe calls with no extra arguments now correctly trigger lint errors (#15)
+  * `x->Belt.List.toArray` and similar single-argument pipe expressions were silently bypassing the rule
+  * Replaced `Pexp_apply`-only matching with `Pexp_ident` matching to catch all disallowed module references
+
 ### 2026-02-09 - v0.4.2
 * Improved error handling for config file parsing
   * Added `ConfigParseError` exception with detailed error messages

dune-project

@@ -2,7 +2,7 @@
 
 (name rescript_linter)
 
-(version 0.4.2)
+(version 0.4.3)
 
 (generate_opam_files true)
 

lib/rules/DisallowModuleRule.ml

@@ -87,9 +87,8 @@ module Make (OPT : Rule.OPTIONS with type options = Options.options) (LinterOpti
     Rule.LintExpression
       (fun expr ->
         match expr with
-        (* match M.function or M.N.function in function calls *)
-        | { Parsetree.pexp_desc=
-              Pexp_apply {funct= {pexp_desc= Pexp_ident {txt= ident}; Parsetree.pexp_loc= loc}; args= _} }
+        (* match M.function or M.N.function — covers direct calls, pipe targets, and bare references *)
+        | {Parsetree.pexp_desc= Pexp_ident {txt= ident; _}; Parsetree.pexp_loc= loc}
           when match extract_module_path ident with
                | Some module_path -> matches_disallowed_module module_path
                | None -> false ->

rescript_linter.opam

@@ -1,6 +1,6 @@
 # This file is generated by dune, edit dune-project instead
 opam-version: "2.0"
-version: "0.4.2"
+version: "0.4.3"
 synopsis: "AST-based linter for ReScript"
 description: "AST-based linter for ReScript"
 maintainer: ["Shulhi Sapli"]

test/rescript_linter_test.ml

@@ -107,6 +107,28 @@ module DisallowBeltRule =
     end)
     (TestingLinterOptions)
 
+module DisallowBeltListRule =
+  DisallowModuleRule.Make
+    (struct
+      type options = DisallowModuleRule.Options.options
+
+      let options =
+        { DisallowModuleRule.Options.disallowed_module= "Belt.List"
+        ; DisallowModuleRule.Options.suggested_module= Some "List" }
+    end)
+    (TestingLinterOptions)
+
+module DisallowBeltArrayRule =
+  DisallowModuleRule.Make
+    (struct
+      type options = DisallowModuleRule.Options.options
+
+      let options =
+        { DisallowModuleRule.Options.disallowed_module= "Belt.Array"
+        ; DisallowModuleRule.Options.suggested_module= Some "Array" }
+    end)
+    (TestingLinterOptions)
+
 module DisallowedEmbeddedRegexLiteralRule =
   DisallowedEmbeddedRegexLiteralRule.Make
     (struct
@@ -317,6 +339,48 @@ module Tests = struct
           ^ string_of_int (List.length errors)
           ^ " errors" )
 
+  (* Issue #15: pipe with no extra arguments bypasses DisallowModule lint *)
+  let disallow_module_pipe_no_args_test () =
+    let parseResult = parseAst "testData/disallow_module_test_6.res" in
+    let errors, _warnings =
+      Linter.lint [(module DisallowBeltListRule : Rule.HASRULE)] parseResult.ast parseResult.comments
+    in
+    match errors with
+    | [_; _; _; _] -> Alcotest.(check pass) "Same error message" [] []
+    | errors ->
+        Alcotest.fail
+          ( "Should have four lint errors (direct call, pipe+args, pipe no-args toArray, pipe no-args \
+             length), but got "
+          ^ string_of_int (List.length errors)
+          ^ " errors" )
+
+  (* Issue #15: verify Pexp_apply scenarios still caught after Pexp_ident fix *)
+  let disallow_module_pexp_apply_test () =
+    let parseResult = parseAst "testData/disallow_module_test_7.res" in
+    let errors, _warnings =
+      Linter.lint
+        [(module DisallowBeltListRule : Rule.HASRULE); (module DisallowBeltArrayRule : Rule.HASRULE)]
+        parseResult.ast parseResult.comments
+    in
+    (* Expected errors:
+       1. Belt.List.toArray  — direct call, single arg
+       2. Belt.List.has      — direct call, multiple args
+       3. Belt.List.map      — pipe with extra args
+       4. Belt.List.toArray  — pipe with no extra args (was the bug)
+       5. Belt.List.toArray  — chained pipe, no-args (was the bug)
+       6. Belt.Array.map     — chained pipe, with args
+       7. Belt.List.toArray  — nested outer call
+       8. Belt.List.map      — nested inner call
+    *)
+    match errors with
+    | [_; _; _; _; _; _; _; _] -> Alcotest.(check pass) "Same error message" [] []
+    | errors ->
+        Alcotest.fail
+          ( "Should have eight lint errors (6 Belt.List + 2 Belt.Array... wait, 7 Belt.List + 1 Belt.Array), \
+             but got "
+          ^ string_of_int (List.length errors)
+          ^ " errors" )
+
   let disallowed_embedded_regex_literal_test () =
     let parseResult = parseAst "testData/disallowed_embedded_regex_literal_test.res" in
     let errors, _warnings =
@@ -441,7 +505,9 @@ let () =
         ; test_case "alias module" `Quick Tests.disallow_module_test_2
         ; test_case "direct access module" `Quick Tests.disallow_module_test_3
         ; test_case "qualified module with constructors (Belt.Result)" `Quick Tests.disallow_module_test_4
-        ; test_case "module prefix matching (Belt.*)" `Quick Tests.disallow_module_test_5 ] )
+        ; test_case "module prefix matching (Belt.*)" `Quick Tests.disallow_module_test_5
+        ; test_case "pipe with no extra args (Issue #15)" `Quick Tests.disallow_module_pipe_no_args_test
+        ; test_case "Pexp_apply still caught (Issue #15)" `Quick Tests.disallow_module_pexp_apply_test ] )
     ; ( "Disallowed embedded regex literal"
       , [test_case "Disallowed embedded regex literal" `Quick Tests.disallowed_embedded_regex_literal_test] )
     ; ("Disallowed dead code", [test_case "Disallowed dead code" `Quick Tests.disallowed_dead_code_test])

test/testData/disallow_module_test_6.res

@@ -0,0 +1,14 @@
+// Test for pipe expressions with no extra arguments (Issue #15)
+// Rule: DisallowModule[Belt.List]
+
+// Caught: direct call with arguments
+let a = Belt.List.toArray(list{1, 2, 3})
+
+// Caught: pipe with extra arguments
+let b = list{1, 2, 3}->Belt.List.map(x => x + 1)
+
+// BUG: pipe with no extra arguments (should be caught)
+let c = list{1, 2, 3}->Belt.List.toArray
+
+// BUG: pipe with no extra arguments (should be caught)
+let d = list{1, 2, 3}->Belt.List.length

test/testData/disallow_module_test_7.res

@@ -0,0 +1,20 @@
+// Test that Pexp_apply scenarios (function calls) are still caught after Issue #15 fix
+// Rule: DisallowModule[Belt.List] + DisallowModule[Belt.Array]
+
+// 1. Direct call with single argument (Pexp_apply, Belt.List)
+let a = Belt.List.toArray(list{1, 2, 3})
+
+// 2. Direct call with multiple arguments (Pexp_apply, Belt.List)
+let b = Belt.List.has(list{1, 2, 3}, 1, (a, b) => a == b)
+
+// 3. Pipe with extra arguments (Pexp_apply, Belt.List)
+let c = list{1, 2, 3}->Belt.List.map(x => x + 1)
+
+// 4. Pipe with no extra arguments (Pexp_ident, Belt.List — was the bug)
+let d = list{1, 2, 3}->Belt.List.toArray
+
+// 5. Chained pipe: no-args into with-args (Belt.List missed + Belt.Array caught)
+let e = list{1, 2, 3}->Belt.List.toArray->Belt.Array.map(x => x)
+
+// 6. Nested calls (both inner and outer are Pexp_apply, Belt.List)
+let f = Belt.List.toArray(Belt.List.map(list{1, 2, 3}, x => x + 1))