Datasets:
Tasks:
Text Classification
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
Tags:
code-review
defect-detection
software-engineering
label-noise
uncertainty-quantification
python
License:
| """Maps marked lines of a change to the syntax nodes of N(c). | |
| Copied verbatim from the pipeline's ``benchmark.localization.projection`` so CoReDD | |
| lifts predicted lines to the exact same syntax nodes the ground truth was built with. | |
| The only change is the ``VersionControl`` dependency: here it is a structural type | |
| satisfied by :class:`coredd.history.GitRepository` (``parents``/``diff``/``blob``), not the | |
| pipeline's cloud-backed class. | |
| """ | |
| from __future__ import annotations | |
| from dataclasses import dataclass | |
| from typing import Protocol | |
| from tree_sitter_language_pack import get_parser | |
| class VersionControl(Protocol): | |
| """The three git operations :class:`NodeProjection` needs of a repository.""" | |
| def parents(self, commit: str) -> list[str]: ... | |
| def diff(self, base: str, commit: str, *, context: int = 1): ... | |
| def blob(self, commit: str, path: str) -> bytes: ... | |
| class SyntaxNode: | |
| """A syntax node of N(c), identified within the base tree of a change. | |
| The identity is the span and type in the base file, so the same node reached | |
| from several marked lines deduplicates to one entry. The type is retained | |
| because it enters the audit statistics over N(c). | |
| """ | |
| path: str | |
| start: tuple[int, int] | |
| end: tuple[int, int] | |
| type: str | |
| class NodeProjection: | |
| """Maps marked lines of a change to the syntax nodes of N(c). | |
| N(c) is defined over the abstract syntax tree of the change's parent | |
| (\\autoref{section:measurement-framework}): a deletion or update references the | |
| affected parent node, an insertion the parent node at its position. The | |
| localization stage emits lines, so this projection supplies the deterministic | |
| line-to-node mapping that stage leaves implicit. | |
| A base line is already a parent-side coordinate. An after line is carried back | |
| through the diff by the line-level correspondence git reports: a context line | |
| maps to its recorded base line, while an inserted line has no base counterpart | |
| and instead resolves to the node the parent already had between the two base | |
| lines the insertion sits between -- their common enclosing node. | |
| """ | |
| def __init__(self, repository: VersionControl) -> None: | |
| self._repository = repository | |
| self._trees: dict[tuple[str, str], object] = {} | |
| self._sources: dict[tuple[str, str], tuple[str, ...]] = {} | |
| self._maps: dict[tuple[str, str], dict[str, dict[int, int]]] = {} | |
| self._parser = get_parser("python") | |
| def project(self, commit: str, path: str, line: int, side: str) -> SyntaxNode | None: | |
| """Return the node in N(commit) a single marked line lifts to. | |
| None when the file is not Python, does not parse, or the line maps to no | |
| named node (a blank line or comment). The caller counts these separately. | |
| """ | |
| if not path.endswith(".py"): | |
| return None | |
| base = self._base(commit) | |
| # A base line is already a parent-side coordinate. An after line anchors in | |
| # the parent tree when the file existed there; when the change adds the file | |
| # its parent has no such node, so the change's own tree carries it. | |
| if side == "base" and base is not None: | |
| return self._lift(base, path, (line, line)) | |
| if base is not None and self._blob(base, path) is not None: | |
| span = self._rebase(base, commit, path, line) | |
| return self._lift(base, path, span) if span is not None else None | |
| return self._lift(commit, path, (line, line)) | |
| def _base(self, commit: str) -> str | None: | |
| parents = self._repository.parents(commit) | |
| return parents[0] if parents else None | |
| def _rebase( | |
| self, base: str, commit: str, path: str, line: int | |
| ) -> tuple[int, int] | None: | |
| """The base-side span an after-side marking resolves to. | |
| A context line carries its recorded base line, returned as a one-line span. | |
| An inserted line has no base line, so it returns the span between the two | |
| base lines it sits between, whose common enclosing node is the parent it | |
| was inserted into. An insertion before or after all context falls back to | |
| the file bounds. | |
| """ | |
| correspondence = self._correspondence(base, commit, path) | |
| if line in correspondence: | |
| base_line = correspondence[line] | |
| return (base_line, base_line) | |
| before = [after for after in correspondence if after < line] | |
| after = [other for other in correspondence if other > line] | |
| lower = correspondence[max(before)] if before else 1 | |
| upper = correspondence[min(after)] if after else len(self._source(base, path)) | |
| return (lower, upper) | |
| def _correspondence(self, base: str, commit: str, path: str) -> dict[int, int]: | |
| """The after-line to base-line map git reports for the context lines of a | |
| file, the lines present unchanged on both sides.""" | |
| key = (base, commit) | |
| if key not in self._maps: | |
| files: dict[str, dict[int, int]] = {} | |
| for patch in self._repository.diff(base, commit, context=1): | |
| target = patch.delta.new_file.path | |
| lines = files.setdefault(target, {}) | |
| for hunk in patch.hunks: | |
| for entry in hunk.lines: | |
| if entry.origin == " ": | |
| lines[entry.new_lineno] = entry.old_lineno | |
| self._maps[key] = files | |
| return self._maps[key].get(path, {}) | |
| def _lift( | |
| self, commit: str, path: str, span: tuple[int, int] | |
| ) -> SyntaxNode | None: | |
| root = self._tree(commit, path) | |
| lines = self._source(commit, path) | |
| lower, upper = span | |
| if root is None or lower <= 0 or upper > len(lines) or lower > upper: | |
| return None | |
| if lower == upper and lines[lower - 1].strip() == "": | |
| return None | |
| column = len(lines[lower - 1]) - len(lines[lower - 1].lstrip()) | |
| if lower == upper: | |
| # A single line: descend to the innermost named node on it, then lift | |
| # one level to the node that owns it. | |
| node = root.descendant_for_point_range( | |
| (lower - 1, column), (lower - 1, column) | |
| ) | |
| while node is not None and not getattr(node, "is_named", False): | |
| node = node.parent | |
| owner = node.parent if node is not None and node.parent is not None else node | |
| else: | |
| # A span between two base lines: the smallest node covering it already | |
| # is the common enclosing node, so it is taken as is. | |
| owner = root.descendant_for_point_range((lower - 1, column), (upper - 1, 0)) | |
| while owner is not None and not getattr(owner, "is_named", False): | |
| owner = owner.parent | |
| if owner is None: | |
| return None | |
| return SyntaxNode( | |
| path=path, | |
| start=(owner.start_point[0] + 1, owner.start_point[1]), | |
| end=(owner.end_point[0] + 1, owner.end_point[1]), | |
| type=str(owner.type), | |
| ) | |
| def _tree(self, commit: str, path: str) -> object | None: | |
| key = (commit, path) | |
| if key not in self._trees: | |
| source = self._blob(commit, path) | |
| if source is None: | |
| self._trees[key] = None | |
| self._sources[key] = () | |
| else: | |
| self._trees[key] = self._parser.parse(source).root_node | |
| self._sources[key] = tuple(source.decode("utf-8", "ignore").splitlines()) | |
| return self._trees[key] | |
| def _source(self, commit: str, path: str) -> tuple[str, ...]: | |
| self._tree(commit, path) | |
| return self._sources.get((commit, path), ()) | |
| def _blob(self, commit: str, path: str) -> bytes | None: | |
| try: | |
| return self._repository.blob(commit, path) | |
| except (KeyError, ValueError, FileNotFoundError): | |
| return None | |