From 5b22ace770464c76f2dc28f428d438766e1f0af8 Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 09:53:39 +0100 Subject: [PATCH 01/12] light refactor. --- filecheckize/main.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/filecheckize/main.py b/filecheckize/main.py index 6c5714e..eb4e42e 100644 --- a/filecheckize/main.py +++ b/filecheckize/main.py @@ -7,6 +7,14 @@ from typing import cast +UNNAMED_SSA_VALUE = re.compile(r"%([\d]+)") +SSA_VALUE_NAME = re.compile(r"%([\d]+|[\w$._-][\w\d$._-]*)(:|#[\d]*)?") +BASIC_BLOCK_NAME = re.compile(r"\^([\d]+|[\w$._-][\w\d$._-]*)") + +ANONYMOUS_VARIABLE = r"%{{.*}}" +ANONYMOUS_BLOCK = r"^{{.*}}" + + def main(): parser = argparse.ArgumentParser( description="Generate the FileCheck lines that expects the given input." @@ -55,9 +63,6 @@ def main(): args = parser.parse_args(sys.argv[1:]) comment_line = re.compile(rf"^\s*{re.escape(args.comments_prefix)}.*$") - unnamed_ssa_value = re.compile(r"%([\d]+)") - ssa_value_name = re.compile(r"%([\d]+|[\w$._-][\w\d$._-]*)(:|#[\d]*)?") - basic_block_name = re.compile(r"\^([\d]+|[\w$._-][\w\d$._-]*)") prefix = args.check_prefix @@ -83,13 +88,13 @@ def main(): if args.mlir_anonymize or args.xdsl_anonymize: if args.mlir_anonymize: # Anonymize SSA value names - line = re.sub(ssa_value_name, r"%{{.*}}", line) + line = re.sub(SSA_VALUE_NAME, ANONYMOUS_VARIABLE, line) elif args.xdsl_anonymize: # Anonymize unnamed SSA values - line = re.sub(unnamed_ssa_value, r"%{{.*}}", line) + line = re.sub(UNNAMED_SSA_VALUE, ANONYMOUS_VARIABLE, line) # Anonymize basic blocks names - line = re.sub(basic_block_name, r"^{{.*}}", line) + line = re.sub(BASIC_BLOCK_NAME, ANONYMOUS_BLOCK, line) # Print the modified line if next: From 567020fdfce231dd555ae33feb7bcccc4beafc4a Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 10:08:01 +0100 Subject: [PATCH 02/12] Bump filecheck. --- requirements-optional.txt | 2 +- tests/filecheck/mlir.mlir | 16 ++++++++-------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/requirements-optional.txt b/requirements-optional.txt index 3e9cb3d..97915d5 100644 --- a/requirements-optional.txt +++ b/requirements-optional.txt @@ -1,7 +1,7 @@ black<24.5 toml<0.11 coverage -filecheck<0.025 +filecheck<=1.0 lit<18.2 ruff<0.5 isort<5.14 diff --git a/tests/filecheck/mlir.mlir b/tests/filecheck/mlir.mlir index b739c86..cc16e25 100644 --- a/tests/filecheck/mlir.mlir +++ b/tests/filecheck/mlir.mlir @@ -1,6 +1,6 @@ // RUN: filecheckize %s --strip-comments | filecheck %s --match-full-lines --check-prefix STRIP // RUN: filecheckize %s --strip-comments --check-empty-lines | filecheck %s --check-prefix WITH-EMPTY --match-full-lines -// RUN: filecheckize %s --strip-comments --mlir-anonymize | filecheck %s --check-prefix ANONYMIZE --match-full-lines +// RUN: filecheckize %s --strip-comments --mlir-anonymize | filecheck %s --check-prefix MLIR-ANONYMIZE --match-full-lines // RUN: filecheckize %s --strip-comments --xdsl-anonymize | filecheck %s --check-prefix XDSL-ANONYMIZE --match-full-lines func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { @@ -32,13 +32,13 @@ func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { // WITH-EMPTY-NEXT: // CHECK-EMPTY: // WITH-EMPTY-NEXT: // CHECK-EMPTY: -// ANONYMIZE: // CHECK: func.func @arg_rec(%{{.*}} : !test.type<"int">) -> !test.type<"int"> { -// ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = func.call @arg_rec(%{{.*}}) : (!test.type<"int">) -> !test.type<"int"> -// ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.constant : i32 -// ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.constant : i32 -// ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.addi %{{.*}}, %{{.*}} : i32 -// ANONYMIZE-NEXT: // CHECK-NEXT: func.return %{{.*}} : !test.type<"int"> -// ANONYMIZE-NEXT: // CHECK-NEXT: } +// MLIR-ANONYMIZE: // CHECK: func.func @arg_rec(%{{.*}} : !test.type<"int">) -> !test.type<"int"> { +// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = func.call @arg_rec(%{{.*}}) : (!test.type<"int">) -> !test.type<"int"> +// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.constant : i32 +// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.constant : i32 +// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.addi %{{.*}}, %{{.*}} : i32 +// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: func.return %{{.*}} : !test.type<"int"> +// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: } // XDSL-ANONYMIZE: // CHECK: func.func @arg_rec(%{{.*}} : !test.type<"int">) -> !test.type<"int"> { // XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = func.call @arg_rec(%{{.*}}) : (!test.type<"int">) -> !test.type<"int"> From 7db5a1fffd768d90d694174457d27aca07ff6547 Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 10:14:56 +0100 Subject: [PATCH 03/12] Factor out conditions in creating the right anonymization function. --- filecheckize/main.py | 58 +++++++++++++++++++++++++++++++++----------- 1 file changed, 44 insertions(+), 14 deletions(-) diff --git a/filecheckize/main.py b/filecheckize/main.py index eb4e42e..a19a6b0 100644 --- a/filecheckize/main.py +++ b/filecheckize/main.py @@ -37,6 +37,11 @@ def main(): action="store_true", help="Anonymize MLIR unnamed SSA values and basic block names.", ) + parser.add_argument( + "--substitute", + action="store_true", + help="Use variable substituion instead of anonymization.", + ) parser.add_argument( "--check-empty-lines", action="store_true", @@ -64,6 +69,41 @@ def main(): comment_line = re.compile(rf"^\s*{re.escape(args.comments_prefix)}.*$") + if args.strip_comments: + + def strip(line: str) -> bool: + return re.match(comment_line, line) + + else: + + def strip(line: str) -> bool: + return False + + if args.mlir_anonymize: + + def anonymize(line: str) -> str: + # Anonymize SSA value names + return re.sub( + BASIC_BLOCK_NAME, + ANONYMOUS_BLOCK, + re.sub(SSA_VALUE_NAME, ANONYMOUS_VARIABLE, line), + ) + + elif args.xdsl_anonymize: + + def anonymize(line: str) -> str: + # Anonymize unnamed SSA value names + return re.sub( + BASIC_BLOCK_NAME, + ANONYMOUS_BLOCK, + re.sub(UNNAMED_SSA_VALUE, ANONYMOUS_VARIABLE, line), + ) + + else: + + def anonymize(line: str) -> str: + return line + prefix = args.check_prefix next = False @@ -81,20 +121,10 @@ def main(): continue # Ignore remaining comment lines - if args.strip_comments: - if re.match(comment_line, line): - continue - - if args.mlir_anonymize or args.xdsl_anonymize: - if args.mlir_anonymize: - # Anonymize SSA value names - line = re.sub(SSA_VALUE_NAME, ANONYMOUS_VARIABLE, line) - elif args.xdsl_anonymize: - # Anonymize unnamed SSA values - line = re.sub(UNNAMED_SSA_VALUE, ANONYMOUS_VARIABLE, line) - - # Anonymize basic blocks names - line = re.sub(BASIC_BLOCK_NAME, ANONYMOUS_BLOCK, line) + if strip(line): + continue + + line = anonymize(line) # Print the modified line if next: From ec714e4ff7bb583ed7ead3de2830970527aff1ce Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 10:26:18 +0100 Subject: [PATCH 04/12] Add xDSL/MLIR substitution. --- filecheckize/main.py | 75 +++++++++++++++++++++++++++++++-------- tests/filecheck/mlir.mlir | 18 ++++++++++ 2 files changed, 79 insertions(+), 14 deletions(-) diff --git a/filecheckize/main.py b/filecheckize/main.py index a19a6b0..c0167d5 100644 --- a/filecheckize/main.py +++ b/filecheckize/main.py @@ -14,6 +14,23 @@ ANONYMOUS_VARIABLE = r"%{{.*}}" ANONYMOUS_BLOCK = r"^{{.*}}" +SUBSTITUTED_VARS = set[str]() +SUBSTITUTED_BLOCKS = set[str]() + + +def substitute_variable(var: str) -> str: + if var not in SUBSTITUTED_VARS: + SUBSTITUTED_VARS.add(var) + return f"[[%{var}:%.*]]" + return f"[[%{var}]]" + + +def substitute_block(block: str) -> str: + if block not in SUBSTITUTED_BLOCKS: + SUBSTITUTED_BLOCKS.add(block) + return f"[[^{block}:^.*]]" + return f"[[^{block}]]" + def main(): parser = argparse.ArgumentParser( @@ -81,23 +98,53 @@ def strip(line: str) -> bool: if args.mlir_anonymize: - def anonymize(line: str) -> str: - # Anonymize SSA value names - return re.sub( - BASIC_BLOCK_NAME, - ANONYMOUS_BLOCK, - re.sub(SSA_VALUE_NAME, ANONYMOUS_VARIABLE, line), - ) + if args.substitute: + + def anonymize(line: str) -> str: + # Anonymize SSA value names + return re.sub( + BASIC_BLOCK_NAME, + lambda m: substitute_block(m.group(1)), + re.sub( + SSA_VALUE_NAME, lambda m: substitute_variable(m.group(1)), line + ), + ) + + else: + + def anonymize(line: str) -> str: + # Anonymize SSA value names + return re.sub( + BASIC_BLOCK_NAME, + ANONYMOUS_BLOCK, + re.sub(SSA_VALUE_NAME, ANONYMOUS_VARIABLE, line), + ) elif args.xdsl_anonymize: - def anonymize(line: str) -> str: - # Anonymize unnamed SSA value names - return re.sub( - BASIC_BLOCK_NAME, - ANONYMOUS_BLOCK, - re.sub(UNNAMED_SSA_VALUE, ANONYMOUS_VARIABLE, line), - ) + if args.substitute: + + def anonymize(line: str) -> str: + # Anonymize SSA value names + return re.sub( + BASIC_BLOCK_NAME, + lambda m: substitute_block(m.group(1)), + re.sub( + UNNAMED_SSA_VALUE, + lambda m: substitute_variable(m.group(1)), + line, + ), + ) + + else: + + def anonymize(line: str) -> str: + # Anonymize SSA value names + return re.sub( + BASIC_BLOCK_NAME, + ANONYMOUS_BLOCK, + re.sub(UNNAMED_SSA_VALUE, ANONYMOUS_VARIABLE, line), + ) else: diff --git a/tests/filecheck/mlir.mlir b/tests/filecheck/mlir.mlir index cc16e25..943e9a8 100644 --- a/tests/filecheck/mlir.mlir +++ b/tests/filecheck/mlir.mlir @@ -1,7 +1,9 @@ // RUN: filecheckize %s --strip-comments | filecheck %s --match-full-lines --check-prefix STRIP // RUN: filecheckize %s --strip-comments --check-empty-lines | filecheck %s --check-prefix WITH-EMPTY --match-full-lines // RUN: filecheckize %s --strip-comments --mlir-anonymize | filecheck %s --check-prefix MLIR-ANONYMIZE --match-full-lines +// RUN: filecheckize %s --strip-comments --mlir-anonymize --substitute | filecheck %s --check-prefix MLIR-SUBSTITUTE --match-full-lines // RUN: filecheckize %s --strip-comments --xdsl-anonymize | filecheck %s --check-prefix XDSL-ANONYMIZE --match-full-lines +// RUN: filecheckize %s --strip-comments --xdsl-anonymize --substitute | filecheck %s --check-prefix XDSL-SUBSTITUTE --match-full-lines func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { %1 = func.call @arg_rec(%0) : (!test.type<"int">) -> !test.type<"int"> @@ -40,6 +42,14 @@ func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { // MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: func.return %{{.*}} : !test.type<"int"> // MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: } +// MLIR-SUBSTITUTE: // CHECK: func.func @arg_rec([[%0:%.*]] : !test.type<"int">) -> !test.type<"int"> { +// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%1:%.*]] = func.call @arg_rec([[%0]]) : (!test.type<"int">) -> !test.type<"int"> +// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%name:%.*]] = arith.constant : i32 +// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%other_name:%.*]] = arith.constant : i32 +// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%2:%.*]] = arith.addi [[%name]], [[%other_name]] : i32 +// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: func.return [[%1]] : !test.type<"int"> +// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: } + // XDSL-ANONYMIZE: // CHECK: func.func @arg_rec(%{{.*}} : !test.type<"int">) -> !test.type<"int"> { // XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = func.call @arg_rec(%{{.*}}) : (!test.type<"int">) -> !test.type<"int"> // XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: %name = arith.constant : i32 @@ -47,3 +57,11 @@ func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { // XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.addi %name, %other_name : i32 // XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: func.return %{{.*}} : !test.type<"int"> // XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: } + +// XDSL-SUBSTITUTE: // CHECK: func.func @arg_rec([[%0:%.*]] : !test.type<"int">) -> !test.type<"int"> { +// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%1:%.*]] = func.call @arg_rec([[%0]]) : (!test.type<"int">) -> !test.type<"int"> +// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: %name = arith.constant : i32 +// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: %other_name = arith.constant : i32 +// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%2:%.*]] = arith.addi %name, %other_name : i32 +// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: func.return [[%1]] : !test.type<"int"> +// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: } \ No newline at end of file From 0bb823d06bb60d66199edcbc866fc52e1ddeef8a Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 10:31:51 +0100 Subject: [PATCH 05/12] Add file split scoping for substituion --- filecheckize/main.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/filecheckize/main.py b/filecheckize/main.py index c0167d5..335ab91 100644 --- a/filecheckize/main.py +++ b/filecheckize/main.py @@ -167,6 +167,10 @@ def anonymize(line: str) -> str: next = False continue + elif "// -----" in line: + SUBSTITUTED_VARS.clear() + SUBSTITUTED_BLOCKS.clear() + # Ignore remaining comment lines if strip(line): continue From e65979eb41ba77b77c2d9415057879b8addcd151 Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 10:38:26 +0100 Subject: [PATCH 06/12] EOL --- tests/filecheck/mlir.mlir | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/filecheck/mlir.mlir b/tests/filecheck/mlir.mlir index 943e9a8..1e88d27 100644 --- a/tests/filecheck/mlir.mlir +++ b/tests/filecheck/mlir.mlir @@ -64,4 +64,4 @@ func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { // XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: %other_name = arith.constant : i32 // XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%2:%.*]] = arith.addi %name, %other_name : i32 // XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: func.return [[%1]] : !test.type<"int"> -// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: } \ No newline at end of file +// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: } From f40d0f2b344c2c29babf19044dceadaede2459d9 Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 10:42:40 +0100 Subject: [PATCH 07/12] ruff --- filecheckize/main.py | 1 - 1 file changed, 1 deletion(-) diff --git a/filecheckize/main.py b/filecheckize/main.py index 335ab91..35c3578 100644 --- a/filecheckize/main.py +++ b/filecheckize/main.py @@ -6,7 +6,6 @@ from io import TextIOWrapper from typing import cast - UNNAMED_SSA_VALUE = re.compile(r"%([\d]+)") SSA_VALUE_NAME = re.compile(r"%([\d]+|[\w$._-][\w\d$._-]*)(:|#[\d]*)?") BASIC_BLOCK_NAME = re.compile(r"\^([\d]+|[\w$._-][\w\d$._-]*)") From 60696efa653df8483f9ce131093a344beb8540bb Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 10:44:32 +0100 Subject: [PATCH 08/12] Pyright. --- filecheckize/main.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/filecheckize/main.py b/filecheckize/main.py index 35c3578..baf9ef3 100644 --- a/filecheckize/main.py +++ b/filecheckize/main.py @@ -88,7 +88,7 @@ def main(): if args.strip_comments: def strip(line: str) -> bool: - return re.match(comment_line, line) + return bool(re.match(comment_line, line)) else: From 2a03a379a131051b3596cc1e2ea5d3221a8fa4f0 Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 10:45:31 +0100 Subject: [PATCH 09/12] Pyright 3.7? --- filecheckize/main.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/filecheckize/main.py b/filecheckize/main.py index baf9ef3..ff3a924 100644 --- a/filecheckize/main.py +++ b/filecheckize/main.py @@ -13,8 +13,8 @@ ANONYMOUS_VARIABLE = r"%{{.*}}" ANONYMOUS_BLOCK = r"^{{.*}}" -SUBSTITUTED_VARS = set[str]() -SUBSTITUTED_BLOCKS = set[str]() +SUBSTITUTED_VARS: set[str] = set() +SUBSTITUTED_BLOCKS: set[str] = set() def substitute_variable(var: str) -> str: From 33e6543af9009dfd22c894928e22800d9ec9dc5e Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 10:46:41 +0100 Subject: [PATCH 10/12] . --- filecheckize/main.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/filecheckize/main.py b/filecheckize/main.py index ff3a924..e885314 100644 --- a/filecheckize/main.py +++ b/filecheckize/main.py @@ -13,8 +13,8 @@ ANONYMOUS_VARIABLE = r"%{{.*}}" ANONYMOUS_BLOCK = r"^{{.*}}" -SUBSTITUTED_VARS: set[str] = set() -SUBSTITUTED_BLOCKS: set[str] = set() +SUBSTITUTED_VARS: "set[str]" = set() +SUBSTITUTED_BLOCKS: "set[str]" = set() def substitute_variable(var: str) -> str: From c48f3b3b98fec14da3dd04d9678d524f3835c390 Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 10:49:28 +0100 Subject: [PATCH 11/12] Just bye 3.7. --- .github/workflows/ci-pyright-fails.yml | 2 +- .github/workflows/code-formatting.yml | 2 +- .github/workflows/tests.yml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci-pyright-fails.yml b/.github/workflows/ci-pyright-fails.yml index c6695ff..7e128bb 100644 --- a/.github/workflows/ci-pyright-fails.yml +++ b/.github/workflows/ci-pyright-fails.yml @@ -17,7 +17,7 @@ jobs: runs-on: ubuntu-20.04 strategy: matrix: - python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12'] + python-version: ['3.8', '3.9', '3.10', '3.11', '3.12'] env: PYRIGHT_VERSION: 1.0 diff --git a/.github/workflows/code-formatting.yml b/.github/workflows/code-formatting.yml index a0025ff..1859f75 100644 --- a/.github/workflows/code-formatting.yml +++ b/.github/workflows/code-formatting.yml @@ -20,7 +20,7 @@ jobs: runs-on: ubuntu-20.04 strategy: matrix: - python-version: ['3.7', '3.8', '3.9', '3.10', '3.11'] + python-version: ['3.8', '3.9', '3.10', '3.11'] steps: - uses: actions/checkout@v3 diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 662021d..f24122c 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -16,7 +16,7 @@ jobs: runs-on: ubuntu-20.04 strategy: matrix: - python-version: ['3.7', '3.8', '3.9', '3.10', '3.11'] + python-version: ['3.8', '3.9', '3.10', '3.11'] steps: - uses: actions/checkout@v3 From 74c700a5e20406d108884d5a6b6203eb477c2b8b Mon Sep 17 00:00:00 2001 From: Emilien Bauer Date: Tue, 30 Jul 2024 11:15:44 +0100 Subject: [PATCH 12/12] Literal filecheck. --- filecheckize/main.py | 8 ++-- tests/filecheck/mlir.mlir | 94 +++++++++++++++++++-------------------- 2 files changed, 51 insertions(+), 51 deletions(-) diff --git a/filecheckize/main.py b/filecheckize/main.py index e885314..aed9dcc 100644 --- a/filecheckize/main.py +++ b/filecheckize/main.py @@ -20,15 +20,15 @@ def substitute_variable(var: str) -> str: if var not in SUBSTITUTED_VARS: SUBSTITUTED_VARS.add(var) - return f"[[%{var}:%.*]]" - return f"[[%{var}]]" + return f"[[v{var}:%.*]]" + return f"[[v{var}]]" def substitute_block(block: str) -> str: if block not in SUBSTITUTED_BLOCKS: SUBSTITUTED_BLOCKS.add(block) - return f"[[^{block}:^.*]]" - return f"[[^{block}]]" + return f"[[b{block}:^.*]]" + return f"[[b{block}]]" def main(): diff --git a/tests/filecheck/mlir.mlir b/tests/filecheck/mlir.mlir index 1e88d27..85d8bc4 100644 --- a/tests/filecheck/mlir.mlir +++ b/tests/filecheck/mlir.mlir @@ -13,55 +13,55 @@ func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { func.return %1 : !test.type<"int"> } -// STRIP: // CHECK: func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { -// STRIP-NEXT: // CHECK-NEXT: %1 = func.call @arg_rec(%0) : (!test.type<"int">) -> !test.type<"int"> -// STRIP-NEXT: // CHECK-NEXT: %name = arith.constant : i32 -// STRIP-NEXT: // CHECK-NEXT: %other_name = arith.constant : i32 -// STRIP-NEXT: // CHECK-NEXT: %2 = arith.addi %name, %other_name : i32 -// STRIP-NEXT: // CHECK-NEXT: func.return %1 : !test.type<"int"> -// STRIP-NEXT: // CHECK-NEXT: } +// STRIP{LITERAL}: // CHECK: func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { +// STRIP-NEXT{LITERAL}: // CHECK-NEXT: %1 = func.call @arg_rec(%0) : (!test.type<"int">) -> !test.type<"int"> +// STRIP-NEXT{LITERAL}: // CHECK-NEXT: %name = arith.constant : i32 +// STRIP-NEXT{LITERAL}: // CHECK-NEXT: %other_name = arith.constant : i32 +// STRIP-NEXT{LITERAL}: // CHECK-NEXT: %2 = arith.addi %name, %other_name : i32 +// STRIP-NEXT{LITERAL}: // CHECK-NEXT: func.return %1 : !test.type<"int"> +// STRIP-NEXT{LITERAL}: // CHECK-NEXT: } -// WITH-EMPTY: // CHECK-EMPTY: -// WITH-EMPTY-NEXT: // CHECK-NEXT: func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { -// WITH-EMPTY-NEXT: // CHECK-NEXT: %1 = func.call @arg_rec(%0) : (!test.type<"int">) -> !test.type<"int"> -// WITH-EMPTY-NEXT: // CHECK-NEXT: %name = arith.constant : i32 -// WITH-EMPTY-NEXT: // CHECK-NEXT: %other_name = arith.constant : i32 -// WITH-EMPTY-NEXT: // CHECK-NEXT: %2 = arith.addi %name, %other_name : i32 -// WITH-EMPTY-NEXT: // CHECK-NEXT: func.return %1 : !test.type<"int"> -// WITH-EMPTY-NEXT: // CHECK-NEXT: } -// WITH-EMPTY-NEXT: // CHECK-EMPTY: -// WITH-EMPTY-NEXT: // CHECK-EMPTY: -// WITH-EMPTY-NEXT: // CHECK-EMPTY: -// WITH-EMPTY-NEXT: // CHECK-EMPTY: +// WITH-EMPTY{LITERAL}: // CHECK-EMPTY: +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-NEXT: func.func @arg_rec(%0 : !test.type<"int">) -> !test.type<"int"> { +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-NEXT: %1 = func.call @arg_rec(%0) : (!test.type<"int">) -> !test.type<"int"> +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-NEXT: %name = arith.constant : i32 +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-NEXT: %other_name = arith.constant : i32 +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-NEXT: %2 = arith.addi %name, %other_name : i32 +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-NEXT: func.return %1 : !test.type<"int"> +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-NEXT: } +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-EMPTY: +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-EMPTY: +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-EMPTY: +// WITH-EMPTY-NEXT{LITERAL}: // CHECK-EMPTY: -// MLIR-ANONYMIZE: // CHECK: func.func @arg_rec(%{{.*}} : !test.type<"int">) -> !test.type<"int"> { -// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = func.call @arg_rec(%{{.*}}) : (!test.type<"int">) -> !test.type<"int"> -// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.constant : i32 -// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.constant : i32 -// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.addi %{{.*}}, %{{.*}} : i32 -// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: func.return %{{.*}} : !test.type<"int"> -// MLIR-ANONYMIZE-NEXT: // CHECK-NEXT: } +// MLIR-ANONYMIZE{LITERAL}: // CHECK: func.func @arg_rec(%{{.*}} : !test.type<"int">) -> !test.type<"int"> { +// MLIR-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: %{{.*}} = func.call @arg_rec(%{{.*}}) : (!test.type<"int">) -> !test.type<"int"> +// MLIR-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: %{{.*}} = arith.constant : i32 +// MLIR-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: %{{.*}} = arith.constant : i32 +// MLIR-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: %{{.*}} = arith.addi %{{.*}}, %{{.*}} : i32 +// MLIR-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: func.return %{{.*}} : !test.type<"int"> +// MLIR-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: } -// MLIR-SUBSTITUTE: // CHECK: func.func @arg_rec([[%0:%.*]] : !test.type<"int">) -> !test.type<"int"> { -// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%1:%.*]] = func.call @arg_rec([[%0]]) : (!test.type<"int">) -> !test.type<"int"> -// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%name:%.*]] = arith.constant : i32 -// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%other_name:%.*]] = arith.constant : i32 -// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%2:%.*]] = arith.addi [[%name]], [[%other_name]] : i32 -// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: func.return [[%1]] : !test.type<"int"> -// MLIR-SUBSTITUTE-NEXT: // CHECK-NEXT: } +// MLIR-SUBSTITUTE{LITERAL}: // CHECK: func.func @arg_rec([[v0:%.*]] : !test.type<"int">) -> !test.type<"int"> { +// MLIR-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: [[v1:%.*]] = func.call @arg_rec([[v0]]) : (!test.type<"int">) -> !test.type<"int"> +// MLIR-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: [[vname:%.*]] = arith.constant : i32 +// MLIR-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: [[vother_name:%.*]] = arith.constant : i32 +// MLIR-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: [[v2:%.*]] = arith.addi [[vname]], [[vother_name]] : i32 +// MLIR-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: func.return [[v1]] : !test.type<"int"> +// MLIR-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: } -// XDSL-ANONYMIZE: // CHECK: func.func @arg_rec(%{{.*}} : !test.type<"int">) -> !test.type<"int"> { -// XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = func.call @arg_rec(%{{.*}}) : (!test.type<"int">) -> !test.type<"int"> -// XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: %name = arith.constant : i32 -// XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: %other_name = arith.constant : i32 -// XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: %{{.*}} = arith.addi %name, %other_name : i32 -// XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: func.return %{{.*}} : !test.type<"int"> -// XDSL-ANONYMIZE-NEXT: // CHECK-NEXT: } +// XDSL-ANONYMIZE{LITERAL}: // CHECK: func.func @arg_rec(%{{.*}} : !test.type<"int">) -> !test.type<"int"> { +// XDSL-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: %{{.*}} = func.call @arg_rec(%{{.*}}) : (!test.type<"int">) -> !test.type<"int"> +// XDSL-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: %name = arith.constant : i32 +// XDSL-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: %other_name = arith.constant : i32 +// XDSL-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: %{{.*}} = arith.addi %name, %other_name : i32 +// XDSL-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: func.return %{{.*}} : !test.type<"int"> +// XDSL-ANONYMIZE-NEXT{LITERAL}: // CHECK-NEXT: } -// XDSL-SUBSTITUTE: // CHECK: func.func @arg_rec([[%0:%.*]] : !test.type<"int">) -> !test.type<"int"> { -// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%1:%.*]] = func.call @arg_rec([[%0]]) : (!test.type<"int">) -> !test.type<"int"> -// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: %name = arith.constant : i32 -// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: %other_name = arith.constant : i32 -// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: [[%2:%.*]] = arith.addi %name, %other_name : i32 -// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: func.return [[%1]] : !test.type<"int"> -// XDSL-SUBSTITUTE-NEXT: // CHECK-NEXT: } +// XDSL-SUBSTITUTE{LITERAL}: // CHECK: func.func @arg_rec([[v0:%.*]] : !test.type<"int">) -> !test.type<"int"> { +// XDSL-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: [[v1:%.*]] = func.call @arg_rec([[v0]]) : (!test.type<"int">) -> !test.type<"int"> +// XDSL-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: %name = arith.constant : i32 +// XDSL-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: %other_name = arith.constant : i32 +// XDSL-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: [[v2:%.*]] = arith.addi %name, %other_name : i32 +// XDSL-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: func.return [[v1]] : !test.type<"int"> +// XDSL-SUBSTITUTE-NEXT{LITERAL}: // CHECK-NEXT: }