1	# rule noqa: a noqa comment (src/noqa.bend) that silences nothing, as
2	# ruff's RUF100. A bare one names no code, so it silences nothing; a code
3	# it names silences nothing when no graded finding of the file, on the
4	# mark's line, has that code, and a code that is no rule's never does. One
5	# finding for a bare mark, and one for each such code, at the comment.
6	#
7	# It reads the graded findings of the whole run, so it is no per-file rule:
8	# the planner runs it after every other rule and after the filter, and
9	# what it reports no noqa comment silences. A project rule's code
10	# (`coverage`) is judged only when the run is the whole
11	# tree (`whole`): over files named, and in the editor, those rules see only
12	# part of the laws, so their silence proves nothing.
13	import Base
14	import ../../lazy/lazy.bend as Lazy
15	import ../../finding.bend as F
16	import ../../codes.bend as Codes
17	import ../../noqa.bend as Noqa
18	
19	# a project rule's code
20	def project(+code: String) -> Bool:
21	  String.eq(code, Codes.code("coverage"))
22	
23	# a code this run can judge: any, over the whole tree; a per-file rule's
24	# (or no rule's) otherwise
25	def judged(+whole: Bool, +code: String) -> Bool:
26	  Lazy.or_else(whole, _u => Bool.not(project(code)))
27	
28	# some row of the table has the code
29	def known.in(rows: List<&2, Codes.Entry>, +code: String) -> Bool:
30	  match rows:
31	    case Nil{}:
32	      False{}
33	    case Con{Codes.Entry{_s, id, _grp}, rest}:
34	      Lazy.or_else(String.eq(id, code), _u => known.in(rest, code))
35	
36	# the code is a rule's
37	def known(+code: String) -> Bool:
38	  known.in(Codes.table(), code)
39	
40	# a graded finding at the path, on the line, has the code
41	def used(gs: List<&2, F.Graded>, +path: String, +line: U32, +code: String) -> Bool:
42	  match gs:
43	    case Nil{}:
44	      False{}
45	    case Con{F.Graded{_ll, F.Finding{p, l, _col, _len, rule, _msg}}, rest}:
46	      Lazy.or_else(
47	        Lazy.and_then(String.eq(p, path),
48	          _u => Lazy.and_then(U32.is_eq(l, line), _v => String.eq(Codes.code(rule), code))),
49	        _w => used(rest, path, line, code))
50	
51	# what a bare mark is told
52	def say.bare() -> String:
53	  "`# noqa` names no code, so it silences nothing; name the codes, e.g. `# noqa: L001`."
54	
55	# what an unused code is told: a rule's, or no rule's
56	def say(+code: String) -> String:
57	  Bool.pick(String, known(code), "`# noqa: " ++ code ++ "` silences nothing on this line.",
58	    "`# noqa: " ++ code ++ "` is no rule's code, so it silences nothing.")
59	
60	# one finding for each code judged here that silences nothing on its line
61	def check.codes(
62	  cs: List<&2, String>,
63	  +whole: Bool,
64	  +path: String,
65	  +line: U32,
66	  +col: U32,
67	  +len: U32,
68	  +gs: List<&2, F.Graded>
69	) -> List<&2, F.Finding>:
70	  match cs:
71	    case Nil{}:
72	      Nil{}
73	    case Con{+c, rest}:
74	      +more = check.codes(rest, whole, path, line, col, len, gs)
75	      +bad = Lazy.and_then(judged(whole, c), _u => Bool.not(used(gs, path, line, c)))
76	      +msg = say(c)
77	      Bool.pick(List<&2, F.Finding>, bad, F.Finding{path, line, col, len, "noqa", msg} <> more, more)
78	
79	# a mark's findings: one when it is bare, else one per code that silences
80	# nothing
81	def check.mark(mk: Noqa.Mark, +whole: Bool, +path: String, +gs: List<&2, F.Graded>) -> List<&2, F.Finding>:
82	  match mk:
83	    case Noqa.Mark{line, col, len, Nil{}}:
84	      [F.Finding{path, line, col, len, "noqa", say.bare()}]
85	    case Noqa.Mark{line, col, len, Con{c, rest}}:
86	      check.codes(c <> rest, whole, path, line, col, len, gs)
87	
88	# every mark of the file at the path, against the run's graded findings
89	def check(mks: List<&2, Noqa.Mark>, +whole: Bool, +path: String, +gs: List<&2, F.Graded>) -> List<&2, F.Finding>:
90	  match mks:
91	    case Nil{}:
92	      Nil{}
93	    case Con{mk, rest}:
94	      List.append(&2, F.Finding, check.mark(mk, whole, path, gs), check(rest, whole, path, gs))