| #!/usr/bin/env python3 | |
| """Replaces absolute line numbers in lit-tests with relative line numbers. | |
| Writing line numbers like 152 in 'RUN: or CHECK:' makes tests hard to maintain: | |
| inserting lines in the middle of the test means updating all the line numbers. | |
| Encoding them relative to the current line helps, and tools support it: | |
| Lit will substitute %(line+2) with the actual line number | |
| FileCheck supports [[@LINE+2]] | |
| This tool takes a regex which captures a line number, and a list of test files. | |
| It searches for line numbers in the files and replaces them with a relative | |
| line number reference. | |
| """ | |
| USAGE = """Example usage: | |
| find -type f clang/test/CodeCompletion | grep -v /Inputs/ | \\ | |
| xargs relative_lines.py --dry-run --verbose --near=100 \\ | |
| --pattern='-code-completion-at[ =]%s:(\d+)' \\ | |
| --pattern='requires fix-it: {(\d+):\d+-(\d+):\d+}' | |
| """ | |
| import argparse | |
| import re | |
| import sys | |
| def b(x): | |
| return bytes(x, encoding="utf-8") | |
| parser = argparse.ArgumentParser( | |
| prog="relative_lines", | |
| description=__doc__, | |
| epilog=USAGE, | |
| formatter_class=argparse.RawTextHelpFormatter, | |
| ) | |
| parser.add_argument( | |
| "--near", type=int, default=20, help="maximum line distance to make relative" | |
| ) | |
| parser.add_argument( | |
| "--partial", | |
| action="store_true", | |
| default=False, | |
| help="apply replacements to files even if others failed", | |
| ) | |
| parser.add_argument( | |
| "--pattern", | |
| default=[], | |
| action="append", | |
| type=lambda x: re.compile(b(x)), | |
| help="regex to match, with line numbers captured in ().", | |
| ) | |
| parser.add_argument( | |
| "--verbose", action="store_true", default=False, help="print matches applied" | |
| ) | |
| parser.add_argument( | |
| "--dry-run", | |
| action="store_true", | |
| default=False, | |
| help="don't apply replacements. Best with --verbose.", | |
| ) | |
| parser.add_argument("files", nargs="+") | |
| args = parser.parse_args() | |
| for file in args.files: | |
| try: | |
| contents = open(file, "rb").read() | |
| except UnicodeDecodeError as e: | |
| print(f"{file}: not valid UTF-8 - {e}", file=sys.stderr) | |
| failures = 0 | |
| def line_number(offset): | |
| return 1 + contents[:offset].count(b"\n") | |
| def replace_one(capture, line, offset): | |
| """Text to replace a capture group, e.g. 42 => %(line+1)""" | |
| try: | |
| target = int(capture) | |
| except ValueError: | |
| print(f"{file}:{line}: matched non-number '{capture}'", file=sys.stderr) | |
| return capture | |
| if args.near > 0 and abs(target - line) > args.near: | |
| print( | |
| f"{file}:{line}: target line {target} is farther than {args.near}", | |
| file=sys.stderr, | |
| ) | |
| return capture | |
| if target > line: | |
| delta = "+" + str(target - line) | |
| elif target < line: | |
| delta = "-" + str(line - target) | |
| else: | |
| delta = "" | |
| prefix = contents[:offset].rsplit(b"\n")[-1] | |
| is_lit = b"RUN" in prefix or b"DEFINE" in prefix | |
| text = ("%(line{0})" if is_lit else "[[@LINE{0}]]").format(delta) | |
| if args.verbose: | |
| print(f"{file}:{line}: {0} ==> {text}") | |
| return b(text) | |
| def replace_match(m): | |
| """Text to replace a whole match, e.g. --at=42:3 => --at=%(line+2):3""" | |
| line = 1 + contents[: m.start()].count(b"\n") | |
| result = b"" | |
| pos = m.start() | |
| for index, capture in enumerate(m.groups()): | |
| index += 1 # re groups are conventionally 1-indexed | |
| result += contents[pos : m.start(index)] | |
| replacement = replace_one(capture, line, m.start(index)) | |
| result += replacement | |
| if replacement == capture: | |
| global failures | |
| failures += 1 | |
| pos = m.end(index) | |
| result += contents[pos : m.end()] | |
| return result | |
| for pattern in args.pattern: | |
| contents = re.sub(pattern, replace_match, contents) | |
| if failures > 0 and not args.partial: | |
| print(f"{file}: leaving unchanged (some failed, --partial not given)") | |
| continue | |
| if not args.dry_run: | |
| open(file, "wb").write(contents) |