Add definition checks for \ref and \iref

Author: eisenwave

source/intro.tex

@@ -326,8 +326,7 @@
 behavior, for a \termref{defns.well.formed}{well-formed program}{} construct and correct data, that
 depends on the implementation and that each implementation documents
 
-\definition{implementation-defined strict total order over pointers}
-{defns.order.ptr}
+\definition{implementation-defined strict total order over pointers}{defns.order.ptr}
 \indexdefn{pointer!strict total order}%
 \defncontext{library}
 \impldef{strict total order over pointer values}

tools/check-source.py

@@ -1700,26 +1700,78 @@ def __init__(
         self.definition_pattern = definition_pattern
         self.usage_pattern = usage_pattern
         self.defined: Set[str] = set()
-        self.used: Dict[str, List[Tuple[str, int]]] = defaultdict(list)
+        self.used: Dict[str, List[Tuple[str, int, int, int]]] = defaultdict(list)
 
     def check_line(self, line_num: int, line: str) -> None:
         for m in self.definition_pattern.finditer(line):
             self.defined.add(m.group(1))
         for pattern in self.usage_pattern:
             for m in pattern.finditer(line):
-                name = m.group(1)
-                self.used[name].append((os.path.relpath(self.file_path), line_num))
+                for name in m.group(1).split(","):
+                    name = name.strip()
+                    if not name or name.startswith("\\"):
+                        continue
+                    self.used[name].append(
+                        (
+                            os.path.relpath(self.file_path),
+                            line_num,
+                            m.start(1),
+                            m.end(1),
+                        )
+                    )
 
     def end_checks(self) -> None:
         for name, locations in sorted(self.used.items()):
             if name not in self.defined:
-                file_name, line_num = locations[0]
+                file_name, line_num, column_start, column_end = locations[0]
                 emit_check_failure(
                     self,
                     file_name,
                     line_num,
-                    0,
-                    0,
+                    column_start,
+                    column_end,
+                    f"`{name}` has no definition.",
+                )
+
+
+class RefUndefinedCheck(Check):
+    """Checks whether any uses of `\\ref` or `\\iref` are dangling."""
+
+    SECTION_PATTERN = re.compile(r"\\rSec[0-9]\[([^\]]+)\]")
+    DEFINITION_PATTERN = re.compile(r"\\definition\{[^\}]*?\}\{(.+?)\}")
+    ETC_PATTERN = re.compile(r"\\(?:infannex|normannex|label)\{(.+?)\}")
+    DEFINING_PATTERNS = [SECTION_PATTERN, DEFINITION_PATTERN, ETC_PATTERN]
+
+    # TODO: Excluding `:` means that `tab:...` references are currently unchecked.
+    #       Maybe that could be added in the future,
+    #       but there are lots of different kinds of tables that could be defining.
+    REF_IREF_PATTERN = re.compile(r"\\i?ref\{([^}\\:]+)\}")
+
+    def __init__(self, check_id: str):
+        self.id = check_id
+        self.defined: Set[str] = set()
+        self.used: Dict[str, List[Tuple[str, int, int, int]]] = defaultdict(list)
+
+    def check_line(self, line_num: int, line: str) -> None:
+        for defining_pattern in self.DEFINING_PATTERNS:
+            for m in defining_pattern.finditer(line):
+                self.defined.add(m.group(1))
+        for m in self.REF_IREF_PATTERN.finditer(line):
+            for usage in m.group(1).split(","):
+                self.used[usage.strip()].append(
+                    (os.path.relpath(self.file_path), line_num, m.start(1), m.end(1))
+                )
+
+    def end_checks(self) -> None:
+        for name, locations in sorted(self.used.items()):
+            if name not in self.defined:
+                file_name, line_num, column_start, column_end = locations[0]
+                emit_check_failure(
+                    self,
+                    file_name,
+                    line_num,
+                    column_start,
+                    column_end,
                     f"`{name}` has no definition.",
                 )
 
@@ -1895,6 +1947,7 @@ def end_checks(self) -> None:
     SubclausesWithoutSiblingsCheck("base-lonely-subclause"),
     UnknownCommandCheck("base-unknown-command"),
     SectionSelfReferenceCheck("base-self-ref"),
+    RefUndefinedCheck("base-ref-undef"),
     UseOfUndefinedCheck(
         "base-grammarterm-undef",
         definition_pattern=re.compile(r"\\nontermdef\{([^}]+)\}"),

tools/test-checks.tex

@@ -75,14 +75,14 @@
 \tcode{\exposid{kebak-case}}
 
 %EXPECTCHECKNEXTLINE(base-ref-in-parens)
-See the section.(\ref{some.label})
+See the section.(\ref{expr.const})
 %EXPECTCHECKNEXTLINE(base-ref-in-parens)
-Also see (\ref{other.label}) for details.
+Also see (\ref{expr.const}) for details.
 
 %EXPECTCHECKNEXTLINE(base-iref-location)
-\iref{some.label} at start of line.
+\iref{expr.const} at start of line.
 %EXPECTCHECKNEXTLINE(base-iref-location)
-See \iref{some.label} for details.
+See \iref{expr.const} for details.
 
 %EXPECTCHECKNEXTLINE(base-xrefc)
 ISO C 7.42.0 specifies this.
@@ -190,6 +190,9 @@
 %EXPECTCHECKNEXTLINE(base-self-ref)
 More text\iref{test.selfref2} there.
 
+%EXPECTCHECKNEXTLINE(base-ref-undef)
+\ref{lex.whatever}
+
 %EXPECTCHECKNEXTLINE(base-grammarterm-undef)
 \grammarterm{test-nonexistent-grammar-term}
 %EXPECTCHECKNEXTLINE(base-grammarterm-undef)