tree-sitter-mlir: contribute a more complete grammar.js

[artagnon]

Summary

Contribute a grammar.js from the upstream project maintained at
https://github.com/artagnon/tree-sitter-mlir. The new grammar.js
includes several fixes, and successfully parses 60-80% of MLIR tests in
the Arith, Tensor, and Linalg dialects.

[artagnon]

Update; format with git-clang-format

[rriddle]

Something that doesn't seem great about this approach is the need for every operation of every dialect to have an explicit entry. For MLIR that severely limits the situations that the grammar can be useful (effectively no downstream user can benefit), and is also hard to maintain, is there not a more generic fuzzy approach that gets us the correct highlighting most of the time (similarly to the textmate grammar)? @jpienaar

mlir/utils/tree-sitter-mlir/README.md

9–10

we shouldn't be referencing an external project for this, I'd rather have everything necessary in-tree.

[artagnon]

In D144408#4144964, @rriddle wrote:

Something that doesn't seem great about this approach is the need for every operation of every dialect to have an explicit entry. For MLIR that severely limits the situations that the grammar can be useful (effectively no downstream user can benefit), and is also hard to maintain, is there not a more generic fuzzy approach that gets us the correct highlighting most of the time (similarly to the textmate grammar)? @jpienaar

Every operation of every dialect has a custom syntax, and as far as I can tell, there is very little that is common between the syntaxes. A fuzzy approach would essentially entail a very permissive parser, but even if we match custom_operation with /[a-z.]/, I find myself at a loss when having to define its fields. Downstream users won't benefit from the custom_operation section, as those will be ERROR nodes; however, they would still benefit from tree-sitter error-recovery and highlighting the types, literals, attributes etc. correctly, which would be on-par with a hypothetical fuzzy grammar. Textmate grammars are very slow, since they rely on regexp matching, and only VSCode currently uses them: both NVim and Emacs have recently merged their respective tree-sitter features.

While I agree that a complete grammar.js using this approach is a significant time investment, I don't think this grammar is particularly hard to maintain. When a new custom_operation is added, users will automatically see that it is not being highlighted; then, it's just a matter of adding an entry to the custom_operation table. Moreover, I have a small script to bench grammar.js against the .mlir files in test/Dialect/, and we could even add this to the CI to avoid regressions.

[artagnon]

mlir/utils/tree-sitter-mlir/README.md

9–10

I agree with this. I'll prepare a patch checking in everything from the external project in-tree.

[artagnon]

Don't reference external project; check in complete project.

[mehdi_amini]

Another approach would be to generate this from ODS declarative assembly syntax, any obstacle to this?

[artagnon]

In D144408#4145211, @mehdi_amini wrote:

Another approach would be to generate this from ODS declarative assembly syntax, any obstacle to this?

Indeed, this is a very good idea; it will work for 70-80% of custom operations: we'd have to include the mlir-tblgen headers, and write something that processes all the .td files in one go, and spit out the custom_operation section of grammar.js, by looking at the assemblyFormat of defs. However, we'd have to rely on hand-written parsers for those defs that have customAssemblyFormat. I can try to attack this problem over the coming days, as a follow-up patch.

[jpienaar]

When I did the first version I was using this as I wanted to run some analysis tool that uses tree-sitter (that didn't work well) and also to check the language guide a bit using the error checks in tree-sitter generation process. Generation would be really nice, and from maintenance point of view (and we know these may go out of sync, so it would be best effort). Could you perhaps show the before and after of how it affects highlighting? Esp with an unsupported dialect too, to speak to the fuzzing matching part.

mlir/utils/tree-sitter-mlir/grammar.js

463

Could we utilize modules here to have these be in separate files?

[artagnon]

In D144408#4145827, @jpienaar wrote:

When I did the first version I was using this as I wanted to run some analysis tool that uses tree-sitter (that didn't work well) and also to check the language guide a bit using the error checks in tree-sitter generation process. Generation would be really nice, and from maintenance point of view (and we know these may go out of sync, so it would be best effort). Could you perhaps show the before and after of how it affects highlighting? Esp with an unsupported dialect too, to speak to the fuzzing matching part.

Actually, I found that the tree-sitter error recovery algorithm is quite rudimentary at the moment, and there is nothing we can do as a grammar-author to get better error-recovery. Here's a comparison of how a supported dialect highlights versus how a downstream dialect highlights.

After some digging, I'm not feeling terribly optimistic about auto-generation, since customAssemblyFormat seems to be the norm for any operation with a non-trivial assembly format. I'm going to attempt auto-generation of grammar for dialects like Arith and Math as a follow-up, but for Linalg, ControlFlow, SCF, and the like, we have to rely on hand-written parsers.

mlir/utils/tree-sitter-mlir/grammar.js

463

It turns out that tree-sitter doesn't support ESM modules, but I found a way to split the grammar up into multiple files nevertheless. Will post an updated diff shortly.

[artagnon]

• Split up dialect grammars into separate files
• Include highlighting test for downstream dialect

[jpienaar]

I see on the screenshot for unknown dialects it treats everything as unknown (e.g., memref not identified). That's more conservative (only show what you know) but might be worse for highlighting. Do you know if this is intrinsic to tree-sitter or the way the grammar is written? (It was written directly matching our markdown/uses to fix markdown, with explicit structure in mind).

[artagnon]

The poor error recovery is intrinsic to tree-sitter, and there is nothing we can do as a grammar author to improve it. I found a couple of issues related to this here and here.

[artagnon]

Ping.

[jpienaar]

This is very thorough, which is both good and bad. Maintaining these won't be on many folks minds or knowledge set. The other highlighting support we have here is much simpler (they are approximate, they only attempt to work well enough). So this has me a bit in two minds. As long as we don't make it required or increase maintenance demands, that seems fine (and we can revise if not).

mlir/utils/tree-sitter-mlir/bench.mjs

9 ↗

(On Diff #499822)

Why is this needed?

mlir/utils/tree-sitter-mlir/dialect/linalg.js

7

Could we just do something like linalg.[a-z_]* ? (this list on named ops keep on growing but I think the assembly format is all similar)

[artagnon]

mlir/utils/tree-sitter-mlir/bench.mjs

9 ↗

(On Diff #499822)

So we can benchmark against test-suite in supported dialects, and notify contributors when coverage drops. We can't possibly write tests for everything: the tests are extracted from the test-suite anyway.

mlir/utils/tree-sitter-mlir/dialect/linalg.js

7

The issue is overlap with linalg.index, linalg.map, and linalg.yield, which have a different parse-rule. I agree that it's not ideal to maintain this list, but I don't see a way out, unless we make the parser overly permissive to all linalg operations.

[jpienaar]

mlir/utils/tree-sitter-mlir/bench.mjs

9 ↗

(On Diff #499822)

As long as optional and expectation is clear.

I don't particularly like serializing the results of a benchmark run here vs in some dashboard. E.g., some repo with GitHub action that checks out llvm and runs/tracks these over time would cause less churn here.

mlir/utils/tree-sitter-mlir/test/corpus/type.txt

1243

Why is this needed vs just inf part?

[artagnon]

Address review comments:

• Remove bench.js.
• Update arith inf test to not include irrelevant lines.

[jpienaar]

Looks good - I would like something where this could be generated more from the asm specs (it will never be complete, but we could get to something that reduces effort here). Let me know if you need help in landing.

This also makes me a bit sad for if github switches to tree-sitter, I think it'll make it more difficult to give "good enough (even if not great)" across known and unknown dialects.

mlir/utils/tree-sitter-mlir/.gitignore

+node_modules/
+src/
+bindings/
+binding.gyp
+Cargo.toml
+Cargo.lock
+target/
+build/

mlir/utils/tree-sitter-mlir/README.md

-tree-sitter-mlir
-================
+# tree-sitter-mlir
 
-Basic [tree-sitter](https://github.com/tree-sitter/tree-sitter) grammar for
-MLIR following the [lang-ref](https://mlir.llvm.org/docs/LangRef/).
+[tree-sitter](https://github.com/tree-sitter/tree-sitter) grammar for MLIR
+following the [lang-ref](https://mlir.llvm.org/docs/LangRef/). The parser is
+incomplete, and the bench statistics on the test files in the MLIR tree are as
+follows:
 
-Note: the directory in [LLVM repo](https://github.com/llvm/llvm-project/)
-merely contains the grammar file(s) and not the NPM/generated code.
+```
+Math, 100% passed
+Builtin, 100% passed
+Func, 100% passed
+ControlFlow, 100% passed
+Tensor, 93.33% passed
+Arith, 83.33% passed
+SCF, 88% passed
+Affine, 73.08% passed
+Linalg, 51.11% passed
+```

mlir/utils/tree-sitter-mlir/dialect/affine.js

+'use strict';
+
+module.exports = {
+  affine_dialect : $ => prec.right(choice(
+                     seq('affine.apply',
+                         field('operand',
+                               seq($.attribute, $._dim_and_symbol_use_list)),
+                         field('attributes', optional($.attribute))),
+
+                     // operation ::= `affine.delinearize_index` $linear_index
+                     // `into` ` `
+                     //               `(` $basis `)` attr-dict `:`
+                     //               type($multi_index)
+                     seq('affine.delinearlize_index',
+                         field('operand', $.value_use), 'into',
+                         field('basis', $._value_use_list_parens),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `affine.dma_start` ssa-use `[`
+                     // multi-dim-affine-map-of-ssa-ids `]`,
+                     //               `[` multi-dim-affine-map-of-ssa-ids `]`,
+                     //               `[` multi-dim-affine-map-of-ssa-ids `]`,
+                     //               ssa-use `:` memref-type
+                     seq(choice('affine.dma_start', 'affine.dma_wait'),
+                         field('operands',
+                               seq($.value_use, $._multi_dim_affine_expr_sq,
+                                   repeat(seq(',', $.value_use,
+                                              $._multi_dim_affine_expr_sq)))),
+                         ',', field('numElements', $._value_use_list),
+                         field('return', $._type_annotation)),
+
+                     // operation   ::= `affine.for` ssa-id `=` lower-bound `to`
+                     // upper-bound
+                     //                 (`step` integer-literal)? `{` op* `}`
+                     seq('affine.for', field('iv', $.value_use), '=',
+                         field('lowerBound',
+                               seq(optional(token('max')), $._bound)),
+                         token('to'),
+                         field('upperBound',
+                               seq(optional(token('min')), $._bound)),
+                         field('step',
+                               optional(seq(token('step'), $.integer_literal))),
+                         field('iter_args',
+                               optional(seq(token('iter_args'),
+                                            $._value_assignment_list))),
+                         field('return', optional($._function_return)),
+                         field('body', $.region),
+                         field('attributes', optional($.attribute))),
+
+                     // operation  ::= `affine.if` if-op-cond `{` op* `}`
+                     // (`else` `{` op* `}`)? if-op-cond ::= integer-set-attr
+                     // dim-and-symbol-use-list
+                     seq('affine.if',
+                         field('condition',
+                               seq($.attribute, $._dim_and_symbol_use_list)),
+                         field('return', optional($._function_return)),
+                         field('trueblk', $.region),
+                         field('falseblk',
+                               optional(seq(token('else'), $.region))),
+                         field('attributes', optional($.attribute))),
+
+                     // operation ::= `affine.load` ssa-use `[`
+                     // multi-dim-affine-map-of-ssa-ids `]`
+                     //               `:` memref-type
+                     seq(choice('affine.load', 'affine.vector_load'),
+                         field('operand', $.value_use),
+                         field('multiDimAffineMap',
+                               $._multi_dim_affine_expr_sq),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `affine.min` affine-map-attribute
+                     // dim-and-symbol-use-list
+                     seq(choice('affine.min', 'affine.max'),
+                         field('operand',
+                               seq($.attribute, $._dim_and_symbol_use_list))),
+
+                     seq('affine.parallel',
+                         field('iv', $._value_use_list_parens), '=',
+                         field('lowerBound', $._multi_dim_affine_expr_parens),
+                         token('to'),
+                         field('upperBound', $._multi_dim_affine_expr_parens),
+                         field('step',
+                               optional(seq(token('step'),
+                                            $._multi_dim_affine_expr_parens))),
+                         field('reduce',
+                               optional(seq(token('reduce'), '(',
+                                            $.string_literal,
+                                            repeat(seq(',', $.string_literal)),
+                                            ')'))),
+                         field('return', optional($._function_return)),
+                         field('body', $.region)),
+
+                     seq('affine.prefetch', field('source', $.value_use),
+                         field('indices',
+                               optional($._multi_dim_affine_expr_sq)),
+                         ',', field('isWrite', $.isWrite_attr), ',',
+                         field('localityHint', $.localityHint_attr), ',',
+                         field('isDataCache', $.isDataCache_attr),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `affine.store` ssa-use, ssa-use `[`
+                     // multi-dim-affine-map-of-ssa-ids `]`
+                     //               `:` memref-type
+                     seq(choice('affine.store', 'affine.vector_store'),
+                         field('source', $.value_use), ',',
+                         field('destination', $.value_use),
+                         field('multiDimAffineMap',
+                               $._multi_dim_affine_expr_sq),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `affine.yield` attr-dict ($operands^ `:`
+                     // type($operands))?
+                     seq('affine.yield',
+                         field('attributes', optional($.attribute)),
+                         field('results', optional($._value_use_type_list)))))
+}

mlir/utils/tree-sitter-mlir/dialect/arith.js

+'use strict';
+
+module.exports = {
+  arith_dialect : $ => choice(
+                    // operation ::= `arith.constant` attr-dict $value
+                    seq('arith.constant',
+                        field('attributes', optional($.attribute)),
+                        field('value', $._literal_and_type)),
+
+                    // operation ::= `arith.addi` $lhs `,` $rhs attr-dict `:`
+                    // type($result) operation ::= `arith.subi` $lhs `,` $rhs
+                    // attr-dict `:` type($result) operation ::= `arith.divsi`
+                    // $lhs `,` $rhs attr-dict `:` type($result) operation ::=
+                    // `arith.divui` $lhs `,` $rhs attr-dict `:` type($result)
+                    // operation ::= `arith.ceildivsi` $lhs `,` $rhs attr-dict
+                    // `:` type($result) operation ::= `arith.ceildivui` $lhs
+                    // `,` $rhs attr-dict `:` type($result) operation ::=
+                    // `arith.floordivsi` $lhs `,` $rhs attr-dict `:`
+                    // type($result) operation ::= `arith.remsi` $lhs `,` $rhs
+                    // attr-dict `:` type($result) operation ::= `arith.remui`
+                    // $lhs `,` $rhs attr-dict `:` type($result) operation ::=
+                    // `arith.muli` $lhs `,` $rhs attr-dict `:` type($result)
+                    // operation ::= `arith.mulsi_extended` $lhs `,` $rhs
+                    // attr-dict `:` type($lhs) operation ::=
+                    // `arith.mului_extended` $lhs `,` $rhs attr-dict `:`
+                    // type($lhs) operation ::= `arith.andi` $lhs `,` $rhs
+                    // attr-dict `:` type($result) operation ::= `arith.ori`
+                    // $lhs `,` $rhs attr-dict `:` type($result) operation ::=
+                    // `arith.xori` $lhs `,` $rhs attr-dict `:` type($result)
+                    // operation ::= `arith.maxsi` $lhs `,` $rhs attr-dict `:`
+                    // type($result) operation ::= `arith.maxui` $lhs `,` $rhs
+                    // attr-dict `:` type($result) operation ::= `arith.minsi`
+                    // $lhs `,` $rhs attr-dict `:` type($result) operation ::=
+                    // `arith.minui` $lhs `,` $rhs attr-dict `:` type($result)
+                    // operation ::= `arith.shli` $lhs `,` $rhs attr-dict `:`
+                    // type($result) operation ::= `arith.shrsi` $lhs `,` $rhs
+                    // attr-dict `:` type($result) operation ::= `arith.shrui`
+                    // $lhs `,` $rhs attr-dict `:` type($result)
+                    seq(choice('arith.addi', 'arith.subi', 'arith.divsi',
+                               'arith.divui', 'arith.ceildivsi',
+                               'arith.ceildivui', 'arith.floordivsi',
+                               'arith.remsi', 'arith.remui', 'arith.muli',
+                               'arith.mulsi_extended', 'arith.mului_extended',
+                               'arith.andi', 'arith.ori', 'arith.xori',
+                               'arith.maxsi', 'arith.maxui', 'arith.minsi',
+                               'arith.minui', 'arith.shli', 'arith.shrsi',
+                               'arith.shrui'),
+                        field('lhs', $.value_use), ',',
+                        field('rhs', $.value_use),
+                        field('attributes', optional($.attribute)),
+                        field('return', $._type_annotation)),
+
+                    // operation ::= `arith.addui_extended` $lhs `,` $rhs
+                    // attr-dict `:` type($sum)
+                    //                `,` type($overflow)
+                    seq('arith.addui_extended', field('lhs', $.value_use), ',',
+                        field('rhs', $.value_use),
+                        field('attributes', optional($.attribute)),
+                        field('return', seq(':', $.type, ',', $.type))),
+
+                    // operation ::= `arith.addf` $lhs `,` $rhs (`fastmath` ``
+                    // $fastmath^)?
+                    //                attr-dict `:` type($result)
+                    // operation ::= `arith.divf` $lhs `,` $rhs (`fastmath` ``
+                    // $fastmath^)?
+                    //                attr-dict `:` type($result)
+                    // operation ::= `arith.maxf` $lhs `,` $rhs (`fastmath` ``
+                    // $fastmath^)?
+                    //                attr-dict `:` type($result)
+                    // operation ::= `arith.minf` $lhs `,` $rhs (`fastmath` ``
+                    // $fastmath^)?
+                    //                attr-dict `:` type($result)
+                    // operation ::= `arith.mulf` $lhs `,` $rhs (`fastmath` ``
+                    // $fastmath^)?
+                    //                attr-dict `:` type($result)
+                    // operation ::= `arith.remf` $lhs `,` $rhs (`fastmath` ``
+                    // $fastmath^)?
+                    //                attr-dict `:` type($result)
+                    // operation ::= `arith.subf` $lhs `,` $rhs (`fastmath` ``
+                    // $fastmath^)?
+                    //                attr-dict `:` type($result)
+                    seq(choice('arith.addf', 'arith.divf', 'arith.maxf',
+                               'arith.minf', 'arith.mulf', 'arith.remf',
+                               'arith.subf'),
+                        field('lhs', $.value_use), ',',
+                        field('rhs', $.value_use),
+                        field('fastmath', optional($.fastmath_attr)),
+                        field('attributes', optional($.attribute)),
+                        field('return', $._type_annotation)),
+
+                    // operation ::= `arith.negf` $operand (`fastmath` ``
+                    // $fastmath^)?
+                    //                attr-dict `:` type($result)
+                    seq(choice('arith.negf'), field('operand', $.value_use),
+                        field('fastmath', optional($.fastmath_attr)),
+                        field('attributes', optional($.attribute)),
+                        field('return', $._type_annotation)),
+
+                    // operation ::= `arith.cmpi` $predicate `,` $lhs `,` $rhs
+                    // attr-dict `:` type($lhs) operation ::= `arith.cmpf`
+                    // $predicate `,` $lhs `,` $rhs attr-dict `:` type($lhs)
+                    seq(choice('arith.cmpi', 'arith.cmpf'),
+                        field('predicate',
+                              choice('eq', 'ne', 'oeq', 'olt', 'ole', 'ogt',
+                                     'oge', 'slt', 'sle', 'sgt', 'sge', 'ult',
+                                     'ule', 'ugt', 'uge', $.string_literal)),
+                        ',', field('lhs', $.value_use), ',',
+                        field('rhs', $.value_use),
+                        field('attributes', optional($.attribute)),
+                        field('return', $._type_annotation)),
+
+                    // operation ::= `arith.extf` $in attr-dict `:` type($in)
+                    // `to` type($out) operation ::= `arith.extsi` $in attr-dict
+                    // `:` type($in) `to` type($out) operation ::= `arith.extui`
+                    // $in attr-dict `:` type($in) `to` type($out) operation ::=
+                    // `arith.fptosi` $in attr-dict `:` type($in) `to`
+                    // type($out) operation ::= `arith.fptoui` $in attr-dict `:`
+                    // type($in) `to` type($out) operation ::=
+                    // `arith.index_cast` $in attr-dict `:` type($in) `to`
+                    // type($out) operation ::= `arith.index_castui` $in
+                    // attr-dict `:` type($in) `to` type($out) operation ::=
+                    // `arith.sitofp` $in attr-dict `:` type($in) `to`
+                    // type($out) operation ::= `arith.uitofp` $in attr-dict `:`
+                    // type($in) `to` type($out) operation ::= `arith.bitcast`
+                    // $in attr-dict `:` type($in) `to` type($out) operation ::=
+                    // `arith.truncf` $in attr-dict `:` type($in) `to`
+                    // type($out) operation ::= `arith.trunci` $in attr-dict `:`
+                    // type($in) `to` type($out)
+                    seq(choice('arith.extf', 'arith.extsi', 'arith.extui',
+                               'arith.fptosi', 'arith.fptoui',
+                               'arith.index_cast', 'arith.index_castui',
+                               'arith.sitofp', 'arith.uitofp', 'arith.bitcast',
+                               'arith.truncf', 'arith.trunci'),
+                        field('in', $.value_use),
+                        field('attributes', optional($.attribute)),
+                        field('return', $._type_annotation)),
+
+                    seq('arith.select', field('cond', $.value_use), ',',
+                        field('trueblk', $.value_use), ',',
+                        field('falseblk', $.value_use),
+                        field('return', $._type_annotation)))
+}

mlir/utils/tree-sitter-mlir/dialect/bufferization.js

+'use strict';
+
+module.exports = {
+  bufferization_dialect : $ => choice(
+                            seq('bufferization.alloc_tensor',
+                                field('in', $._value_use_list_parens),
+                                field('copy', optional(seq(token('copy'), '(',
+                                                           $.value_use, ')'))),
+                                field('size_hint',
+                                      optional(seq(token('size_hint'), '=',
+                                                   $.value_use))),
+                                field('attributes', optional($.attribute)),
+                                field('return', $._type_annotation)),
+
+                            // operation ::= `bufferization.to_memref` $tensor
+                            // attr-dict `:` type($memref)
+                            seq('bufferization.to_memref',
+                                field('tensor', $.value_use),
+                                field('attributes', optional($.attribute)),
+                                field('return', $._type_annotation)),
+
+                            // operation ::= `bufferization.to_tensor` $memref
+                            //               (`restrict` $restrict^)?
+                            //               (`writable` $writable^)? attr-dict
+                            //               `:` type($memref)
+                            seq('bufferization.to_tensor',
+                                field('memref', $.value_use),
+                                field('restrict', optional($.restrict_attr)),
+                                field('writable', optional($.writable_attr)),
+                                field('attributes', optional($.attribute)),
+                                field('return', $._type_annotation)))
+}

mlir/utils/tree-sitter-mlir/dialect/builtin.js

+'use strict';
+
+module.exports = {
+  builtin_dialect : $ => prec.right(choice(
+                      // operation ::= `builtin.module` ($sym_name^)?
+                      // attr-dict-with-keyword $bodyRegion
+                      seq(choice('builtin.module', 'module'),
+                          field('name', optional($.bare_id)),
+                          field('attributes', optional($.attribute)),
+                          field('body', $.region)),
+
+                      // operation ::= `builtin.unrealized_conversion_cast`
+                      // ($inputs^ `:` type($inputs))?
+                      //                `to` type($outputs) attr-dict
+                      seq(choice('builtin.unrealized_conversion_cast',
+                                 'unrealized_conversion_cast'),
+                          field('inputs', optional($._value_use_type_list)),
+                          token('to'), field('outputs', $._type_list_no_parens),
+                          field('attributes', optional($.attribute)))))
+}

mlir/utils/tree-sitter-mlir/dialect/cf.js

+'use strict';
+
+module.exports = {
+  cf_dialect : $ => prec.right(choice(
+                 // operation ::= `cf.assert` $arg `,` $msg attr-dict
+                 seq('cf.assert', field('argument', $.value_use), ',',
+                     field('message', $.string_literal),
+                     field('attributes', optional($.attribute))),
+
+                 // operation ::= `cf.br` $dest (`(` $destOperands^ `:`
+                 // type($destOperands) `)`)? attr-dict
+                 seq('cf.br', field('successor', $.successor),
+                     field('attributes', optional($.attribute))),
+
+                 // operation ::= `cf.cond_br` $condition `,`
+                 //               $trueDest(`(` $trueDestOperands ^ `:`
+                 //               type($trueDestOperands)`)`)? `,`
+                 //               $falseDest(`(` $falseDestOperands ^ `:`
+                 //               type($falseDestOperands)`)`)? attr-dict
+                 seq('cf.cond_br', field('condition', $.value_use), ',',
+                     field('trueblk', $.successor), ',',
+                     field('falseblk', $.successor),
+                     field('attributes', optional($.attribute))),
+
+                 // operation ::= `cf.switch` $flag `:` type($flag) `,` `[` `\n`
+                 //               custom<SwitchOpCases>(ref(type($flag)),$defaultDestination,
+                 //               $defaultOperands,
+                 //               type($defaultOperands),
+                 //               $case_values,
+                 //               $caseDestinations,
+                 //               $caseOperands,
+                 //               type($caseOperands))
+                 //               `]`
+                 //               attr-dict
+                 seq('cf.switch', field('flag', $._value_use_and_type), ',',
+                     '[', $.cf_case_label, $.successor,
+                     repeat(seq(',', $.cf_case_label, $.successor)), ']',
+                     field('attributes', optional($.attribute))),
+                 )),
+
+  cf_case_label : $ => seq(choice($.integer_literal, token('default')), ':')
+}

mlir/utils/tree-sitter-mlir/dialect/func.js

+'use strict';
+
+module.exports = {
+  func_dialect : $ => prec.right(choice(
+                   // operation ::= `func.call_indirect` $callee `(`
+                   // $callee_operands `)` attr-dict
+                   //               `:` type($callee)
+                   // operation ::= `func.call` $callee `(` $operands `)`
+                   // attr-dict
+                   //               `:` functional-type($operands, results)
+                   seq(choice('func.call', 'call', 'func.call_indirect',
+                              'call_indirect'),
+                       field('callee', $.symbol_ref_id),
+                       field('operands', $._value_use_list_parens),
+                       field('attributes', optional($.attribute)),
+                       field('return', $._function_type_annotation)),
+
+                   // operation ::= `func.constant` attr-dict $value `:`
+                   // type(results)
+                   seq(choice('func.constant', 'constant'),
+                       field('attributes', optional($.attribute)),
+                       field('value', $.symbol_ref_id),
+                       field('return', $._function_type_annotation)),
+
+                   seq('func.func', $._op_func),
+
+                   seq(choice('func.return', 'return'),
+                       field('attributes', optional($.attribute)),
+                       field('results', optional($._value_use_type_list)))))
+}

mlir/utils/tree-sitter-mlir/dialect/linalg.js

+'use strict';
+
+module.exports = {
+  linalg_dialect : $ => prec.right(choice(
+                     seq(choice(
+                             'linalg.batch_matmul',
+                             'linalg.batch_matmul_transpose_b',
+                             'linalg.batch_matvec',
+                             'linalg.batch_reduce_matmul', 'linalg.broadcast',
+                             'linalg.conv_1d_ncw_fcw', 'linalg.conv_1d_nwc_wcf',
+                             'linalg.conv_1d', 'linalg.conv_2d_nchw_fchw',
+                             'linalg.conv_2d_ngchw_fgchw',
+                             'linalg.conv_2d_nhwc_fhwc',
+                             'linalg.conv_2d_nhwc_hwcf',
+                             'linalg.conv_2d_nhwc_hwcf_q', 'linalg.conv_2d',
+                             'linalg.conv_3d_ndhwc_dhwcf',
+                             'linalg.conv_3d_ndhwc_dhwcf_q', 'linalg.conv_3d',
+                             'linalg.copy', 'linalg.depthwise_conv_1d_nwc_wc',
+                             'linalg.depthwise_conv_1d_nwc_wcm',
+                             'linalg.depthwise_conv_2d_nchw_chw',
+                             'linalg.depthwise_conv_2d_nhwc_hwc',
+                             'linalg.depthwise_conv_2d_nhwc_hwc_q',
+                             'linalg.depthwise_conv_2d_nhwc_hwcm',
+                             'linalg.depthwise_conv_2d_nhwc_hwcm_q',
+                             'linalg.depthwise_conv_3d_ndhwc_dhwc',
+                             'linalg.depthwise_conv_3d_ndhwc_dhwcm',
+                             'linalg.dot', 'linalg.elemwise_binary',
+                             'linalg.elemwise_unary', 'linalg.fill',
+                             'linalg.fill_rng_2d', 'linalg.matmul',
+                             'linalg.matmul_transpose_b',
+                             'linalg.matmul_unsigned', 'linalg.matvec',
+                             'linalg.mmt4d', 'linalg.pooling_nchw_max',
+                             'linalg.pooling_nchw_sum',
+                             'linalg.pooling_ncw_max', 'linalg.pooling_ncw_sum',
+                             'linalg.pooling_ndhwc_max',
+                             'linalg.pooling_ndhwc_min',
+                             'linalg.pooling_ndhwc_sum',
+                             'linalg.pooling_nhwc_max',
+                             'linalg.pooling_nhwc_max_unsigned',
+                             'linalg.pooling_nhwc_min',
+                             'linalg.pooling_nhwc_min_unsigned',
+                             'linalg.pooling_nhwc_sum',
+                             'linalg.pooling_nwc_max',
+                             'linalg.pooling_nwc_max_unsigned',
+                             'linalg.pooling_nwc_min',
+                             'linalg.pooling_nwc_min_unsigned',
+                             'linalg.pooling_nwc_sum',
+                             'linalg.quantized_batch_matmul',
+                             'linalg.quantized_matmul', 'linalg.vecmat'),
+                         repeat1($._ins_outs_attributes),
+                         field('return', optional($._function_return))),
+
+                     seq('linalg.generic', repeat1($._ins_outs_attributes),
+                         field('body', $.region),
+                         field('return', optional($._function_return))),
+
+                     // operation ::= `linalg.index` $dim attr-dict `:`
+                     // type($result)
+                     seq('linalg.index', field('dimension', $.integer_literal),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     seq(choice('linalg.map', 'linalg.reduce'),
+                         repeat1($._ins_outs_attributes),
+                         field('arguments', $.block_arg_list),
+                         field('body', $.region),
+                         field('return', optional($._function_return))),
+
+                     seq('linalg.yield',
+                         field('attributes', optional($.attribute)),
+                         field('results', optional($._value_use_type_list))))),
+
+  _ins_outs_attributes : $ => choice($._ins, $._outs, $.attribute,
+                                     $._attribute_entry_list),
+  _ins : $ => seq(token('ins'), '(', $._value_use_type_list, ')'),
+  _outs : $ => seq(token('outs'), '(', $._value_use_type_list, ')'),
+  _attribute_entry_list : $ => seq($.bare_attribute_entry,
+                                   repeat(seq(',', $.bare_attribute_entry))),
+  bare_attribute_entry : $ => seq($.bare_id, '=', $.attribute_value)
+}

mlir/utils/tree-sitter-mlir/dialect/llvm.js

+'use strict';
+
+module.exports = {
+  llvm_dialect : $ => prec.right(choice(
+                   seq('llvm.func', $._op_func),
+
+                   seq('llvm.return',
+                       field('attributes', optional($.attribute)),
+                       field('results', optional($._value_use_type_list)))))
+}

mlir/utils/tree-sitter-mlir/dialect/math.js

+'use strict';
+
+module.exports = {
+  math_dialect : $ => choice(
+                   // operation ::= `math.absf` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.atan` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.cbrt` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.ceil` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.cos` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.erf` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.exp` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.exp2` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.expm1` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.floor` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.log` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.log10` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.log1p` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.log2` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.round` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.roundeven` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.rsqrt` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.sin` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.sqrt` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.tan` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.tanh` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.trunc` $operand (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   seq(choice('math.absf', 'math.atan', 'math.cbrt',
+                              'math.ceil', 'math.cos', 'math.erf', 'math.exp',
+                              'math.exp2', 'math.expm1', 'math.floor',
+                              'math.log', 'math.log10', 'math.log1p',
+                              'math.log2', 'math.round', 'math.roundeven',
+                              'math.rsqrt', 'math.sin', 'math.sqrt', 'math.tan',
+                              'math.tanh', 'math.trunc'),
+                       field('operand', $.value_use),
+                       field('fastmath', optional($.fastmath_attr)),
+                       field('attributes', optional($.attribute)),
+                       field('return', $._type_annotation)),
+
+                   // operation ::= `math.absi` $operand attr-dict `:`
+                   // type($result) operation ::= `math.ctlz` $operand attr-dict
+                   // `:` type($result) operation ::= `math.cttz` $operand
+                   // attr-dict `:` type($result) operation ::= `math.ctpop`
+                   // $operand attr-dict `:` type($result)
+                   seq(choice('math.absi', 'math.ctlz', 'math.cttz',
+                              'math.ctpop'),
+                       field('operand', $.value_use),
+                       field('attributes', optional($.attribute)),
+                       field('return', $._type_annotation)),
+
+                   // operation ::= `math.atan2` $lhs `,` $rhs (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.copysign` $lhs `,` $rhs (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   // operation ::= `math.fpowi` $lhs `,` $rhs (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($lhs) `,` type($rhs)
+                   // operation ::= `math.powf` $lhs `,` $rhs (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   seq(choice('math.atan2', 'math.copysign', 'math.fpowi',
+                              'math.powf'),
+                       field('lhs', $.value_use), ',',
+                       field('rhs', $.value_use),
+                       field('fastmath', optional($.fastmath_attr)),
+                       field('attributes', optional($.attribute)),
+                       field('return', $._type_annotation)),
+
+                   // operation ::= `math.ipowi` $lhs `,` $rhs attr-dict `:`
+                   // type($result)
+                   seq('math.ipowi', field('lhs', $.value_use), ',',
+                       field('rhs', $.value_use),
+                       field('attributes', optional($.attribute)),
+                       field('return', $._type_annotation)),
+
+                   // operation ::= `math.fma` $a `,` $b `,` $c (`fastmath` ``
+                   // $fastmath^)?
+                   //               attr-dict `:` type($result)
+                   seq('math.fma', field('a', $.value_use), ',',
+                       field('b', $.value_use), ',', field('c', $.value_use),
+                       field('fastmath', optional($.fastmath_attr)),
+                       field('attributes', optional($.attribute)),
+                       field('return', $._type_annotation)))
+}

mlir/utils/tree-sitter-mlir/dialect/memref.js

+'use strict';
+
+module.exports = {
+  memref_dialect : $ => choice(
+                     // operation ::= `memref.assume_alignment` $memref `,`
+                     // $alignment attr-dict `:` type($memref)
+                     seq('memref.assume_alignment',
+                         field('memref', $.value_use), ',',
+                         field('alignment', $.integer_literal),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.alloc` `(`$dynamicSizes`)` (`` `[`
+                     // $symbolOperands^ `]`)? attr-dict
+                     //               `:` type($memref)
+                     // operation ::= `memref.alloca` `(`$dynamicSizes`)` (``
+                     // `[` $symbolOperands^ `]`)? attr-dict
+                     //               `:` type($memref)
+                     seq(choice('memref.alloc', 'memref.alloca'),
+                         field('dynamicSizes', $._value_use_list_parens),
+                         field('symbolOperands', optional($._dense_idx_list)),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.cast` $source attr-dict `:`
+                     // type($source) `to` type($dest)
+                     seq('memref.cast', field('in', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.copy` $source `,` $target
+                     // attr-dict
+                     //               `:` type($source) `to` type($target)
+                     seq('memref.copy', field('source', $.value_use), ',',
+                         field('target', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.collapse_shape` $src
+                     // $reassociation attr-dict
+                     //               `:` type($src) `into` type($result)
+                     // operation ::= `memref.expand_shape` $src $reassociation
+                     // attr-dict
+                     //               `:` type($src) `into` type($result)
+                     seq(choice('memref.collapse_shape', 'memref.expand_shape'),
+                         field('source', $.value_use),
+                         field('reassociation', $.nested_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.dealloc` $memref attr-dict `:`
+                     // type($memref)
+                     seq('memref.dealloc', field('memref', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.dim` attr-dict $source `,` $index
+                     // `:` type($source)
+                     seq('memref.dim',
+                         field('attributes', optional($.attribute)),
+                         field('source', $.value_use), ',',
+                         field('index', $.value_use),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.load` $memref `[` $indices `]`
+                     // attr-dict `:` type($memref)
+                     seq('memref.load',
+                         field('memref', seq($.value_use, $._dense_idx_list)),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     seq('memref.prefetch', field('source', $.value_use),
+                         field('indices', optional($._dense_idx_list)), ',',
+                         field('isWrite', $.isWrite_attr), ',',
+                         field('localityHint', $.localityHint_attr), ',',
+                         field('isDataCache', $.isDataCache_attr),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.rank` $memref attr-dict `:`
+                     // type($memref)
+                     seq('memref.rank', field('memref', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.realloc` $source (`(`
+                     // $dynamicResultSize^ `)`)? attr-dict
+                     //               `:` type($source) `to` type(results)
+                     seq('memref.realloc', field('source', $.value_use),
+                         field('dynamicResultSize',
+                               optional($._value_use_list_parens)),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.reinterpret_cast` $source `to`
+                     // `offset` `` `:`
+                     //               custom<DynamicIndexList>($offsets,
+                     //               $static_offsets)
+                     //               `` `,` `sizes` `` `:`
+                     //               custom<DynamicIndexList>($sizes,
+                     //               $static_sizes)
+                     //               `` `,` `strides` `` `:`
+                     //               custom<DynamicIndexList>($strides,
+                     //               $static_strides) attr-dict `:`
+                     //               type($source) `to` type($result)
+                     seq('memref.reinterpret_cast',
+                         field('source', $.value_use), token('to'),
+                         field('offset', seq(token('offset'), ':',
+                                             $._dense_idx_list, ',')),
+                         field('sizes', seq(token('sizes'), ':',
+                                            $._dense_idx_list, ',')),
+                         field('strides',
+                               seq(token('strides'), ':', $._dense_idx_list)),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.reshape` $source `(` $shape `)`
+                     // attr-dict
+                     //               `:` functional-type(operands, results)
+                     seq('memref.reshape', field('source', $.value_use),
+                         field('shape', seq('(', $.value_use, ')')),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._function_type_annotation)),
+
+                     // operation ::= `memref.store` $value `,` $memref `[`
+                     // $indices `]` attr-dict
+                     //                `:` type($memref)
+                     seq('memref.store', field('source', $.value_use), ',',
+                         field('destination', $.value_use),
+                         field('indices', $._dense_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.subview` $source ``
+                     //               custom<DynamicIndexList>($offsets,
+                     //               $static_offsets)
+                     //               custom<DynamicIndexList>($sizes,
+                     //               $static_sizes)
+                     //               custom<DynamicIndexList>($strides,
+                     //               $static_strides) attr-dict `:`
+                     //               type($source) `to` type($result)
+                     seq('memref.subview', field('source', $.value_use),
+                         field('offsets', $._dense_idx_list),
+                         field('sizes', $._dense_idx_list),
+                         field('strides', $._dense_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `memref.view` $source `[` $byte_shift `]`
+                     // `` `[` $sizes `]` attr-dict
+                     //         `:` type($source) `to` type(results)
+                     seq('memref.view', field('source', $.value_use),
+                         field('byte_shift', $._dense_idx_list),
+                         field('sizes', $._dense_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)))
+}

mlir/utils/tree-sitter-mlir/dialect/scf.js

+'use strict';
+
+module.exports = {
+  scf_dialect : $ => prec.right(choice(
+                  // operation ::= `scf.condition` `(` $condition `)` attr-dict
+                  // ($args^ `:` type($args))?
+                  seq('scf.condition',
+                      field('condition', $._value_use_list_parens),
+                      field('attributes', optional($.attribute)),
+                      field('arguments', optional($._value_use_type_list))),
+
+                  seq('scf.execute_region',
+                      field('return', optional($._function_return)),
+                      field('body', $.region),
+                      field('attributes', optional($.attribute))),
+
+                  seq('scf.if', field('condition', $.value_use),
+                      field('return', optional($._function_return)),
+                      field('trueblk', $.region),
+                      field('falseblk',
+                            optional(seq(token('else'), $.region)))),
+
+                  // operation ::= `scf.index_switch` $arg attr-dict (`->`
+                  // type($results)^)?
+                  //               custom<SwitchCases>($cases, $caseRegions)
+                  //               `\n`
+                  //               `` `default` $defaultRegion
+                  seq('scf.index_switch', field('flag', $._value_use_and_type),
+                      field('attributes', optional($.attribute)),
+                      field('result', optional($._function_return)),
+                      $.scf_case_label, $.region,
+                      repeat(seq($.scf_case_label, $.region))),
+
+                  // scf.for %iv = %lb to %ub step %step {
+                  // ... // body
+                  // }
+                  seq('scf.for', field('iv', $.value_use), '=',
+                      field('lb', $.value_use), token('to'),
+                      field('ub', $.value_use),
+                      field('step', seq(token('step'), $.value_use)),
+                      field('iter_args',
+                            optional(seq(token('iter_args'),
+                                         $._value_assignment_list))),
+                      field('return', optional($._function_return)),
+                      field('body', $.region),
+                      field('attributes', optional($.attribute))),
+
+                  seq('scf.forall', field('iv', $._value_use_list_parens),
+                      field('bounds',
+                            seq(choice(seq('=', $._value_use_list_parens,
+                                           token('to')),
+                                       token('in')),
+                                $._value_use_list_parens)),
+                      field('step', optional(seq(token('step'),
+                                                 $._value_use_list_parens))),
+                      field('shared_outs',
+                            optional(seq(token('shared_outs'),
+                                         $._value_assignment_list))),
+                      field('return', optional($._function_return)),
+                      field('body', $.region),
+                      field('attributes', optional($.attribute))),
+
+                  seq('scf.forall.in_parallel', field('body', $.region),
+                      field('attributes', optional($.attribute))),
+
+                  seq('scf.parallel', field('iv', $._value_use_list_parens),
+                      '=', field('lb', $._value_use_list_parens), token('to'),
+                      field('ub', $._value_use_list_parens),
+                      field('step',
+                            seq(token('step'), $._value_use_list_parens)),
+                      field('init', optional(seq(token('init'),
+                                                 $._value_use_list_parens))),
+                      field('return', optional($._function_return)),
+                      field('body', $.region),
+                      field('attributes', optional($.attribute))),
+
+                  seq('scf.reduce', field('operand', $._value_use_list_parens),
+                      field('return', $._type_annotation),
+                      field('body', $.region)),
+
+                  // operation ::= `scf.reduce.return` $result attr-dict `:`
+                  // type($result)
+                  seq('scf.reduce.return', field('result', $.value_use),
+                      field('attributes', optional($.attribute)),
+                      field('return', $._type_annotation)),
+
+                  // op ::= `scf.while` assignments `:` function-type region
+                  // `do` region
+                  //        `attributes` attribute-dict
+                  // initializer ::= /* empty */ | `(` assignment-list `)`
+                  seq('scf.while',
+                      field('assignments', optional($._value_assignment_list)),
+                      field('return', $._function_type_annotation),
+                      field('condblk', $.region), 'do',
+                      field('doblk', $.region),
+                      field('attributes',
+                            optional(seq('attributes', $.attribute)))),
+
+                  // operation ::= `scf.yield` attr-dict ($results^ `:`
+                  // type($results))?
+                  seq('scf.yield', field('attributes', optional($.attribute)),
+                      field('results', optional($._value_use_type_list))),
+                  )),
+
+  scf_case_label : $ => choice(seq(token('case'), $.integer_literal),
+                               token('default'))
+}

mlir/utils/tree-sitter-mlir/dialect/tensor.js

+'use strict';
+
+module.exports = {
+  tensor_dialect : $ => choice(
+                     // operation ::= `tensor.empty` `(`$dynamicSizes`)`
+                     // attr-dict `:` type($result)
+                     seq('tensor.empty',
+                         field('dynamicSizes', $._value_use_list_parens),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.cast` $source attr-dict `:`
+                     // type($source) `to` type($dest)
+                     seq('tensor.cast', field('in', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.dim` attr-dict $source `,` $index
+                     // `:` type($source)
+                     seq('tensor.dim',
+                         field('attributes', optional($.attribute)),
+                         field('tensor', $.value_use), ',',
+                         field('index', $.value_use),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.collapse_shape` $src
+                     // $reassociation attr-dict `:` type($src)
+                     //                `into` type($result)
+                     seq(choice('tensor.collapse_shape', 'tensor.expand_shape'),
+                         field('tensor', $.value_use),
+                         field('reassociation', $.nested_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.extract` $tensor `[` $indices `]`
+                     // attr-dict `:` type($tensor)
+                     seq('tensor.extract', field('tensor', $.value_use),
+                         field('indices', $._dense_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.insert` $scalar `into` $dest `[`
+                     // $indices `]` attr-dict
+                     //               `:` type($dest)
+                     seq('tensor.insert', field('scalar', $.value_use),
+                         token('into'), field('destination', $.value_use),
+                         field('indices', $._dense_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.extract_slice` $source ``
+                     //                custom<DynamicIndexList>($offsets,
+                     //                $static_offsets)
+                     //                custom<DynamicIndexList>($sizes,
+                     //                $static_sizes)
+                     //                custom<DynamicIndexList>($strides,
+                     //                $static_strides) attr-dict `:`
+                     //                type($source) `to` type($result)
+                     seq('tensor.extract_slice', field('tensor', $.value_use),
+                         field('offsets', $._dense_idx_list),
+                         field('sizes', $._dense_idx_list),
+                         field('strides', $._dense_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.insert_slice` $source `into` $dest
+                     // ``
+                     //                custom<DynamicIndexList>($offsets,
+                     //                $static_offsets)
+                     //                custom<DynamicIndexList>($sizes,
+                     //                $static_sizes)
+                     //                custom<DynamicIndexList>($strides,
+                     //                $static_strides) attr-dict `:`
+                     //                type($source) `into` type($dest)
+                     // operation ::= `tensor.parallel_insert_slice` $source
+                     // `into` $dest ``
+                     //                custom<DynamicIndexList>($offsets,
+                     //                $static_offsets)
+                     //                custom<DynamicIndexList>($sizes,
+                     //                $static_sizes)
+                     //                custom<DynamicIndexList>($strides,
+                     //                $static_strides) attr-dict `:`
+                     //                type($source) `into` type($dest)
+                     seq(choice('tensor.insert_slice',
+                                'tensor.parallel_insert_slice'),
+                         field('source', $.value_use), token('into'),
+                         field('destination', $.value_use),
+                         field('offsets', $._dense_idx_list),
+                         field('sizes', $._dense_idx_list),
+                         field('strides', $._dense_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.from_elements` $elements attr-dict
+                     // `:` type($result)
+                     seq('tensor.from_elements',
+                         field('elements', optional($._value_use_list)),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.gather` $source `[` $indices `]`
+                     //               `gather_dims` `(` $gather_dims `)`
+                     //               (`unique` $unique^)?
+                     //               attr-dict
+                     //               `:` functional-type(operands, results)
+                     seq('tensor.gather', field('source', $.value_use),
+                         field('indices', $._dense_idx_list),
+                         field('gatherDims', $.gather_dims_attr),
+                         field('unique', optional($.unique_attr)),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._function_type_annotation)),
+
+                     // operation ::= `tensor.scatter` $source `into` $dest `[`
+                     // $indices `]`
+                     //               `scatter_dims` `(` $scatter_dims `)`
+                     //               (`unique` $unique^)?
+                     //               attr-dict
+                     //               `:` functional-type(operands, results)
+                     seq('tensor.scatter', field('source', $.value_use),
+                         token('into'), field('destination', $.value_use),
+                         field('indices', $._dense_idx_list),
+                         field('scatterDims', $.scatter_dims_attr),
+                         field('unique', optional($.unique_attr)),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._function_type_annotation)),
+
+                     // operation ::= `tensor.pad` $source
+                     //               (`nofold` $nofold^)?
+                     //               `low` `` custom<DynamicIndexList>($low,
+                     //               $static_low) `high` ``
+                     //               custom<DynamicIndexList>($high,
+                     //               $static_high) $region attr-dict `:`
+                     //               type($source) `to` type($result)
+                     seq('tensor.pad', field('source', $.value_use),
+                         field('nofold', optional($.nofold_attr)),
+                         field('low', seq(token('low'), $._dense_idx_list)),
+                         field('high', seq(token('high'), $._dense_idx_list)),
+                         field('body', $.region),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.reshape` $source `(` $shape `)`
+                     // attr-dict
+                     //                `:` functional-type(operands, results)
+                     seq('tensor.reshape', field('tensor', $.value_use),
+                         field('shape', $._value_use_list_parens),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._function_type_annotation)),
+
+                     // operation ::= `tensor.splat` $input attr-dict `:`
+                     // type($aggregate)
+                     seq('tensor.splat', field('input', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.pack` $source
+                     //               (`padding_value` `(` $padding_value^ `:`
+                     //               type($padding_value) `)`)?
+                     //               (`outer_dims_perm` `=` $outer_dims_perm^)?
+                     //               `inner_dims_pos` `=` $inner_dims_pos
+                     //               `inner_tiles` `=`
+                     //               custom<DynamicIndexList>($inner_tiles,
+                     //               $static_inner_tiles) `into` $dest
+                     //               attr-dict `:` type($source) `->`
+                     //               type($dest)
+                     // operation ::= `tensor.unpack` $source
+                     //               (`outer_dims_perm` `=` $outer_dims_perm^)?
+                     //               `inner_dims_pos` `=` $inner_dims_pos
+                     //               `inner_tiles` `=`
+                     //               custom<DynamicIndexList>($inner_tiles,
+                     //               $static_inner_tiles) `into` $dest
+                     //               attr-dict `:` type($source) `->`
+                     //               type($dest)
+                     seq(choice('tensor.pack', 'tensor.unpack'),
+                         field('source', $.value_use),
+                         field('padding_value',
+                               optional(seq(token('padding_value'), '(',
+                                            $._value_use_and_type, ')'))),
+                         field('outer_dims_perm',
+                               optional($.outer_dims_perm_attr)),
+                         field('inner_dims_pos', $.inner_dims_pos_attr),
+                         field('inner_tiles', $.inner_tiles_attr),
+                         token('into'), field('destination', $.value_use),
+                         field('return', $._function_type_annotation)),
+
+                     // operation ::= `tensor.generate` $dynamicExtents $body
+                     // attr-dict `:` type($result)
+                     seq('tensor.generate',
+                         field('dynamicExtents', $._value_use_list),
+                         field('body', $.region),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `tensor.rank` $tensor attr-dict `:`
+                     // type($tensor) operation ::= `tensor.yield` $value
+                     // attr-dict `:` type($value)
+                     seq(choice('tensor.rank', 'tensor.yield'),
+                         field('tensor', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)))
+}

mlir/utils/tree-sitter-mlir/dialect/vector.js

+'use strict';
+
+module.exports = {
+  vector_dialect : $ => prec.right(choice(
+                     // operation ::= `vector.bitcast` $source attr-dict `:`
+                     // type($source) `to` type($result) operation ::=
+                     // `vector.broadcast` $source attr-dict `:` type($source)
+                     // `to` type($vector) operation ::= `vector.shape_cast`
+                     // $source attr-dict `:` type($source) `to` type($result)
+                     // operation ::= `vector.type_cast` $memref attr-dict `:`
+                     // type($memref) `to` type($result)
+                     seq(choice('vector.bitcast', 'vector.broadcast',
+                                'vector.shape_cast', 'vector.type_cast'),
+                         field('in', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `vector.constant_mask` $mask_dim_sizes
+                     // attr-dict `:` type(results)
+                     seq('vector.constant_mask',
+                         field('mask', $._dense_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `vector.create_mask` $operands attr-dict
+                     // `:` type(results)
+                     seq('vector.create_mask',
+                         field('operands', $._value_use_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `vector.extract` $vector `` $position
+                     // attr-dict `:` type($vector) operation ::= `vector.load`
+                     // $base `[` $indices `]` attr-dict
+                     //               `:` type($base) `,` type($nresult)
+                     // operation ::= `vector.scalable.extract` $source `[` $pos
+                     // `]` attr-dict
+                     //               `:` type($res) `from` type($source)
+                     seq(choice('vector.extract', 'vector.load',
+                                'vector.scalable.extract'),
+                         field('operand', $.value_use),
+                         field('indices', $._dense_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `vector.fma` $lhs `,` $rhs `,` $acc
+                     // attr-dict `:` type($lhs)
+                     seq('vector.fma', field('lhs', $.value_use), ',',
+                         field('rhs', $.value_use), ',',
+                         field('acc', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `vector.flat_transpose` $matrix attr-dict
+                     // `:` type($matrix) `->` type($res)
+                     seq('vector.flat_transpose', field('matrix', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._function_type_annotation)),
+
+                     // operation ::= `vector.insert` $source `,` $dest
+                     // $position attr-dict
+                     //               `:` type($source) `into` type($dest)
+                     // operation ::= `vector.scalable.insert` $source `,` $dest
+                     // `[` $pos `]` attr-dict
+                     //               `:` type($source) `into` type($dest)
+                     // operation ::= `vector.shuffle` operands $mask attr-dict
+                     // `:` type(operands) operation ::= `vector.store`
+                     // $valueToStore `,` $base `[` $indices `]` attr-dict
+                     //               `:` type($base) `,` type($valueToStore)
+                     seq(choice('vector.insert', 'vector.scalable.insert',
+                                'vector.shuffle', 'vector.store'),
+                         field('source', $.value_use), ',',
+                         field('destination', $.value_use),
+                         field('position', $._dense_idx_list),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `vector.insert_strided_slice` $source `,`
+                     // $dest attr-dict
+                     //               `:` type($source) `into` type($dest)
+                     seq('vector.insert_strided_slice',
+                         field('source', $.value_use), ',',
+                         field('destination', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `vector.matrix_multiply` $lhs `,` $rhs
+                     // attr-dict
+                     //                `:` `(` type($lhs) `,` type($rhs) `)`
+                     //                `->` type($res)
+                     seq('vector.matrix_multiply', field('lhs', $.value_use),
+                         ',', field('rhs', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._function_type_annotation)),
+
+                     // operation ::= `vector.print` $source attr-dict `:`
+                     // type($source)
+                     seq(choice('vector.print', 'vector.splat'),
+                         field('operand', $.value_use),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     seq('vector.transfer_read',
+                         field('source', seq($.value_use, $._dense_idx_list)),
+                         field('paddingMask', repeat(seq(',', $.value_use))),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     seq('vector.transfer_write', field('vector', $.value_use),
+                         ',',
+                         field('source', seq($.value_use, $._dense_idx_list)),
+                         field('mask', optional(seq(',', $.value_use))),
+                         field('attributes', optional($.attribute)),
+                         field('return', $._type_annotation)),
+
+                     // operation ::= `vector.yield` attr-dict ($operands^ `:`
+                     // type($operands))?
+                     seq('vector.yield',
+                         field('attributes', optional($.attribute)),
+                         field('results', optional($._value_use_type_list)))))
+}

mlir/utils/tree-sitter-mlir/grammar.js

-module.exports = grammar({
-  name : 'mlir',
-  extras : $ => [/\s/,
-                 $.comment,
-],
-  conflicts : $ => [],
-  rules : {
-    // Top level production:
-    //   (operation | attribute-alias-def | type-alias-def)
-    toplevel : $ => seq(choice(
-                 $.operation,
-                 $.attribute_alias_def,
-                 $.type_alias_def,
-                 )),
+'use strict';
+
+const builtin_dialect = require('./dialect/builtin');
+const func_dialect = require('./dialect/func');
+const llvm_dialect = require('./dialect/llvm');
+const arith_dialect = require('./dialect/arith');
+const math_dialect = require('./dialect/math');
+const cf_dialect = require('./dialect/cf');
+const scf_dialect = require('./dialect/scf');
+const memref_dialect = require('./dialect/memref');
+const vector_dialect = require('./dialect/vector');
+const tensor_dialect = require('./dialect/tensor');
+const bufferization_dialect = require('./dialect/bufferization');
+const affine_dialect = require('./dialect/affine');
+const linalg_dialect = require('./dialect/linalg');
+
+const common = {
+  toplevel : $ => seq($._toplevel, repeat($._toplevel)),
+  _toplevel : $ => choice($.operation, $.attribute_alias_def, $.type_alias_def),
 
-    // Common syntax (lang-ref)
-    //  digit     ::= [0-9]
-    //  hex_digit ::= [0-9a-fA-F]
-    //  letter    ::= [a-zA-Z]
-    //  id-punct  ::= [$._-]
-    //
-    //  integer-literal ::= decimal-literal | hexadecimal-literal
-    //  decimal-literal ::= digit+
-    //  hexadecimal-literal ::= `0x` hex_digit+
-    //  float-literal ::= [-+]?[0-9]+[.][0-9]*([eE][-+]?[0-9]+)?
-    //  string-literal  ::= `"` [^"\n\f\v\r]* `"`   TODO: define escaping rules
-    //
-    _digit : $ => /[0-9]/,
-    _hex_digit : $ => /[0-9a-fA-F]/,
-    integer_literal : $ => choice($._decimal_literal, $._hexadecimal_literal),
-    _decimal_literal : $ => repeat1($._digit),
-    _hexadecimal_literal : $ => seq('0x', repeat1($._hex_digit)),
-    float_literal : $ => token(
-                      seq(optional(/[-+]/), repeat1(/[0_9]/),
-                          optional(seq('.', repeat(/[0-9]/),
-                                       optional(seq(/[eE]/, optional(/[-+]/),
-                                                    repeat1(/[0-9]/))))))),
-    string_literal : $ => seq(
-                       '"',
-                       repeat(token.immediate(prec(1, /[^\\"\n\f\v\r]+/))),
-                       '"',
-                       ),
+  _decimal_literal : $ => token(seq(optional(/[-+]/), repeat1(/[0-9]/))),
+  _hexadecimal_literal : $ => token(seq('0x', repeat1(/[0-9a-fA-F]/))),
+  float_literal : $ =>
+      token(seq(optional(/[-+]/), repeat1(/[0-9]/), '.', repeat(/[0-9]/),
+                optional(seq(/[eE]/, optional(/[-+]/), repeat1(/[0-9]/))))),
+  string_literal : $ => token(seq('"', repeat(/[^\\"\n\f\v\r]+/), '"')),
+  bool_literal : $ => token(choice('true', 'false')),
+  unit_literal : $ => token('unit'),
+  complex_literal : $ =>
+      seq('(', choice($.integer_literal, $.float_literal), ',',
+          choice($.integer_literal, $.float_literal), ')'),
+  tensor_literal : $ =>
+      seq(token(choice('dense', 'sparse')), '<',
+          optional(choice(
+              seq($.nested_idx_list, repeat(seq(',', $.nested_idx_list))),
+              $._primitive_idx_literal)),
+          '>'),
+  array_literal : $ => seq(token('array'), '<', $.type, ':', $._idx_list, '>'),
+  _literal : $ => choice($.integer_literal, $.float_literal, $.string_literal,
+                         $.bool_literal, $.tensor_literal, $.array_literal,
+                         $.complex_literal, $.unit_literal),
+
+  nested_idx_list : $ =>
+      seq('[', optional(choice($.nested_idx_list, $._idx_list)),
+          repeat(seq(',', $.nested_idx_list)), ']'),
+  _idx_list : $ => prec.right(seq($._primitive_idx_literal,
+                                  repeat(seq(',', $._primitive_idx_literal)))),
+  _primitive_idx_literal : $ => choice($.integer_literal, $.float_literal,
+                                       $.bool_literal, $.complex_literal),
 
-    // Identifiers
-    //   bare-id ::= (letter|[_]) (letter|digit|[_$.])*
-    //   bare-id-list ::= bare-id (`,` bare-id)*
-    //   value-id ::= `%` suffix-id
-    //   suffix-id ::= (digit+ | ((letter|id-punct) (letter|id-punct|digit)*))
-    //   alias-name :: = bare-id
-    //
-    //   symbol-ref-id ::= `@` (suffix-id | string-literal) (`::`
-    //   symbol-ref-id)?
-    //   value-id-list ::= value-id (`,` value-id)*
-    //
-    //   // Uses of value, e.g. in an operand list to an operation.
-    //   value-use ::= value-id
-    //   value-use-list ::= value-use (`,` value-use)*
-    bare_id : $ => seq(token(/[a-zA-Z_]/),
-                       token.immediate(repeat(/[a-zA-Z0-9_$]/))),
-    bare_id_list : $ => seq($.bare_id, repeat(seq(',', $.bare_id))),
-    value_id : $ => seq('%', $._suffix_id),
-    alias_name : $ => $.bare_id,
-    _suffix_id : $ => choice(repeat1(/[0-9]/),
-                             seq(/[a-zA-Z_$.]/, repeat(/[a-zA-Z0-9_$.]/))),
-    symbol_ref_id : $ => seq('@', choice($._suffix_id, $.string_literal),
-                             optional(seq('::', $.symbol_ref_id))),
-    value_use : $ => $.value_id,
-    value_use_list : $ => seq($.value_use, repeat(seq(',', $.value_use))),
+  //                     symbol-ref-id)?
+  bare_id : $ => token(seq(/[a-zA-Z_]/, repeat(/[a-zA-Z0-9_$.]/))),
+  _alias_or_dialect_id : $ => token(seq(/[a-zA-Z_]/, repeat(/[a-zA-Z0-9_$]/))),
+  value_use : $ => seq('%', $._suffix_id),
+  _suffix_id : $ => token(seq(
+      choice(repeat1(/[0-9]/), seq(/[a-zA-Z_$.-]/, repeat(/[a-zA-Z0-9_$.-]/))),
+      optional(seq(choice(':', '#'), repeat1(/[0-9]/))))),
+  _value_use_list : $ => seq($.value_use, repeat(seq(',', $.value_use))),
 
-    // Operations
-    //   operation            ::= op-result-list? (generic-operation |
-    //                            custom-operation)
-    //                            trailing-location?
-    //   generic-operation    ::= string-literal `(` value-use-list? `)`
-    //   successor-list?
-    //                            region-list? dictionary-attribute? `:`
-    //                            function-type
-    //   custom-operation     ::= bare-id custom-operation-format
-    //   op-result-list       ::= op-result (`,` op-result)* `=`
-    //   op-result            ::= value-id (`:` integer-literal)
-    //   successor-list       ::= `[` successor (`,` successor)* `]`
-    //   successor            ::= caret-id (`:` bb-arg-list)?
-    //   region-list          ::= `(` region (`,` region)* `)`
-    //   dictionary-attribute ::= `{` (attribute-entry (`,` attribute-entry)*)?
-    //                            `}`
-    //   trailing-location    ::= (`loc` `(` location `)`)?
-    operation : $ => seq(optional($.op_result_list),
-                         choice($.generic_operation, $.custom_operation),
-                         optional($.trailing_location)),
-    generic_operation : $ =>
-                          seq($.string_literal, '(', optional($.value_use_list),
-                              ')', optional($.successor_list),
-                              optional($.region_list),
-                              optional($.dictionary_attribute), ':',
-                              $.function_type),
-    // custom-operation rule is defined later in the grammar, post the generic.
-    op_result_list : $ => seq($.op_result, repeat(seq(',', $.op_result)), '='),
-    op_result : $ => seq($.value_id, optional(seq(':', $.integer_literal))),
-    successor_list : $ => seq('[', $.successor, repeat(seq(',', $.successor)),
-                              ']'),
-    successor : $ => seq($.caret_id, optional(seq(':', $.block_arg_list))),
-    region_list : $ => seq('(', $.region, repeat(seq(',', $.region)), ')'),
-    dictionary_attribute : $ => seq(
-                             '{',
-                             optional(seq($.attribute_entry,
-                                          repeat(seq(',', $.attribute_entry)))),
-                             '}'),
-    trailing_location : $ => seq('loc(', $.location, ')'),
-    // TODO: Complete location forms.
-    location : $ => $.string_literal,
+  //                            successor-list? region-list?
+  //                            dictionary-attribute? `:` function-type
+  operation : $ =>
+      seq(field('lhs', optional($._op_result_list)),
+          field('rhs', choice($.generic_operation, $.custom_operation)),
+          field('location', optional($.trailing_location))),
+  generic_operation : $ => seq(
+      $.string_literal, $._value_use_list_parens, optional($._successor_list),
+      optional($._region_list), optional($.attribute), ':', $.function_type),
+  _op_result_list : $ => seq($.op_result, repeat(seq(',', $.op_result)), '='),
+  op_result : $ => seq($.value_use, optional(seq(':', $.integer_literal))),
+  _successor_list : $ =>
+      seq('[', $.successor, repeat(seq(',', $.successor)), ']'),
+  successor : $ => seq($.caret_id, optional($._value_arg_list)),
+  _region_list : $ => seq('(', $.region, repeat(seq(',', $.region)), ')'),
+  dictionary_attribute : $ => seq('{', optional($.attribute_entry),
+                                  repeat(seq(',', $.attribute_entry)), '}'),
+  trailing_location : $ => seq(token('loc'), '(', $.location, ')'),
 
-    // Blocks
-    //   block           ::= block-label operation+
-    //   block-label     ::= block-id block-arg-list? `:`
-    //   block-id        ::= caret-id
-    //   caret-id        ::= `^` suffix-id
-    //   value-id-and-type ::= value-id `:` type
-    //
-    //   // Non-empty list of names and types.
-    //   value-id-and-type-list ::= value-id-and-type (`,` value-id-and-type)*
-    //
-    //   block-arg-list ::= `(` value-id-and-type-list? `)`
-    block : $ => seq($.block_label, repeat1($.operation)),
-    block_label : $ => seq($._block_id, optional($.block_arg_list), ':'),
-    _block_id : $ => $.caret_id,
-    caret_id : $ => seq('^', $._suffix_id),
-    value_id_and_type : $ => seq($.value_id, ':', $.type),
-    value_id_and_type_list : $ => seq($.value_id_and_type,
-                                      repeat(seq(',', $.value_id_and_type))),
-    block_arg_list : $ => seq('(', optional($.value_id_and_type_list), ')'),
+  _value_use_and_type : $ => seq($.value_use, optional(seq(':', $.type))),
+  _value_use_and_type_list : $ =>
+      seq($._value_use_and_type, repeat(seq(',', $._value_use_and_type))),
+  block_arg_list : $ => seq('(', optional($._value_use_and_type_list), ')'),
+  _value_arg_list : $ => seq('(', optional($._value_use_type_list), ')'),
+  _value_use_type_list : $ => seq($._value_use_list, $._type_annotation),
 
-    // Regions
-    //   region      ::= `{` entry-block? block* `}`
-    //   entry-block ::= operation+
-    region : $ => seq('{', optional($.entry_block), repeat($.block), '}'),
-    entry_block : $ => repeat1($.operation),
 
-    // Types
-    //   type ::= type-alias | dialect-type | builtin-type
-    //
-    //   type-list-no-parens ::=  type (`,` type)*
-    //   type-list-parens ::= `(` type-list-no-parens? `)`
-    //
-    //   // This is a common way to refer to a value with a specified type.
-    //   ssa-use-and-type ::= ssa-use `:` type
-    //   ssa-use ::= value-use
-    //
-    //   // Non-empty list of names and types.
-    //   ssa-use-and-type-list ::= ssa-use-and-type (`,` ssa-use-and-type)*
-    //
-    //   function-type ::= (type | type-list-parens) `->` (type |
-    //   type-list-parens)
-    type : $ => choice($.type_alias, $.dialect_type, $.builtin_type),
-    type_list_no_parens : $ => seq($.type, repeat(seq(',', $.type))),
-    type_list_parens : $ => seq('(', optional($.type_list_no_parens), ')'),
-    ssa_use_and_type : $ => seq($.ssa_use, ':', $.type),
-    ssa_use : $ => $.value_use,
-    ssa_use_and_type_list : $ => seq($.ssa_use_and_type,
-                                     repeat(seq(',', $.ssa_use_and_type))),
-    function_type : $ => seq(choice($.type, $.type_list_parens), '->',
-                             choice($.type, $.type_list_parens)),
+  //                      type-list-parens)
+  _type_list_no_parens : $ => prec.left(seq($.type, repeat(seq(',', $.type)))),
+  _type_list_parens : $ => seq('(', optional($._type_list_no_parens), ')'),
+  function_type : $ =>
+      seq(choice($.type, $._type_list_parens), $._function_return),
+  _function_return : $ => seq(token('->'), choice($.type, $._type_list_parens)),
+  _type_annotation : $ =>
+      seq(':', choice(seq($.type, choice('from', 'into', 'to'), $.type),
+                      $._type_list_no_parens)),
+  _function_type_annotation : $ => seq(':', $.function_type),
+  _literal_and_type : $ => seq($._literal, optional($._type_annotation)),
 
-    // Type aliases
-    //   type-alias-def ::= '!' alias-name '=' type
-    //   type-alias ::= '!' alias-name
-    type_alias_def : $ => seq('!', $.alias_name, '=', $.type),
-    type_alias : $ => seq('!', $.alias_name),
+  type_alias_def : $ => seq('!', $._alias_or_dialect_id, '=', $.type),
+  type_alias : $ => seq('!', $._alias_or_dialect_id),
 
-    // Dialect Types
-    //   dialect-namespace ::= bare-id
-    //
-    //   opaque-dialect-item ::= dialect-namespace '<' string-literal '>'
-    //
-    //   pretty-dialect-item ::= dialect-namespace '.'
-    //   pretty-dialect-item-lead-ident
-    //                                                 pretty-dialect-item-body?
-    //
-    //   pretty-dialect-item-lead-ident ::= '[A-Za-z][A-Za-z0-9._]*'
-    //   pretty-dialect-item-body ::= '<' pretty-dialect-item-contents+ '>'
-    //   pretty-dialect-item-contents ::= pretty-dialect-item-body
-    //                                 | '(' pretty-dialect-item-contents+ ')'
-    //                                 | '[' pretty-dialect-item-contents+ ']'
-    //                                 | '{' pretty-dialect-item-contents+ '}'
-    //                                 | '[^[<({>\])}\0]+'
-    //
-    //   dialect-type ::= '!' (opaque-dialect-item | pretty-dialect-item)
-    dialect_type : $ => seq(
-                     '!', choice($.opaque_dialect_item, $.pretty_dialect_item)),
-    dialect_namespace : $ => $.bare_id,
-    opaque_dialect_item : $ => seq($.dialect_namespace, '<', $.string_literal,
-                                   '>'),
-    pretty_dialect_item : $ => seq($.dialect_namespace, '.',
-                                   $.pretty_dialect_item_lead_ident,
-                                   optional($.pretty_dialect_item_body)),
-    pretty_dialect_item_lead_ident : $ => $.bare_id,
-    pretty_dialect_item_body : $ => seq('<',
-                                        repeat1($.pretty_dialect_item_contents),
-                                        '>'),
-    // TODO: not sure why prec.left (setting left-associated parsing) needed
-    // here,
-    // left-associated way avoids an ambiguity flagged by generator. It may not
-    // be needed and be only papering over an issue.
-    pretty_dialect_item_contents : $ => prec.left(choice(
-                                     $.pretty_dialect_item_body,
-                                     seq('(',
-                                         repeat1(
-                                             $.pretty_dialect_item_contents),
-                                         ')'),
-                                     seq('[',
-                                         repeat1(
-                                             $.pretty_dialect_item_contents),
-                                         ']'),
-                                     seq('{',
-                                         repeat1(
-                                             $.pretty_dialect_item_contents),
-                                         '}'),
-                                     repeat1(/[^\[<({>\])}\\0]/))),
-    dialect_type : $ => seq(
-                     '!', choice($.opaque_dialect_item, $.pretty_dialect_item)),
+  //   pretty-dialect-item-lead-ident pretty-dialect-item-body?
+  dialect_type : $ =>
+      seq('!', choice($.opaque_dialect_item, $.pretty_dialect_item)),
+  dialect_namespace : $ => $._alias_or_dialect_id,
+  dialect_ident : $ => $._alias_or_dialect_id,
+  opaque_dialect_item : $ =>
+      seq($.dialect_namespace, '<', $.string_literal, '>'),
+  pretty_dialect_item : $ => seq($.dialect_namespace, '.', $.dialect_ident,
+  pretty_dialect_item_body : $ =>
+      seq('<', repeat($._pretty_dialect_item_contents), '>'),
+  _pretty_dialect_item_contents : $ =>
+      prec.left(choice($.pretty_dialect_item_body, repeat1(/[^<>]/))),
 
-    // Builtin types
-    builtin_type : $ => choice(
-                     // TODO: Add builtin types
-                     seq('i', repeat1(/[0-9]/))),
+      // TODO: Add opaque_type
+      $.integer_type, $.float_type, $.complex_type, $.index_type, $.memref_type,
+      $.none_type, $.tensor_type, $.vector_type, $.tuple_type),
+
+  // signed-integer-type ::= `si`[1-9][0-9]*
+  // unsigned-integer-type ::= `ui`[1-9][0-9]*
+  // signless-integer-type ::= `i`[1-9][0-9]*
+  // integer-type ::= signed-integer-type | unsigned-integer-type |
+  // signless-integer-type
+  integer_type : $ =>
+      token(seq(choice('si', 'ui', 'i'), /[1-9]/, repeat(/[0-9]/))),
+  float_type : $ => token(
+      choice('f16', 'f32', 'f64', 'f80', 'f128', 'bf16', 'f8E4M3FN', 'f8E5M2')),
+  index_type : $ => token('index'),
+  none_type : $ => token('none'),
+  complex_type : $ => seq(token('complex'), '<', $._prim_type, '>'),
+  _prim_type : $ =>
+      choice($.integer_type, $.float_type, $.index_type, $.complex_type,
+             $.none_type, $.memref_type, $.vector_type, $.tensor_type),
+
+  // memref-type ::= `memref` `<` dimension-list-ranked type
+  //                 (`,` layout-specification)? (`,` memory-space)? `>`
+  // layout-specification ::= attribute-value
+  // memory-space ::= attribute-value
+  memref_type : $ =>
+      seq(token('memref'), '<', field('dimension_list', $.dim_list),
+          optional(seq(',', $.attribute_value)),
+          optional(seq(',', $.attribute_value)), '>'),
+  dim_list : $ => seq($._dim_primitive, repeat(seq('x', $._dim_primitive))),
+  _dim_primitive : $ => choice($._prim_type, repeat1($._digit), '?', '*'),
+
+  // tensor-type ::= `tensor` `<` dimension-list type (`,` encoding)? `>`
+  // dimension-list ::= (dimension `x`)*
+  // dimension ::= `?` | decimal-literal
+  // encoding ::= attribute-value
+  // tensor-type ::= `tensor` `<` `*` `x` type `>`
+  tensor_type : $ => seq(token('tensor'), '<', $.dim_list,
+                         optional(seq(',', $.tensor_encoding)), '>'),
+  tensor_encoding : $ => $.attribute_value,
+
+  // vector-type ::= `vector` `<` vector-dim-list vector-element-type `>`
+  // vector-element-type ::= float-type | integer-type | index-type
+  // vector-dim-list := (static-dim-list `x`)? (`[` static-dim-list `]` `x`)?
+  // static-dim-list ::= decimal-literal (`x` decimal-literal)*
+  vector_type : $ =>
+      seq(token('vector'), '<', optional($.vector_dim_list), $._prim_type, '>'),
+  vector_dim_list : $ =>
+      choice(seq($._static_dim_list, 'x',
+                 optional(seq('[', $._static_dim_list, ']', 'x'))),
+             seq('[', $._static_dim_list, ']', 'x')),
+  _static_dim_list : $ =>
+      seq(repeat1($._digit), repeat(seq('x', repeat1($._digit)))),
+
+  // tuple-type ::= `tuple` `<` (type ( `,` type)*)? `>`
+  tuple_type : $ =>
+      seq(token('tuple'), '<', $.tuple_dim, repeat(seq(',', $.tuple_dim)), '>'),
+  tuple_dim : $ => $._prim_type,
 
-    // Attributes
-    //   attribute-entry ::= (bare-id | string-literal) `=` attribute-value
-    //   attribute-value ::= attribute-alias | dialect-attribute |
-    //   builtin-attribute
-    attribute_entry : $ => seq(choice($.bare_id, $.string_literal), '=',
-                               $.attribute_value),
-    attribute_value : $ => choice($.attribute_alias, $.dialect_attribute,
-                                  $.builtin_attribute),
+  attribute_entry : $ => seq(choice($.bare_id, $.string_literal),
+                             optional(seq('=', $.attribute_value))),
+  attribute_value : $ =>
+      choice(seq('[', optional($._attribute_value_nobracket),
+                 repeat(seq(',', $._attribute_value_nobracket)), ']'),
+             $._attribute_value_nobracket),
+  _attribute_value_nobracket : $ =>
+      choice($.attribute_alias, $.dialect_attribute, $.builtin_attribute,
+             $.dictionary_attribute, $._literal_and_type, $.type),
+  attribute : $ => choice($.attribute_alias, $.dialect_attribute,
+                          $.builtin_attribute, $.dictionary_attribute),
 
-    // Attribute Value Aliases
-    //   attribute-alias-def ::= '#' alias-name '=' attribute-value
-    //   attribute-alias ::= '#' alias-name
-    attribute_alias_def : $ => seq('#', $.alias_name, '=', $.attribute_value),
-    attribute_alias : $ => seq('#', $.alias_name),
+  attribute_alias_def : $ =>
+      seq('#', $._alias_or_dialect_id, '=', $.attribute_value),
+  attribute_alias : $ => seq('#', $._alias_or_dialect_id),
 
-    // Dialect Attribute Values
-    dialect_attribute : $ => seq('#', choice($.opaque_dialect_item,
-                                             $.pretty_dialect_item)),
+  dialect_attribute : $ =>
+      seq('#', choice($.opaque_dialect_item, $.pretty_dialect_item)),
 
-    // Builtin Attribute Values
-    builtin_attribute : $ => choice(
-                          // TODO
-                          $.function_type,
-                          $.string_literal,
-                          ),
+      $.strided_layout, $.affine_map, $.affine_set),
+  strided_layout : $ => seq(token('strided'), '<', '[', $._dim_list_comma, ']',
+                            optional(seq(',', token('offset'), ':',
+                                         choice($.integer_literal, '?', '*'))),
+                            '>'),
+  _dim_list_comma : $ =>
+      seq($._dim_primitive, repeat(seq(',', $._dim_primitive))),
+
+  affine_map : $ =>
+      seq(token('affine_map'), '<', $._multi_dim_affine_expr_parens,
+          optional($._multi_dim_affine_expr_sq), token('->'),
+          $._multi_dim_affine_expr_parens, '>'),
+  affine_set : $ =>
+      seq(token('affine_set'), '<', $._multi_dim_affine_expr_parens,
+          optional($._multi_dim_affine_expr_sq), ':',
+          $._multi_dim_affine_expr_parens, '>'),
+  _multi_dim_affine_expr_parens : $ =>
+      seq('(', optional($._multi_dim_affine_expr), ')'),
+  _multi_dim_affine_expr_sq : $ =>
+      seq('[', optional($._multi_dim_affine_expr), ']'),
+
+  // affine-expr ::= `(` affine-expr `)`
+  //               | affine-expr `+` affine-expr
+  //               | affine-expr `-` affine-expr
+  //               | `-`? integer-literal `*` affine-expr
+  //               | affine-expr `ceildiv` integer-literal
+  //               | affine-expr `floordiv` integer-literal
+  //               | affine-expr `mod` integer-literal
+  //               | `-`affine-expr
+  //               | bare-id
+  //               | `-`? integer-literal
+  // multi-dim-affine-expr ::= `(` `)`
+  //                         | `(` affine-expr (`,` affine-expr)* `)`
+
+  // semi-affine-expr ::= `(` semi-affine-expr `)`
+  //                    | semi-affine-expr `+` semi-affine-expr
+  //                    | semi-affine-expr `-` semi-affine-expr
+  //                    | symbol-or-const `*` semi-affine-expr
+  //                    | semi-affine-expr `ceildiv` symbol-or-const
+  //                    | semi-affine-expr `floordiv` symbol-or-const
+  //                    | semi-affine-expr `mod` symbol-or-const
+  //                    | bare-id
+  //                    | `-`? integer-literal
+  // symbol-or-const ::= `-`? integer-literal | symbol-id
+  // multi-dim-semi-affine-expr ::= `(` semi-affine-expr (`,` semi-affine-expr)*
+  // `)`
+
+  // affine-constraint ::= affine-expr `>=` `affine-expr`
+  //                     | affine-expr `<=` `affine-expr`
+  //                     | affine-expr `==` `affine-expr`
+  // affine-constraint-conjunction ::= affine-constraint (`,`
+  // affine-constraint)*
+
+  _multi_dim_affine_expr : $ =>
+      seq($._affine_expr, repeat(seq(',', $._affine_expr))),
+  _affine_expr : $ => prec.right(choice(
+      seq('(', $._affine_expr, ')'), seq('-', $._affine_expr),
+      seq($._affine_expr, $._affine_token, $._affine_expr), $._affine_prim)),
+  _affine_prim : $ =>
+      choice($.integer_literal, $.value_use, $.bare_id,
+             seq('symbol', '(', $.value_use, ')'),
+             seq(choice('max', 'min'), '(', $._value_use_list, ')')),
+  _affine_token : $ => token(
+      choice('+', '-', '*', 'ceildiv', 'floordiv', 'mod', '==', '>=', '<=')),
+
+  func_return : $ => seq(token('->'), $.type_list_attr_parens),
+  func_arg_list : $ => seq(
+      '(', optional(choice($.variadic, $._value_id_and_type_attr_list)), ')'),
+  _value_id_and_type_attr_list : $ => seq(
+      $._value_id_and_type_attr, repeat(seq(',', $._value_id_and_type_attr)),
+      optional(seq(',', $.variadic))),
+  _value_id_and_type_attr : $ => seq($._function_arg, optional($.attribute)),
+  _function_arg : $ =>
+      choice(seq($.value_use, ':', $.type), $.value_use, $.type),
+  type_list_attr_parens : $ =>
+      choice($.type,
+             seq('(', $.type, optional($.attribute),
+                 repeat(seq(',', $.type, optional($.attribute))), ')'),
+             seq('(', ')')),
+  variadic : $ => token('...'),
+
+  // (func.func|llvm.func) takes arguments, an optional return type, and and
+  // optional body
+  _op_func : $ =>
+      seq(field('visibility', optional('private')),
+          field('name', $.symbol_ref_id), field('arguments', $.func_arg_list),
+          field('return', optional($.func_return)),
+          field('attributes', optional(seq(token('attributes'), $.attribute))),
+          field('body', optional($.region))),
+
+  // dim-use-list ::= `(` ssa-use-list? `)`
+  // symbol-use-list ::= `[` ssa-use-list? `]`
+  // dim-and-symbol-use-list ::= dim-use-list symbol-use-list?
+  _value_use_list_parens : $ => seq('(', optional($._value_use_list), ')'),
+  _dim_and_symbol_use_list : $ =>
+      seq($._value_use_list_parens, optional($._dense_idx_list)),
+
+  // assignment-list ::= assignment | assignment `,` assignment-list
+  // assignment ::= ssa-value `=` ssa-value
+  _value_assignment_list : $ => seq('(', optional($._value_assignment),
+                                    repeat(seq(',', $._value_assignment)), ')'),
+  _value_assignment : $ => seq($.value_use, '=', $.value_use),
+
+  _dense_idx_list : $ => seq(
+      '[',
+      optional(seq(choice($.integer_literal, $.value_use),
+                   repeat(seq(',', choice($.integer_literal, $.value_use))))),
+      ']'),
+
+  // lower-bound ::= `max`? affine-map-attribute dim-and-symbol-use-list |
+  // shorthand-bound
+  // upper-bound ::= `min`? affine-map-attribute dim-and-symbol-use-list |
+  // shorthand-bound
+  // shorthand-bound ::= ssa-id | `-`? integer-literal
+  _bound : $ =>
+      choice(seq($.attribute, $._dim_and_symbol_use_list), $._shorthand_bound),
+  _shorthand_bound : $ => choice($.value_use, $.integer_literal),
+
+  // Dialect-specific attributes
+  restrict_attr : $ => token('restrict'),
+  writable_attr : $ => token('writable'),
+  gather_dims_attr : $ =>
+      seq(token('gather_dims'), '(', $._dense_idx_list, ')'),
+  scatter_dims_attr : $ =>
+      seq(token('scatter_dims'), '(', $._dense_idx_list, ')'),
+  unique_attr : $ => token('unique'),
+  nofold_attr : $ => token('nofold'),
+  outer_dims_perm_attr : $ =>
+      seq(token('outer_dims_perm'), '=', $._dense_idx_list),
+  inner_dims_pos_attr : $ =>
+      seq(token('inner_dims_pos'), '=', $._dense_idx_list),
+  inner_tiles_attr : $ => seq(token('inner_tiles'), '=', $._dense_idx_list),
+  isWrite_attr : $ => token(choice('read', 'write')),
+  localityHint_attr : $ => seq(token('locality'), '<', $.integer_literal, '>'),
+  isDataCache_attr : $ => token(choice('data', 'instr')),
+  fastmath_attr : $ =>
+      seq(token('fastmath'), '<',
+          seq($._fastmath_flag, repeat(seq(',', $._fastmath_flag))), '>'),
+  _fastmath_flag : $ => token(choice('none', 'reassoc', 'nnan', 'ninf', 'nsz',
+                                     'arcp', 'contract', 'afn', 'fast')),
 
-    // Comment (standard BCPL)
-    comment : $ => token(seq('//', /.*/)),
 
-    custom_operation : $ => choice(
-                         // TODO: Just basic/incomplete instance.
-                         seq('func', field('name', $.symbol_ref_id),
-                             $.block_arg_list, '->', $.type, $.region),
-                         ),
-  }
+  // TODO: complete
+  custom_operation : $ =>
+      choice($.builtin_dialect, $.func_dialect, $.llvm_dialect, $.arith_dialect,
+             $.math_dialect, $.cf_dialect, $.scf_dialect, $.memref_dialect,
+             $.vector_dialect, $.tensor_dialect, $.bufferization_dialect,
+             $.affine_dialect, $.linalg_dialect)
+
+               module.exports = grammar({
+  name : 'mlir',
+  extras : $ => [/\s/, $.comment],
+  conflicts : $ => [[ $._static_dim_list, $._static_dim_list ],
+                    [ $.dictionary_attribute, $.region ]],
+  rules : Object.assign(common, builtin_dialect, func_dialect, llvm_dialect,
+                        arith_dialect, math_dialect, cf_dialect, scf_dialect,
+                        memref_dialect, vector_dialect, tensor_dialect,
+                        bufferization_dialect, affine_dialect, linalg_dialect)
 });

mlir/utils/tree-sitter-mlir/package-lock.json

+{
+  "name": "tree-sitter-mlir",
+  "version": "0.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "tree-sitter-mlir",
+      "version": "0.0.1",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "nan": "^2.17.0"
+      },
+      "devDependencies": {
+        "glob": "^8.1.0",
+        "tree-sitter-cli": "^0.20.7"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
+      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true
+    },
+    "node_modules/glob": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+      "dev": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "dev": true,
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "dev": true
+    },
+    "node_modules/minimatch": {
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/nan": {
+      "version": "2.17.0",
+      "resolved": "https://registry.npmjs.org/nan/-/nan-2.17.0.tgz",
+      "integrity": "sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ=="
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dev": true,
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/tree-sitter-cli": {
+      "version": "0.20.7",
+      "resolved": "https://registry.npmjs.org/tree-sitter-cli/-/tree-sitter-cli-0.20.7.tgz",
+      "integrity": "sha512-MHABT8oCPr4D0fatsPo6ATQ9H4h9vHpPRjlxkxJs80tpfAEKGn6A1zU3eqfCKBcgmfZDe9CiL3rKOGMzYHwA3w==",
+      "dev": true,
+      "hasInstallScript": true,
+      "bin": {
+        "tree-sitter": "cli.js"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "dev": true
+    }
+  }
+}

mlir/utils/tree-sitter-mlir/package.json

+{
+  "name": "tree-sitter-mlir",
+  "description": "Tree sitter grammar for MLIR",
+  "version": "0.0.1",
+  "license": "Apache-2.0",
+  "main": "grammar.js",
+  "scripts": {
+    "compile": "tree-sitter generate",
+    "update-tests": "tree-sitter test --update",
+    "test": "tree-sitter test"
+  },
+  "keywords": [
+    "tree-sitter",
+    "lexer",
+    "parser",
+    "grammar"
+  ],
+  "dependencies": {
+    "nan": "^2.17.0"
+  },
+  "devDependencies": {
+    "glob": "^8.1.0",
+    "tree-sitter-cli": "^0.20.7"
+  },
+  "tree-sitter": [
+    {
+      "scope": "source.mlir",
+      "file-types": [
+        "mlir"
+      ]
+    }
+  ]
+}

mlir/utils/tree-sitter-mlir/queries/highlights.scm

+[
+  "ins"
+  "outs"
+  "else"
+  "do"
+  "loc"
+  "attributes"
+  "into"
+  "to"
+  "from"
+  "step"
+  "low"
+  "high"
+  "iter_args"
+  "padding_value"
+  "inner_tiles"
+  "gather_dims"
+  "scatter_dims"
+  "outer_dims_perm"
+  "inner_dims_pos"
+  "shared_outs"
+  "default"
+
+  "eq"
+  "ne"
+  "oeq"
+  "olt"
+  "ole"
+  "ogt"
+  "oge"
+  "slt"
+  "sle"
+  "sgt"
+  "sge"
+  "ult"
+  "ule"
+  "ugt"
+  "uge"
+] @keyword
+
+[
+  "module"
+  "unrealized_conversion_cast"
+
+  "func.call"
+  "call"
+  "func.call_indirect"
+  "call_indirect"
+  "func.constant"
+  "constant"
+  "func.func"
+  "func.return"
+  "return"
+
+  "llvm.func"
+  "llvm.return"
+
+  "cf.assert"
+  "cf.br"
+  "cf.cond_br"
+  "cf.switch"
+
+  "scf.condition"
+  "scf.execute_region"
+  "scf.if"
+  "scf.index_switch"
+  "scf.for"
+  "scf.forall"
+  "scf.forall.in_parallel"
+  "scf.parallel"
+  "scf.reduce"
+  "scf.reduce.return"
+  "scf.while"
+  "scf.yield"
+
+  "arith.constant"
+  "arith.addi"
+  "arith.subi"
+  "arith.divsi"
+  "arith.divui"
+  "arith.ceildivsi"
+  "arith.ceildivui"
+  "arith.floordivsi"
+  "arith.remsi"
+  "arith.remui"
+  "arith.muli"
+  "arith.mulsi_extended"
+  "arith.mului_extended"
+  "arith.andi"
+  "arith.ori"
+  "arith.xori"
+  "arith.maxsi"
+  "arith.maxui"
+  "arith.minsi"
+  "arith.minui"
+  "arith.shli"
+  "arith.shrsi"
+  "arith.shrui"
+  "arith.addui_extended"
+  "arith.addf"
+  "arith.divf"
+  "arith.maxf"
+  "arith.minf"
+  "arith.mulf"
+  "arith.remf"
+  "arith.subf"
+  "arith.negf"
+  "arith.cmpi"
+  "arith.cmpf"
+  "arith.extf"
+  "arith.extsi"
+  "arith.extui"
+  "arith.fptosi"
+  "arith.fptoui"
+  "arith.index_cast"
+  "arith.index_castui"
+  "arith.sitofp"
+  "arith.uitofp"
+  "arith.bitcast"
+  "arith.truncf"
+  "arith.select"
+
+  "math.absf"
+  "math.atan"
+  "math.cbrt"
+  "math.ceil"
+  "math.cos"
+  "math.erf"
+  "math.exp"
+  "math.exp2"
+  "math.expm1"
+  "math.floor"
+  "math.log"
+  "math.log10"
+  "math.log1p"
+  "math.log2"
+  "math.round"
+  "math.roundeven"
+  "math.rsqrt"
+  "math.sin"
+  "math.sqrt"
+  "math.tan"
+  "math.tanh"
+  "math.trunc"
+  "math.absi"
+  "math.ctlz"
+  "math.cttz"
+  "math.ctpop"
+  "math.atan2"
+  "math.copysign"
+  "math.fpowi"
+  "math.powf"
+  "math.ipowi"
+  "math.fma"
+
+  "memref.alloc"
+  "memref.cast"
+  "memref.copy"
+  "memref.collapse_shape"
+  "memref.expand_shape"
+  "memref.prefetch"
+  "memref.rank"
+  "memref.realloc"
+  "memref.view"
+
+  "vector.bitcast"
+  "vector.broadcast"
+  "vector.shape_cast"
+  "vector.type_cast"
+  "vector.constant_mask"
+  "vector.create_mask"
+  "vector.extract"
+  "vector.load"
+  "vector.scalable.extract"
+  "vector.fma"
+  "vector.flat_transpose"
+  "vector.insert"
+  "vector.scalable.insert"
+  "vector.shuffle"
+  "vector.store"
+  "vector.insert_strided_slice"
+  "vector.matrix_multiply"
+  "vector.print"
+  "vector.splat"
+  "vector.transfer_read"
+  "vector.transfer_write"
+  "vector.yield"
+
+  "tensor.empty"
+  "tensor.cast"
+  "tensor.dim"
+  "tensor.collapse_shape"
+  "tensor.expand_shape"
+  "tensor.extract"
+  "tensor.insert"
+  "tensor.extract_slice"
+  "tensor.insert_slice"
+  "tensor.parallel_insert_slice"
+  "tensor.from_elements"
+  "tensor.gather"
+  "tensor.scatter"
+  "tensor.pad"
+  "tensor.reshape"
+  "tensor.splat"
+  "tensor.pack"
+  "tensor.unpack"
+  "tensor.generate"
+  "tensor.rank"
+  "tensor.yield"
+
+  "bufferization.alloc_tensor"
+  "bufferization.to_memref"
+  "bufferization.to_tensor"
+
+  "linalg.batch_matmul"
+  "linalg.batch_matmul_transpose_b"
+  "linalg.batch_matvec"
+  "linalg.batch_reduce_matmul"
+  "linalg.broadcast"
+  "linalg.conv_1d_ncw_fcw"
+  "linalg.conv_1d_nwc_wcf"
+  "linalg.conv_1d"
+  "linalg.conv_2d_nchw_fchw"
+  "linalg.conv_2d_ngchw_fgchw"
+  "linalg.conv_2d_nhwc_fhwc"
+  "linalg.conv_2d_nhwc_hwcf"
+  "linalg.conv_2d_nhwc_hwcf_q"
+  "linalg.conv_2d"
+  "linalg.conv_3d_ndhwc_dhwcf"
+  "linalg.conv_3d_ndhwc_dhwcf_q"
+  "linalg.conv_3d"
+  "linalg.copy"
+  "linalg.depthwise_conv_1d_nwc_wcm"
+  "linalg.depthwise_conv_2d_nchw_chw"
+  "linalg.depthwise_conv_2d_nhwc_hwc"
+  "linalg.depthwise_conv_2d_nhwc_hwc_q"
+  "linalg.depthwise_conv_2d_nhwc_hwcm"
+  "linalg.depthwise_conv_2d_nhwc_hwcm_q"
+  "linalg.depthwise_conv_3d_ndhwc_dhwc"
+  "linalg.depthwise_conv_3d_ndhwc_dhwcm"
+  "linalg.dot"
+  "linalg.elemwise_binary"
+  "linalg.elemwise_unary"
+  "linalg.fill"
+  "linalg.fill_rng_2d"
+  "linalg.matmul"
+  "linalg.matmul_transpose_b"
+  "linalg.matmul_unsigned"
+  "linalg.matvec"
+  "linalg.mmt4d"
+  "linalg.pooling_nchw_max"
+  "linalg.pooling_nchw_sum"
+  "linalg.pooling_ncw_max"
+  "linalg.pooling_ncw_sum"
+  "linalg.pooling_ndhwc_max"
+  "linalg.pooling_ndhwc_min"
+  "linalg.pooling_ndhwc_sum"
+  "linalg.pooling_nhwc_max"
+  "linalg.pooling_nhwc_max_unsigned"
+  "linalg.pooling_nhwc_min"
+  "linalg.pooling_nhwc_min_unsigned"
+  "linalg.pooling_nhwc_sum"
+  "linalg.pooling_nwc_max"
+  "linalg.pooling_nwc_max_unsigned"
+  "linalg.pooling_nwc_min"
+  "linalg.pooling_nwc_min_unsigned"
+  "linalg.pooling_nwc_sum"
+  "linalg.quantized_batch_matmul"
+  "linalg.quantized_matmul"
+  "linalg.vecmat"
+  "linalg.generic"
+  "linalg.index"
+  "linalg.map"
+  "linalg.yield"
+] @function.builtin
+
+(generic_operation) @function
+
+(builtin_type) @type.builtin
+
+[
+  (type_alias)
+  (dialect_type)
+  (type_alias_def)
+] @type
+
+[
+  (integer_literal)
+  (float_literal)
+  (complex_literal)
+] @number
+
+[
+  (bool_literal)
+  (tensor_literal)
+  (array_literal)
+  (unit_literal)
+] @constant.builtin
+
+(string_literal) @string
+
+[
+  (attribute_alias_def)
+  (attribute_alias)
+  (bare_attribute_entry)
+  (attribute)
+  (fastmath_attr)
+  (scatter_dims_attr)
+  (gather_dims_attr)
+  (outer_dims_perm_attr)
+  (inner_dims_pos_attr)
+  (inner_tiles_attr)
+  (unique_attr)
+  (nofold_attr)
+  (isWrite_attr)
+  (localityHint_attr)
+  (isDataCache_attr)
+  (restrict_attr)
+  (writable_attr)
+] @attribute
+
+[
+  "("
+  ")"
+  "{"
+  "}"
+  "["
+  "]"
+] @punctuation.bracket
+
+[
+  ":"
+  ","
+] @punctuation.delimeter
+
+[
+  "="
+  "->"
+] @operator
+
+(func_dialect name: (symbol_ref_id) @function)
+(llvm_dialect name: (symbol_ref_id) @function)
+
+(func_arg_list (value_use) @variable.parameter)
+(block_arg_list (value_use) @variable.parameter)
+
+(caret_id) @tag
+(value_use) @variable
+(comment) @comment

mlir/utils/tree-sitter-mlir/queries/locals.scm

+(region) @local.scope
+
+(func_arg_list (value_use) @local.definition)
+(block_arg_list (value_use) @local.definition)
+(op_result (value_use) @local.definition)
+
+(value_use) @local.reference

mlir/utils/tree-sitter-mlir/test/corpus/affine.txt

+================================================================================
+affine_map with indexing and sum
+================================================================================
+#inline_map_minmax_loop2 = affine_map<()[s0] -> (100, s0 + 1)>
+#map0 = affine_map<(i) -> ()>
+#bound_map1 = affine_map<(i, j)[s] -> (i + j + s)>
+--------------------------------------------------------------------------------
+
+(toplevel
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)
+          (integer_literal)
+          (bare_id)
+          (integer_literal)))))
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)))))
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)
+          (bare_id)
+          (bare_id)
+          (bare_id)
+          (bare_id)
+          (bare_id))))))
+
+================================================================================
+affine_set expression
+================================================================================
+#set0 = affine_set<(i)[N, M] : (i >= 0, -i + N >= 0, N - 5 == 0, -i + M + 1 >= 0)>
+--------------------------------------------------------------------------------
+
+(toplevel
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_set
+          (bare_id)
+          (bare_id)
+          (bare_id)
+          (bare_id)
+          (integer_literal)
+          (bare_id)
+          (bare_id)
+          (integer_literal)
+          (bare_id)
+          (integer_literal)
+          (integer_literal)
+          (bare_id)
+          (bare_id)
+          (integer_literal)
+          (integer_literal))))))
+
+================================================================================
+affine.min and affine.max with non-trivial affine maps
+================================================================================
+func.func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) {
+  %0 = affine.min affine_map<(d0)[s0] -> (1000, d0 + 512, s0)> (%arg0)[%arg1]
+  %1 = affine.min affine_map<(d0, d1)[s0] -> (d0 - d1, s0 + 512)> (%arg0, %arg1)[%arg2]
+  %2 = affine.min affine_map<()[s0, s1] -> (s0 - s1, 11)> ()[%arg1, %arg2]
+  %3 = affine.min affine_map<()[] -> (77, 78, 79)> ()[]
+  return
+}
+
+func.func @affine_max(%arg0 : index, %arg1 : index, %arg2 : index) {
+  %0 = affine.max affine_map<(d0)[s0] -> (1000, d0 + 512, s0)> (%arg0)[%arg1]
+  %1 = affine.max affine_map<(d0, d1)[s0] -> (d0 - d1, s0 + 512)> (%arg0, %arg1)[%arg2]
+  %2 = affine.max affine_map<()[s0, s1] -> (s0 - s1, 11)> ()[%arg1, %arg2]
+  %3 = affine.max affine_map<()[] -> (77, 78, 79)> ()[]
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_map
+                        (bare_id)
+                        (bare_id)
+                        (integer_literal)
+                        (bare_id)
+                        (integer_literal)
+                        (bare_id))))
+                  (value_use)
+                  (value_use))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_map
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (integer_literal))))
+                  (value_use)
+                  (value_use)
+                  (value_use))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_map
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (integer_literal))))
+                  (value_use)
+                  (value_use))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_map
+                        (integer_literal)
+                        (integer_literal)
+                        (integer_literal)))))))
+            (operation
+              (custom_operation
+                (func_dialect))))))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_map
+                        (bare_id)
+                        (bare_id)
+                        (integer_literal)
+                        (bare_id)
+                        (integer_literal)
+                        (bare_id))))
+                  (value_use)
+                  (value_use))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_map
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (integer_literal))))
+                  (value_use)
+                  (value_use)
+                  (value_use))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_map
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (integer_literal))))
+                  (value_use)
+                  (value_use))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_map
+                        (integer_literal)
+                        (integer_literal)
+                        (integer_literal)))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+affine.dma_start and affine.dma_wait with complicated affine expressions
+================================================================================
+func.func @test4(%arg0 : index, %arg1 : index) {
+  %0 = memref.alloc() : memref<100x100xf32>
+  %1 = memref.alloc() : memref<100x100xf32, 2>
+  %2 = memref.alloc() : memref<1xi32>
+  %c64 = arith.constant 64 : index
+  affine.for %i0 = 0 to 10 {
+    affine.for %i1 = 0 to 10 {
+      affine.dma_start %0[(%i0 + symbol(%arg0)) floordiv 3, %i1],
+                       %1[%i0, (%i1 + symbol(%arg1)) mod 9 + 7],
+                       %2[%i0 + %i1 + 11], %c64
+        : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
+      affine.dma_wait %2[%i0 + %i1 + 11], %c64 : memref<1xi32>
+    }
+  }
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (integer_literal))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (custom_operation
+                (affine_dialect
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (affine_dialect
+                            (value_use)
+                            (integer_literal)
+                            (integer_literal)
+                            (region
+                              (entry_block
+                                (operation
+                                  (custom_operation
+                                    (affine_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (integer_literal)
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (integer_literal)
+                                      (integer_literal)
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (integer_literal)
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (memref_type
+                                            (dim_list
+                                              (float_type)))))
+                                      (type
+                                        (builtin_type
+                                          (memref_type
+                                            (dim_list
+                                              (float_type))
+                                            (attribute_value
+                                              (integer_literal)))))
+                                      (type
+                                        (builtin_type
+                                          (memref_type
+                                            (dim_list
+                                              (integer_type))))))))
+                                (operation
+                                  (custom_operation
+                                    (affine_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (integer_literal)
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (memref_type
+                                            (dim_list
+                                              (integer_type))))))))))))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+affine_map with complex affine expression
+================================================================================
+func.func @semiaffine_mod(%arg0: index, %arg1: index) -> index {
+  %a = affine.apply affine_map<(d0)[s0] ->((-((d0 floordiv s0) * s0) + s0 * s0) mod s0)> (%arg0)[%arg1]
+  return %a : index
+}
+
+func.func @semiaffine_floordiv(%arg0: index, %arg1: index) -> index {
+  %a = affine.apply affine_map<(d0)[s0] ->((-((d0 floordiv s0) * s0) + ((2 * s0) mod (3 * s0))) floordiv s0)> (%arg0)[%arg1]
+  return %a : index
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (index_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_map
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id))))
+                  (value_use)
+                  (value_use))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (index_type)))))))))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (index_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_map
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (bare_id)
+                        (integer_literal)
+                        (bare_id)
+                        (integer_literal)
+                        (bare_id)
+                        (bare_id))))
+                  (value_use)
+                  (value_use))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (index_type))))))))))))

mlir/utils/tree-sitter-mlir/test/corpus/attribute.txt

+================================================================================
+func.func with result attribute
+================================================================================
+func.func @example_fn_result() -> (f64 {dialectName.attrName = 0 : i64})
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (float_type)))
+            (attribute
+              (dictionary_attribute
+                (attribute_entry
+                  (bare_id)
+                  (attribute_value
+                    (integer_literal)
+                    (type
+                      (builtin_type
+                        (integer_type)))))))))))))
+
+================================================================================
+func.func with argument attribute
+================================================================================
+func.func @example_fn_arg(%x: i32 {swift.self = unit})
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type)))
+          (attribute
+            (dictionary_attribute
+              (attribute_entry
+                (bare_id)
+                (attribute_value
+                  (unit_literal))))))))))
+
+================================================================================
+strided attribute in memref
+================================================================================
+func.func @dot_view(%arg0: memref<?xf32, strided<[1], offset: ?>>,
+  %arg1: memref<?xf32, strided<[1], offset: ?>>, %arg2: memref<f32>) {
+  linalg.dot ins(%arg0, %arg1 : memref<?xf32, strided<[1], offset: ?>>,
+                                memref<?xf32, strided<[1], offset: ?>>)
+             outs(%arg2:  memref<f32>)
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))
+                (attribute_value
+                  (builtin_attribute
+                    (strided_layout))))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))
+                (attribute_value
+                  (builtin_attribute
+                    (strided_layout))))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))))))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (linalg_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout))))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+dense attribute in linalg.depthwise_conv_1d_nwc_wcm
+================================================================================
+func.func @depthwise_conv_1d_nwc_wcm(%input: tensor<1x12x8xf32>, %filter: tensor<3x8x8xf32>)
+  -> tensor<1x10x8x8xf32> {
+  %zero = arith.constant 0.000000e+00 : f32
+  %init = tensor.empty() : tensor<1x10x8x8xf32>
+  %fill = linalg.fill ins(%zero : f32) outs(%init : tensor<1x10x8x8xf32>) -> tensor<1x10x8x8xf32>
+  %0 = linalg.depthwise_conv_1d_nwc_wcm {dilations = dense<1> : tensor<1xi64>,
+    strides = dense<1> : tensor<1xi64>}
+    ins(%input, %filter : tensor<1x12x8xf32>, tensor<3x8x8xf32>)
+    outs(%fill : tensor<1x10x8x8xf32>) -> tensor<1x10x8x8xf32>
+  return %0 : tensor<1x10x8x8xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (float_literal)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (linalg_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (float_type)))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (linalg_dialect
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (tensor_literal
+                            (integer_literal))
+                          (type
+                            (builtin_type
+                              (tensor_type
+                                (dim_list
+                                  (integer_type)))))))
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (tensor_literal
+                            (integer_literal))
+                          (type
+                            (builtin_type
+                              (tensor_type
+                                (dim_list
+                                  (integer_type)))))))))
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+fastmath attribute in arith
+================================================================================
+func.func @fastmath(%arg0: f32, %arg1: f32, %arg2: i32) {
+  %0 = arith.addf %arg0, %arg1 fastmath<fast> : f32
+  %1 = arith.subf %arg0, %arg1 fastmath<fast> : f32
+  %2 = arith.mulf %arg0, %arg1 fastmath<fast> : f32
+  %3 = arith.divf %arg0, %arg1 fastmath<fast> : f32
+  %4 = arith.remf %arg0, %arg1 fastmath<fast> : f32
+  %5 = arith.negf %arg0 fastmath<fast> : f32
+  %6 = arith.addf %arg0, %arg1 fastmath<none> : f32
+  %7 = arith.addf %arg0, %arg1 fastmath<nnan,ninf> : f32
+  %8 = arith.mulf %arg0, %arg1 fastmath<reassoc,nnan,ninf,nsz,arcp,contract,afn> : f32
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (float_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (float_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (fastmath_attr)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (fastmath_attr)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (fastmath_attr)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (fastmath_attr)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (fastmath_attr)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (fastmath_attr)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (fastmath_attr)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (fastmath_attr)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (fastmath_attr)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+Generic function bracketed attributes
+================================================================================
+"llvm.func"() ({
+}) {sym_name = "qux", function_type = !llvm.func<void (ptr<i64>, i64)>,
+    arg_attrs = [{llvm.noalias}, {}], xxx = {yyy = 42}} : () -> ()
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (generic_operation
+      (string_literal)
+      (region)
+      (attribute
+        (dictionary_attribute
+          (attribute_entry
+            (bare_id)
+            (attribute_value
+              (string_literal)))
+          (attribute_entry
+            (bare_id)
+            (attribute_value
+              (type
+                (dialect_type
+                  (pretty_dialect_item
+                    (dialect_namespace)
+                    (dialect_ident)
+                    (pretty_dialect_item_body
+                      (pretty_dialect_item_body)))))))
+          (attribute_entry
+            (bare_id)
+            (attribute_value
+              (dictionary_attribute
+                (attribute_entry
+                  (bare_id)))
+              (dictionary_attribute)))
+          (attribute_entry
+            (bare_id)
+            (attribute_value
+              (dictionary_attribute
+                (attribute_entry
+                  (bare_id)
+                  (attribute_value
+                    (integer_literal))))))))
+      (function_type))))
+
+================================================================================
+linalg.generic with attributes using attribute aliases
+================================================================================
+#map0 = affine_map<(d0, d1) -> (d0, d1)>
+#map1 = affine_map<(d0, d1) -> (d0)>
+#map2 = affine_map<(d0) -> (d0)>
+
+func.func @add_broadcast_mul_fusion(%arg0: tensor<?xf32>, %arg1 : tensor<?xf32>,
+  %arg2 : tensor<?x?xf32>) -> tensor<?x?xf32>
+{
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %0 = tensor.dim %arg0, %c0 : tensor<?xf32>
+  %1 = tensor.empty(%0) : tensor<?xf32>
+  %2 = linalg.generic {indexing_maps = [#map2, #map2, #map2], iterator_types = ["parallel"]}
+      ins(%arg0, %arg1 : tensor<?xf32>, tensor<?xf32>)
+      outs(%1 : tensor<?xf32>) {
+    ^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
+      %3 = arith.addf %arg3, %arg4 : f32
+      linalg.yield %3 : f32
+  } -> tensor<?xf32>
+  %3 = tensor.dim %arg2, %c1 : tensor<?x?xf32>
+  %4 = tensor.empty(%0, %3) : tensor<?x?xf32>
+  %5 = linalg.generic {indexing_maps = [#map1, #map0, #map0], iterator_types = ["parallel", "parallel"]}
+      ins(%2, %arg2 : tensor<?xf32>, tensor<?x?xf32>)
+      outs(%4 : tensor<?x?xf32>){
+    ^bb0(%arg5: f32, %arg6: f32, %arg7: f32):
+      %6 = arith.mulf %arg5, %arg6 : f32
+      linalg.yield %6 : f32
+    } -> tensor<?x?xf32>
+  return %5 : tensor<?x?xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)
+          (bare_id)
+          (bare_id)
+          (bare_id)))))
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)
+          (bare_id)
+          (bare_id)))))
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)
+          (bare_id)))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (linalg_dialect
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (attribute_alias)
+                          (attribute_alias)
+                          (attribute_alias)))
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (string_literal)))))
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (float_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (float_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (float_type)))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))
+                      (operation
+                        (custom_operation
+                          (linalg_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (linalg_dialect
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (attribute_alias)
+                          (attribute_alias)
+                          (attribute_alias)))
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (string_literal)
+                          (string_literal)))))
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (float_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (float_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (float_type)))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))
+                      (operation
+                        (custom_operation
+                          (linalg_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+linalg.generic with attribute alias
+================================================================================
+#map0 = affine_map<() -> ()>
+
+#attrs = {
+  indexing_maps = [#map0, #map0, #map0],
+  iterator_types = []
+}
+
+func.func @main() -> (tensor<i32>) attributes {} {
+  %c0 = arith.constant 0 : i32
+  %0 = tensor.from_elements %c0 : tensor<i32>
+  %c10 = arith.constant 10 : i32
+  %1 = tensor.from_elements %c10 : tensor<i32>
+  cf.br ^bb1(%0 : tensor<i32>)
+
+^bb1(%2: tensor<i32>):  // 2 preds: ^bb0, ^bb2
+  %3 = tensor.empty() : tensor<i1>
+  %4 = linalg.generic #attrs
+    ins(%2, %1 : tensor<i32>, tensor<i32>)
+    outs(%3 : tensor<i1>) {
+    ^bb0(%arg0: i32, %arg1: i32, %arg2: i1):
+      %8 = arith.cmpi slt, %arg0, %arg1 : i32
+      linalg.yield %8 : i1
+  } -> tensor<i1>
+  %5 = tensor.extract %4[] : tensor<i1>
+  cf.cond_br %5, ^bb2(%2 : tensor<i32>), ^bb3(%2 : tensor<i32>)
+
+^bb2(%6: tensor<i32>):  // pred: ^bb1
+  %7 = tensor.empty() : tensor<i32>
+  %8 = linalg.generic #attrs
+    ins(%6, %6 : tensor<i32>, tensor<i32>)
+    outs(%7 : tensor<i32>) {
+    ^bb0(%arg0: i32, %arg1: i32, %arg2: i32):
+      %9 = arith.addi %arg0, %arg1 : i32
+      linalg.yield %9 : i32
+  } -> tensor<i32>
+  cf.br ^bb3(%8 : tensor<i32>)
+
+^bb3(%10: tensor<i32>):  // pred: ^bb1
+  return %10 : tensor<i32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map))))
+  (attribute_alias_def
+    (attribute_value
+      (dictionary_attribute
+        (attribute_entry
+          (bare_id)
+          (attribute_value
+            (attribute_alias)
+            (attribute_alias)
+            (attribute_alias)))
+        (attribute_entry
+          (bare_id)
+          (attribute_value)))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (integer_type)))))))
+        (attribute
+          (dictionary_attribute))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (custom_operation
+                (cf_dialect
+                  (successor
+                    (caret_id)
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (integer_type))))))))))
+          (block
+            (block_label
+              (caret_id)
+              (block_arg_list
+                (value_use)
+                (type
+                  (builtin_type
+                    (tensor_type
+                      (dim_list
+                        (integer_type)))))))
+            (comment)
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (linalg_dialect
+                  (attribute
+                    (attribute_alias))
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type)))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type)))))
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (integer_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (integer_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (integer_type)))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (linalg_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type))))))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (custom_operation
+                (cf_dialect
+                  (value_use)
+                  (successor
+                    (caret_id)
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (integer_type))))))
+                  (successor
+                    (caret_id)
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (integer_type))))))))))
+          (block
+            (block_label
+              (caret_id)
+              (block_arg_list
+                (value_use)
+                (type
+                  (builtin_type
+                    (tensor_type
+                      (dim_list
+                        (integer_type)))))))
+            (comment)
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (linalg_dialect
+                  (attribute
+                    (attribute_alias))
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type)))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type)))))
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (integer_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (integer_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (integer_type)))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (linalg_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type))))))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (custom_operation
+                (cf_dialect
+                  (successor
+                    (caret_id)
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (integer_type))))))))))
+          (block
+            (block_label
+              (caret_id)
+              (block_arg_list
+                (value_use)
+                (type
+                  (builtin_type
+                    (tensor_type
+                      (dim_list
+                        (integer_type)))))))
+            (comment)
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))))))))
+
+================================================================================
+linalg.generic with inline attributes
+================================================================================
+func.func @copy_view(%arg0: memref<?xf32, strided<[1], offset: ?>>,
+  %arg1: memref<?xf32, strided<[1], offset: ?>>) {
+  linalg.generic {
+    iterator_types = ["parallel"],
+    indexing_maps = [ affine_map<(i) -> (i)>, affine_map<(i) -> (i)>] }
+   ins(%arg0: memref<?xf32, strided<[1], offset: ?>>)
+   outs(%arg1: memref<?xf32, strided<[1], offset: ?>>) {
+    ^bb0(%a: f32, %b: f32):
+      linalg.yield %a : f32
+  }
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))
+                (attribute_value
+                  (builtin_attribute
+                    (strided_layout))))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))
+                (attribute_value
+                  (builtin_attribute
+                    (strided_layout)))))))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (linalg_dialect
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (string_literal)))
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)))
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)))))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout))))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout))))))
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (float_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (float_type)))))
+                      (operation
+                        (custom_operation
+                          (linalg_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type)))))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+linalg.broadcast with inline attributes, without dictionary tokens
+================================================================================
+func.func @broadcast(%input: tensor<8x32xf32>,
+                     %init: tensor<8x16x32xf32>) -> tensor<8x16x32xf32> {
+  %bcast = linalg.broadcast
+      ins(%input:tensor<8x32xf32>)
+      outs(%init:tensor<8x16x32xf32>)
+      dimensions = [1]
+  func.return %bcast : tensor<8x16x32xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (linalg_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (bare_attribute_entry
+                    (bare_id)
+                    (attribute_value
+                      (integer_literal))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))

mlir/utils/tree-sitter-mlir/test/corpus/controlflow.txt

+================================================================================
+Branching written with cf.br, cf.cond_br
+================================================================================
+func.func @simple(i64, i1) -> i64 {
+^bb0(%a: i64, %cond: i1): // Code dominated by ^bb0 may refer to %a
+  cf.cond_br %cond, ^bb1, ^bb2
+
+^bb1:
+  cf.br ^bb3(%a: i64)    // Branch passes %a as the argument
+
+^bb2:
+  %b = arith.addi %a, %a : i64
+  cf.br ^bb3(%b: i64)    // Branch passes %b as the argument
+
+// ^bb3 receives an argument, named %c, from predecessors
+// and passes it on to bb4 along with %a. %a is referenced
+// directly from its defining operation and is not passed through
+// an argument of ^bb3.
+^bb3(%c: i64):
+  cf.br ^bb4(%c, %a : i64, i64)
+
+^bb4(%d : i64, %e : i64):
+  %0 = arith.addi %d, %e : i64
+  return %0 : i64   // Return is also a terminator.
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (type
+            (builtin_type
+              (integer_type)))
+          (type
+            (builtin_type
+              (integer_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (integer_type)))))
+        (region
+          (block
+            (block_label
+              (caret_id)
+              (block_arg_list
+                (value_use)
+                (type
+                  (builtin_type
+                    (integer_type)))
+                (value_use)
+                (type
+                  (builtin_type
+                    (integer_type)))))
+            (comment)
+            (operation
+              (custom_operation
+                (cf_dialect
+                  (value_use)
+                  (successor
+                    (caret_id))
+                  (successor
+                    (caret_id))))))
+          (block
+            (block_label
+              (caret_id))
+            (operation
+              (custom_operation
+                (cf_dialect
+                  (successor
+                    (caret_id)
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (integer_type))))))))
+          (comment)
+          (block
+            (block_label
+              (caret_id))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (custom_operation
+                (cf_dialect
+                  (successor
+                    (caret_id)
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (integer_type))))))))
+          (comment)
+          (comment)
+          (comment)
+          (comment)
+          (comment)
+          (block
+            (block_label
+              (caret_id)
+              (block_arg_list
+                (value_use)
+                (type
+                  (builtin_type
+                    (integer_type)))))
+            (operation
+              (custom_operation
+                (cf_dialect
+                  (successor
+                    (caret_id)
+                    (value_use)
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (integer_type)))
+                    (type
+                      (builtin_type
+                        (integer_type))))))))
+          (block
+            (block_label
+              (caret_id)
+              (block_arg_list
+                (value_use)
+                (type
+                  (builtin_type
+                    (integer_type)))
+                (value_use)
+                (type
+                  (builtin_type
+                    (integer_type)))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type)))))))
+          (comment))))))
+
+================================================================================
+Switch statement written with cf.switch
+================================================================================
+func.func @switch(%flag : i32, %caseOperand : i32) {
+  cf.switch %flag : i32, [
+    default: ^bb1(%caseOperand : i32),
+    42: ^bb2(%caseOperand : i32),
+    43: ^bb3(%caseOperand : i32)
+  ]
+
+  ^bb1(%bb1arg : i32):
+    return
+  ^bb2(%bb2arg : i32):
+    return
+  ^bb3(%bb3arg : i32):
+    return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type))))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (cf_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type)))
+                  (cf_case_label)
+                  (successor
+                    (caret_id)
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (integer_type))))
+                  (cf_case_label
+                    (integer_literal))
+                  (successor
+                    (caret_id)
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (integer_type))))
+                  (cf_case_label
+                    (integer_literal))
+                  (successor
+                    (caret_id)
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (integer_type))))))))
+          (block
+            (block_label
+              (caret_id)
+              (block_arg_list
+                (value_use)
+                (type
+                  (builtin_type
+                    (integer_type)))))
+            (operation
+              (custom_operation
+                (func_dialect))))
+          (block
+            (block_label
+              (caret_id)
+              (block_arg_list
+                (value_use)
+                (type
+                  (builtin_type
+                    (integer_type)))))
+            (operation
+              (custom_operation
+                (func_dialect))))
+          (block
+            (block_label
+              (caret_id)
+              (block_arg_list
+                (value_use)
+                (type
+                  (builtin_type
+                    (integer_type)))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+Simple for-loop written with scf.for
+================================================================================
+func.func @for_loop_with_increasing_arg() -> i1 {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %c4 = arith.constant 4 : index
+  %c16 = arith.constant 16 : index
+  %0 = scf.for %arg0 = %c0 to %c4 step %c1 iter_args(%arg1 = %c0) -> index {
+      %10 = arith.addi %arg0, %arg1 : index
+      scf.yield %10 : index
+  }
+  %1 = arith.cmpi ule, %0, %c16 : index
+  func.return %1 : i1
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (integer_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (index_type)))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (index_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (index_type)))))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type))))))))))))
+
+================================================================================
+Nested for-loop written using scf.for
+================================================================================
+func.func @std_for(%arg0 : index, %arg1 : index, %arg2 : index) {
+  scf.for %i0 = %arg0 to %arg1 step %arg2 {
+    scf.for %i1 = %arg0 to %arg1 step %arg2 {
+      %min_cmp = arith.cmpi slt, %i0, %i1 : index
+      %min = arith.select %min_cmp, %i0, %i1 : index
+      %max_cmp = arith.cmpi sge, %i0, %i1 : index
+      %max = arith.select %max_cmp, %i0, %i1 : index
+      scf.for %i2 = %min to %max step %i1 {
+      }
+    }
+  }
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (value_use)
+                            (value_use)
+                            (value_use)
+                            (region
+                              (entry_block
+                                (operation
+                                  (op_result
+                                    (value_use))
+                                  (custom_operation
+                                    (arith_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (index_type))))))
+                                (operation
+                                  (op_result
+                                    (value_use))
+                                  (custom_operation
+                                    (arith_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (index_type))))))
+                                (operation
+                                  (op_result
+                                    (value_use))
+                                  (custom_operation
+                                    (arith_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (index_type))))))
+                                (operation
+                                  (op_result
+                                    (value_use))
+                                  (custom_operation
+                                    (arith_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (index_type))))))
+                                (operation
+                                  (custom_operation
+                                    (scf_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (region))))))))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+Conditional written with scf.if and scf.yield
+================================================================================
+func.func @std_if_yield(%arg0: i1, %arg1: f32)
+{
+  %x, %y = scf.if %arg0 -> (f32, f32) {
+    %0 = arith.addf %arg1, %arg1 : f32
+    %1 = arith.subf %arg1, %arg1 : f32
+    scf.yield %0, %1 : f32, f32
+  } else {
+    %0 = arith.subf %arg1, %arg1 : f32
+    %1 = arith.addf %arg1, %arg1 : f32
+    scf.yield %0, %1 : f32, f32
+  }
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (float_type))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (float_type)))
+                  (type
+                    (builtin_type
+                      (float_type)))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type)))
+                            (type
+                              (builtin_type
+                                (float_type))))))))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type)))
+                            (type
+                              (builtin_type
+                                (float_type)))))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+Switch statement using scf.index_switch
+================================================================================
+func.func @switch(%arg0: index) -> i32 {
+  %0 = scf.index_switch %arg0 -> i32
+  case 2 {
+    %c10_i32 = arith.constant 10 : i32
+    scf.yield %c10_i32 : i32
+  }
+  case 5 {
+    %c20_i32 = arith.constant 20 : i32
+    scf.yield %c20_i32 : i32
+  }
+  default {
+    %c30_i32 = arith.constant 30 : i32
+    scf.yield %c30_i32 : i32
+  }
+
+  scf.index_switch %arg0
+  default {
+    scf.yield
+  }
+
+  return %0 : i32
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (integer_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type)))
+                  (scf_case_label
+                    (integer_literal))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (integer_literal)
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type))))))))
+                  (scf_case_label
+                    (integer_literal))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (integer_literal)
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type))))))))
+                  (scf_case_label)
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (integer_literal)
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type)))))))))))
+            (operation
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (scf_case_label)
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (scf_dialect))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type))))))))))))
+
+================================================================================
+Parallel for-loop and reduction using scf.parallel and scf.reduce
+================================================================================
+func.func @single_iteration_reduce(%A: index, %B: index) -> (index, index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %c2 = arith.constant 2 : index
+  %c3 = arith.constant 3 : index
+  %c6 = arith.constant 6 : index
+  %0:2 = scf.parallel (%i0, %i1) = (%c1, %c3) to (%c2, %c6) step (%c1, %c3) init(%A, %B) -> (index, index) {
+    scf.reduce(%i0) : index {
+    ^bb0(%lhs: index, %rhs: index):
+      %1 = arith.addi %lhs, %rhs : index
+      scf.reduce.return %1 : index
+    }
+    scf.reduce(%i1) : index {
+    ^bb0(%lhs: index, %rhs: index):
+      %2 = arith.muli %lhs, %rhs : index
+      scf.reduce.return %2 : index
+    }
+    scf.yield
+  }
+  return %0#0, %0#1 : index, index
+}
+
+func.func @single_iteration_some(%A: memref<?x?x?xi32>) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %c2 = arith.constant 2 : index
+  %c3 = arith.constant 3 : index
+  %c6 = arith.constant 6 : index
+  %c7 = arith.constant 7 : index
+  %c10 = arith.constant 10 : index
+  scf.parallel (%i0, %i1, %i2) = (%c0, %c3, %c7) to (%c1, %c6, %c10) step (%c1, %c2, %c3) {
+    %c42 = arith.constant 42 : i32
+    memref.store %c42, %A[%i0, %i1, %i2] : memref<?x?x?xi32>
+    scf.yield
+  }
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (index_type)))
+            (type
+              (builtin_type
+                (index_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (index_type)))
+                  (type
+                    (builtin_type
+                      (index_type)))
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (index_type)))
+                            (region
+                              (block
+                                (block_label
+                                  (caret_id)
+                                  (block_arg_list
+                                    (value_use)
+                                    (type
+                                      (builtin_type
+                                        (index_type)))
+                                    (value_use)
+                                    (type
+                                      (builtin_type
+                                        (index_type)))))
+                                (operation
+                                  (op_result
+                                    (value_use))
+                                  (custom_operation
+                                    (arith_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (index_type))))))
+                                (operation
+                                  (custom_operation
+                                    (scf_dialect
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (index_type)))))))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (index_type)))
+                            (region
+                              (block
+                                (block_label
+                                  (caret_id)
+                                  (block_arg_list
+                                    (value_use)
+                                    (type
+                                      (builtin_type
+                                        (index_type)))
+                                    (value_use)
+                                    (type
+                                      (builtin_type
+                                        (index_type)))))
+                                (operation
+                                  (op_result
+                                    (value_use))
+                                  (custom_operation
+                                    (arith_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (index_type))))))
+                                (operation
+                                  (custom_operation
+                                    (scf_dialect
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (index_type)))))))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (index_type)))
+                  (type
+                    (builtin_type
+                      (index_type)))))))))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (integer_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (integer_literal)
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (memref_dialect
+                            (value_use)
+                            (value_use)
+                            (value_use)
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (memref_type
+                                  (dim_list
+                                    (integer_type))))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+While loop written using scf.while and scf.condition
+================================================================================
+func.func @while_cond_true() -> i1 {
+  %0 = scf.while () : () -> i1 {
+    %condition = "test.condition"() : () -> i1
+    scf.condition(%condition) %condition : i1
+  } do {
+  ^bb0(%arg0: i1):
+    "test.use"(%arg0) : (i1) -> ()
+    scf.yield
+  }
+  return %0 : i1
+}
+
+func.func @while_unused_arg(%x : i32, %y : f64) -> i32 {
+  %0 = scf.while (%arg1 = %x, %arg2 = %y) : (i32, f64) -> (i32) {
+    %condition = "test.condition"(%arg1) : (i32) -> i1
+    scf.condition(%condition) %arg1 : i32
+  } do {
+  ^bb0(%arg1: i32):
+    %next = "test.use"(%arg1) : (i32) -> (i32)
+    scf.yield %next, %y : i32, f64
+  }
+  return %0 : i32
+}
+
+func.func @infinite_while() {
+  %true = arith.constant true
+  scf.while : () -> () {
+    scf.condition(%true)
+  } do {
+    scf.yield
+  }
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (integer_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (function_type
+                    (type
+                      (builtin_type
+                        (integer_type))))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (generic_operation
+                          (string_literal)
+                          (function_type
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type))))))))
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (integer_type)))))
+                      (operation
+                        (generic_operation
+                          (string_literal)
+                          (value_use)
+                          (function_type
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type)))))))))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (float_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (integer_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (function_type
+                    (type
+                      (builtin_type
+                        (integer_type)))
+                    (type
+                      (builtin_type
+                        (float_type)))
+                    (type
+                      (builtin_type
+                        (integer_type))))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (generic_operation
+                          (string_literal)
+                          (value_use)
+                          (function_type
+                            (type
+                              (builtin_type
+                                (integer_type)))
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type))))))))
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (integer_type)))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (generic_operation
+                          (string_literal)
+                          (value_use)
+                          (function_type
+                            (type
+                              (builtin_type
+                                (integer_type)))
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type)))
+                            (type
+                              (builtin_type
+                                (float_type)))))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type)))))))))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (bool_literal))))
+            (operation
+              (custom_operation
+                (scf_dialect
+                  (function_type)
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use))))))
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (scf_dialect))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+affine.for with attribute aliseses
+================================================================================
+#map_simple0 = affine_map<()[] -> (10)>
+#map_simple1 = affine_map<()[s0] -> (s0)>
+#map_non_simple0 = affine_map<(d0)[] -> (d0)>
+#map_non_simple1 = affine_map<(d0)[s0] -> (d0 + s0)>
+#map_non_simple2 = affine_map<()[s0, s1] -> (s0 + s1)>
+#map_non_simple3 = affine_map<()[s0] -> (s0 + 3)>
+func.func @funcsimplemap(%arg0: index, %arg1: index) -> () {
+  affine.for %i0 = 0 to #map_simple0()[] {
+    affine.for %i1 = 0 to #map_simple1()[%arg1] {
+      affine.for %i2 = 0 to #map_non_simple0(%i0)[] {
+        affine.for %i3 = 0 to #map_non_simple1(%i0)[%arg1] {
+          affine.for %i4 = 0 to #map_non_simple2()[%arg1, %arg0] {
+            affine.for %i5 = 0 to #map_non_simple3()[%arg0] {
+              %c42_i32 = arith.constant 42 : i32
+            }
+          }
+        }
+      }
+    }
+  }
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (integer_literal)))))
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)
+          (bare_id)))))
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)
+          (bare_id)))))
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)
+          (bare_id)
+          (bare_id)
+          (bare_id)))))
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)
+          (bare_id)
+          (bare_id)
+          (bare_id)))))
+  (attribute_alias_def
+    (attribute_value
+      (builtin_attribute
+        (affine_map
+          (bare_id)
+          (bare_id)
+          (integer_literal)))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (func_return
+          (type_list_attr_parens))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (affine_dialect
+                  (value_use)
+                  (integer_literal)
+                  (attribute
+                    (attribute_alias))
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (affine_dialect
+                            (value_use)
+                            (integer_literal)
+                            (attribute
+                              (attribute_alias))
+                            (value_use)
+                            (region
+                              (entry_block
+                                (operation
+                                  (custom_operation
+                                    (affine_dialect
+                                      (value_use)
+                                      (integer_literal)
+                                      (attribute
+                                        (attribute_alias))
+                                      (value_use)
+                                      (region
+                                        (entry_block
+                                          (operation
+                                            (custom_operation
+                                              (affine_dialect
+                                                (value_use)
+                                                (integer_literal)
+                                                (attribute
+                                                  (attribute_alias))
+                                                (value_use)
+                                                (value_use)
+                                                (region
+                                                  (entry_block
+                                                    (operation
+                                                      (custom_operation
+                                                        (affine_dialect
+                                                          (value_use)
+                                                          (integer_literal)
+                                                          (attribute
+                                                            (attribute_alias))
+                                                          (value_use)
+                                                          (value_use)
+                                                          (region
+                                                            (entry_block
+                                                              (operation
+                                                                (custom_operation
+                                                                  (affine_dialect
+                                                                    (value_use)
+                                                                    (integer_literal)
+                                                                    (attribute
+                                                                      (attribute_alias))
+                                                                    (value_use)
+                                                                    (region
+                                                                      (entry_block
+                                                                        (operation
+                                                                          (op_result
+                                                                            (value_use))
+                                                                          (custom_operation
+                                                                            (arith_dialect
+                                                                              (integer_literal)
+                                                                              (type
+                                                                                (builtin_type
+                                                                                  (integer_type))))))))))))))))))))))))))))))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+affine.if and affine.yield
+================================================================================
+func.func @affine_if() -> f32 {
+  %zero = arith.constant 0.0 : f32
+  %0 = affine.if affine_set<() : ()> () -> f32 {
+    affine.yield %zero : f32
+  } else {
+    affine.yield %zero : f32
+  }
+  return %0 : f32
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (float_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (float_literal)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (affine_dialect
+                  (attribute
+                    (builtin_attribute
+                      (affine_set)))
+                  (type
+                    (builtin_type
+                      (float_type)))
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (affine_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))))
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (affine_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type)))))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (float_type))))))))))))
+
+================================================================================
+Parallel for loop written using affine.parallel
+================================================================================
+func.func @parallel(%A : memref<100x100xf32>, %N : index) {
+  affine.parallel (%i0, %j0) = (0, 0) to (symbol(%N), 100) step (10, 10) {
+    %0:2 = affine.parallel (%i1, %j1) = (%i0, %j0) to (%i0 + 10, %j0 + 10)
+      reduce ("minf", "maxf") -> (f32, f32) {
+      %2 = affine.load %A[%i0 + %i0, %j0 + %j1] : memref<100x100xf32>
+      affine.yield %2, %2 : f32, f32
+    }
+  }
+  return
+}
+
+func.func @parallel_min_max(%a: index, %b: index, %c: index, %d: index) {
+  affine.parallel (%i, %j, %k) = (max(%a, %b), %b, max(%a, %c))
+                              to (%c, min(%c, %d), %b) {
+    affine.yield
+  }
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (affine_dialect
+                  (value_use)
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (affine_dialect
+                            (value_use)
+                            (value_use)
+                            (value_use)
+                            (value_use)
+                            (value_use)
+                            (integer_literal)
+                            (value_use)
+                            (integer_literal)
+                            (string_literal)
+                            (string_literal)
+                            (type
+                              (builtin_type
+                                (float_type)))
+                            (type
+                              (builtin_type
+                                (float_type)))
+                            (region
+                              (entry_block
+                                (operation
+                                  (op_result
+                                    (value_use))
+                                  (custom_operation
+                                    (affine_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (memref_type
+                                            (dim_list
+                                              (float_type))))))))
+                                (operation
+                                  (custom_operation
+                                    (affine_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (type
+                                        (builtin_type
+                                          (float_type)))
+                                      (type
+                                        (builtin_type
+                                          (float_type))))))))))))))))
+            (operation
+              (custom_operation
+                (func_dialect))))))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (affine_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (affine_dialect))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+Execution of a region using scf.execute_region
+================================================================================
+func.func @execute_region() -> i64 {
+  %res = scf.execute_region -> i64 {
+    %c1 = arith.constant 1 : i64
+    scf.yield %c1 : i64
+  }
+
+  %res2:2 = scf.execute_region -> (i64, i64) {
+    %c1 = arith.constant 1 : i64
+    scf.yield %c1, %c1 : i64, i64
+  }
+  return %res : i64
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (integer_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (type
+                    (builtin_type
+                      (integer_type)))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (integer_literal)
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type)))))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (type
+                    (builtin_type
+                      (integer_type)))
+                  (type
+                    (builtin_type
+                      (integer_type)))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (integer_literal)
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type)))
+                            (type
+                              (builtin_type
+                                (integer_type)))))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type))))))))))))
+
+================================================================================
+Parallel loop written using scf.forall and scf.forall.in_parallel
+================================================================================
+func.func @normalized_forall(%in: tensor<100xf32>, %out: tensor<100xf32>) {
+  %c1 = arith.constant 1 : index
+  %num_threads = arith.constant 100 : index
+  %result = scf.forall (%thread_idx) in (%num_threads) shared_outs(%o = %out) -> tensor<100xf32> {
+      %1 = tensor.extract_slice %in[%thread_idx][1][1] : tensor<100xf32> to tensor<1xf32>
+      scf.forall.in_parallel {
+        tensor.parallel_insert_slice %1 into %o[%thread_idx][1][1] :
+          tensor<1xf32> into tensor<100xf32>
+      }
+  }
+  return
+}
+
+func.func @explicit_loop_bounds_forall(%in: tensor<100xf32>,
+    %out: tensor<100xf32>) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %num_threads = arith.constant 100 : index
+  %result = scf.forall (%thread_idx) =  (%c0) to (%num_threads) step (%c1) shared_outs(%o = %out) -> tensor<100xf32> {
+      %1 = tensor.extract_slice %in[%thread_idx][1][1] : tensor<100xf32> to tensor<1xf32>
+      scf.forall.in_parallel {
+        tensor.parallel_insert_slice %1 into %o[%thread_idx][1][1] :
+          tensor<1xf32> into tensor<100xf32>
+      } {mapping = [#gpu.thread<x>]}
+  }
+  return
+}
+
+func.func @normalized_forall_elide_terminator() -> () {
+  %num_threads = arith.constant 100 : index
+  scf.forall (%thread_idx) in (%num_threads) {
+    scf.forall.in_parallel {
+    }
+  } {mapping = [#gpu.thread<x>]}
+  return
+
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (tensor_dialect
+                            (value_use)
+                            (value_use)
+                            (integer_literal)
+                            (integer_literal)
+                            (type
+                              (builtin_type
+                                (tensor_type
+                                  (dim_list
+                                    (float_type)))))
+                            (type
+                              (builtin_type
+                                (tensor_type
+                                  (dim_list
+                                    (float_type))))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (region
+                              (entry_block
+                                (operation
+                                  (custom_operation
+                                    (tensor_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (integer_literal)
+                                      (integer_literal)
+                                      (type
+                                        (builtin_type
+                                          (tensor_type
+                                            (dim_list
+                                              (float_type)))))
+                                      (type
+                                        (builtin_type
+                                          (tensor_type
+                                            (dim_list
+                                              (float_type))))))))))))))))))
+            (operation
+              (custom_operation
+                (func_dialect))))))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (tensor_dialect
+                            (value_use)
+                            (value_use)
+                            (integer_literal)
+                            (integer_literal)
+                            (type
+                              (builtin_type
+                                (tensor_type
+                                  (dim_list
+                                    (float_type)))))
+                            (type
+                              (builtin_type
+                                (tensor_type
+                                  (dim_list
+                                    (float_type))))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (region
+                              (entry_block
+                                (operation
+                                  (custom_operation
+                                    (tensor_dialect
+                                      (value_use)
+                                      (value_use)
+                                      (value_use)
+                                      (integer_literal)
+                                      (integer_literal)
+                                      (type
+                                        (builtin_type
+                                          (tensor_type
+                                            (dim_list
+                                              (float_type)))))
+                                      (type
+                                        (builtin_type
+                                          (tensor_type
+                                            (dim_list
+                                              (float_type))))))))))
+                            (attribute
+                              (dictionary_attribute
+                                (attribute_entry
+                                  (bare_id)
+                                  (attribute_value
+                                    (dialect_attribute
+                                      (pretty_dialect_item
+                                        (dialect_namespace)
+                                        (dialect_ident)
+                                        (pretty_dialect_item_body)))))))))))))))
+            (operation
+              (custom_operation
+                (func_dialect))))))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (value_use)
+                  (region
+                    (entry_block
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (region))))))
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (dialect_attribute
+                            (pretty_dialect_item
+                              (dialect_namespace)
+                              (dialect_ident)
+                              (pretty_dialect_item_body))))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))

mlir/utils/tree-sitter-mlir/test/corpus/func.txt

+================================================================================
+Function prototype
+================================================================================
+func.func @abort()
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)))))
+
+================================================================================
+Simple function using func, arith dialects
+================================================================================
+func.func @test_addi(%arg0 : i64, %arg1 : i64) -> i64 {
+  %0 = arith.addi %arg0, %arg1 : i64
+  return %0 : i64
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (integer_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type))))))))))))
+
+================================================================================
+Function with multiple return values
+================================================================================
+func.func @count(%x: i64) -> (i64, i64) {
+  return %x, %x: i64, i64
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (integer_type)))
+            (type
+              (builtin_type
+                (integer_type)))))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type)))
+                  (type
+                    (builtin_type
+                      (integer_type))))))))))))
+
+================================================================================
+Variadic function
+================================================================================
+llvm.func @variadic(...)
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (llvm_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (variadic))))))
+
+================================================================================
+Variadic function with other arguments
+================================================================================
+llvm.func @variadic_args(i32, i32, ...)
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (llvm_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (type
+            (builtin_type
+              (integer_type)))
+          (type
+            (builtin_type
+              (integer_type)))
+          (variadic))))))
+
+================================================================================
+Generic operation in a module, with attributes
+================================================================================
+module {
+  "llvm.func"() ({
+  }) {sym_name = "foo", function_type = !llvm.func<void ()>} : () -> ()
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (builtin_dialect
+        (region
+          (entry_block
+            (operation
+              (generic_operation
+                (string_literal)
+                (region)
+                (attribute
+                  (dictionary_attribute
+                    (attribute_entry
+                      (bare_id)
+                      (attribute_value
+                        (string_literal)))
+                    (attribute_entry
+                      (bare_id)
+                      (attribute_value
+                        (type
+                          (dialect_type
+                            (pretty_dialect_item
+                              (dialect_namespace)
+                              (dialect_ident)
+                              (pretty_dialect_item_body))))))))
+                (function_type)))))))))
+
+================================================================================
+Generic operation with successor and region
+================================================================================
+func.func @terminator_with_regions() {
+  "region"()[^bb2] ({}) : () -> ()
+^bb2:
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (region
+          (entry_block
+            (operation
+              (generic_operation
+                (string_literal)
+                (successor
+                  (caret_id))
+                (region)
+                (function_type))))
+          (block
+            (block_label
+              (caret_id))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+Function with private specifier, and func.call
+================================================================================
+func.func private @source() -> tensor<f32>
+func.func @call_source() -> tensor<f32> {
+  %0 = call @source() : () -> tensor<f32>
+  return %0 : tensor<f32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type))))))))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (func_dialect
+                  (symbol_ref_id)
+                  (function_type
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))

mlir/utils/tree-sitter-mlir/test/corpus/op.txt

+================================================================================
+linalg.map without ins
+================================================================================
+func.func @map_no_inputs(%init: tensor<64xf32>) -> tensor<64xf32> {
+   %add = linalg.map
+      outs(%init:tensor<64xf32>)
+      () {
+        %0 = arith.constant 0.0: f32
+        linalg.yield %0: f32
+      }
+  func.return %add : tensor<64xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (linalg_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (block_arg_list)
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (float_literal)
+                            (type
+                              (builtin_type
+                                (float_type))))))
+                      (operation
+                        (custom_operation
+                          (linalg_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type)))))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+linalg.map with ins and outs
+================================================================================
+func.func @map_binary_memref(%lhs: memref<64xf32>, %rhs: memref<64xf32>,
+                      %init: memref<64xf32>) {
+   linalg.map
+      ins(%lhs, %rhs: memref<64xf32>, memref<64xf32>)
+      outs(%init:memref<64xf32>)
+      (%lhs_elem: f32, %rhs_elem: f32) {
+        %0 = arith.addf %lhs_elem, %rhs_elem: f32
+        linalg.yield %0: f32
+      }
+  func.return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))))))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (linalg_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (block_arg_list
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (float_type)))
+                    (value_use)
+                    (type
+                      (builtin_type
+                        (float_type))))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))
+                      (operation
+                        (custom_operation
+                          (linalg_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type)))))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+linalg.generic with attribute dictionary
+================================================================================
+func.func @gather_like(
+    %arg0 : tensor<?x?xf32> {bufferization.writable = false},
+    %arg1 : tensor<?xi32> {bufferization.writable = false},
+    %arg2 : tensor<?x?xf32> {bufferization.writable = true})
+  -> tensor<?x?xf32>
+{
+  %0 = linalg.generic {
+      indexing_maps = [affine_map<(d0, d1) -> (d0)>,
+                       affine_map<(d0, d1) -> (d0, d1)>],
+      iterator_types = ["parallel", "parallel"]}
+      ins(%arg1 : tensor<?xi32>) outs(%arg2 : tensor<?x?xf32>) {
+      ^bb0(%arg3: i32, %arg4 : f32):
+        %iv1 = linalg.index 1 : index
+        %1 = arith.index_cast %arg3: i32 to index
+        %2 = tensor.extract %arg0[%1, %iv1] : tensor<?x?xf32>
+        linalg.yield %2 : f32
+      } -> tensor<?x?xf32>
+  return %0 : tensor<?x?xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (attribute
+            (dictionary_attribute
+              (attribute_entry
+                (bare_id)
+                (attribute_value
+                  (bool_literal)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (integer_type)))))
+          (attribute
+            (dictionary_attribute
+              (attribute_entry
+                (bare_id)
+                (attribute_value
+                  (bool_literal)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (attribute
+            (dictionary_attribute
+              (attribute_entry
+                (bare_id)
+                (attribute_value
+                  (bool_literal))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (linalg_dialect
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)))
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)))))
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (string_literal)
+                          (string_literal)))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type)))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (integer_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (float_type)))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (linalg_dialect
+                            (integer_literal)
+                            (type
+                              (builtin_type
+                                (index_type))))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (integer_type)))
+                            (type
+                              (builtin_type
+                                (index_type))))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (tensor_dialect
+                            (value_use)
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (tensor_type
+                                  (dim_list
+                                    (float_type))))))))
+                      (operation
+                        (custom_operation
+                          (linalg_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+tensor.collapse_shape and tensor.expand_shape without reassocation
+================================================================================
+func.func @tensor_reshape_zero_dim(%arg0 : tensor<1x1xf32>, %arg1 : tensor<f32>)
+    -> (tensor<f32>, tensor<1x1xf32>) {
+  %0 = tensor.collapse_shape %arg0 [] : tensor<1x1xf32> into tensor<f32>
+  %1 = tensor.expand_shape %0 [] : tensor<f32> into tensor<1x1xf32>
+  return %0, %1 : tensor<f32>, tensor<1x1xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (nested_idx_list)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (nested_idx_list)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+tensor.collapse_shape with reassocation
+================================================================================
+func.func @legal_collapsing_reshape_dynamic_tensor
+  (%arg0: tensor<?x?x?x4x?xf32>) -> tensor<?x?x?xf32>
+{
+  %0 = tensor.collapse_shape %arg0 [[0], [1], [2, 3, 4]] :
+    tensor<?x?x?x4x?xf32> into tensor<?x?x?xf32>
+  return %0 : tensor<?x?x?xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (nested_idx_list
+                    (nested_idx_list
+                      (integer_literal))
+                    (nested_idx_list
+                      (integer_literal))
+                    (nested_idx_list
+                      (integer_literal)
+                      (integer_literal)
+                      (integer_literal)))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+tensor.gather and tensor.scatter
+================================================================================
+func.func @gather_scatter(%dest : tensor<4x5x6xf32>, %indices: tensor<1x3x2xindex>,
+  %indices_i32: tensor<1x3x2xi32>) {
+  %gathered = tensor.gather %dest[%indices_i32] gather_dims([1, 2]) unique:
+    (tensor<4x5x6xf32>, tensor<1x3x2xi32>) -> tensor<1x3x4x1x1xf32>
+  %rank_reduced_gathered = tensor.gather %dest[%indices] gather_dims([1, 2]) unique:
+    (tensor<4x5x6xf32>, tensor<1x3x2xindex>) -> tensor<1x3x4xf32>
+
+  %scattered = tensor.scatter %gathered into %dest[%indices]
+      scatter_dims([1, 2]) unique:
+    (tensor<1x3x4x1x1xf32>, tensor<4x5x6xf32>, tensor<1x3x2xindex>) -> tensor<4x5x6xf32>
+  %rank_reduced_scattered = tensor.scatter %rank_reduced_gathered into %dest[%indices_i32]
+      scatter_dims([1, 2]) unique:
+    (tensor<1x3x4xf32>, tensor<4x5x6xf32>, tensor<1x3x2xi32>) -> tensor<4x5x6xf32>
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (index_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (integer_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (gather_dims_attr
+                    (integer_literal)
+                    (integer_literal))
+                  (unique_attr)
+                  (function_type
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (integer_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (gather_dims_attr
+                    (integer_literal)
+                    (integer_literal))
+                  (unique_attr)
+                  (function_type
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (index_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (scatter_dims_attr
+                    (integer_literal)
+                    (integer_literal))
+                  (unique_attr)
+                  (function_type
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (index_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (scatter_dims_attr
+                    (integer_literal)
+                    (integer_literal))
+                  (unique_attr)
+                  (function_type
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (integer_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+tensor.extract_slice
+================================================================================
+func.func @slice(%t: tensor<8x16x4xf32>, %idx : index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %1 = tensor.extract_slice %t[%c0, %c0, %c0][%idx, %idx, %idx][%c1, %c1, %c1]
+    : tensor<8x16x4xf32> to tensor<?x?x?xf32>
+  %2 = tensor.extract_slice %t[0, 2, 0][4, 4, 4][1, 1, 1]
+    : tensor<8x16x4xf32> to tensor<4x4x4xf32>
+  %3 = tensor.extract_slice %t[0, 2, 0][4, 1, 4][1, 1, 1]
+    : tensor<8x16x4xf32> to tensor<4x4xf32>
+
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+tensor.insert_slice
+================================================================================
+func.func @insert_slice(
+    %t: tensor<8x16x4xf32>,
+    %td: tensor<8x?x4xf32>,
+    %t2: tensor<16x32x8xf32>,
+    %t3: tensor<4x4xf32>,
+    %idx : index,
+    %sz : index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %1 = tensor.insert_slice %t into %t2[%c0, %c0, %c0][8, 16, 4][%c1, %c1, %c1]
+    : tensor<8x16x4xf32> into tensor<16x32x8xf32>
+  %2 = tensor.insert_slice %t into %t2[%c0, %idx, %c0][8, 16, 4][%c1, 1, %c1]
+    : tensor<8x16x4xf32> into tensor<16x32x8xf32>
+  %3 = tensor.insert_slice %t3 into %t[0, 2, 0][4, 1, 4][1, 1, 1]
+    : tensor<4x4xf32> into tensor<8x16x4xf32>
+  %4 = tensor.insert_slice %td into %t[0, %idx, 0][8, %sz, 4][1, 1, 1]
+    : tensor<8x?x4xf32> into tensor<8x16x4xf32>
+
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (value_use)
+                  (integer_literal)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (integer_literal)
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+tensor.rank, tensor.generate, tensor.yield, tensor.extract
+================================================================================
+func.func @extract_from_tensor.generate(%idx: index, %tensor: tensor<*xf32>) -> index {
+  %size = tensor.rank %tensor : tensor<*xf32>
+  %0 = tensor.generate %size {
+    ^bb0(%arg0: index):
+    %1 = tensor.dim %tensor, %arg0 : tensor<*xf32>
+    tensor.yield %1 : index
+  } : tensor<?xindex>
+  %1 = tensor.extract %0[%idx] : tensor<?xindex>
+  return %1 : index
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (index_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (index_type)))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (tensor_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (tensor_type
+                                  (dim_list
+                                    (float_type))))))))
+                      (operation
+                        (custom_operation
+                          (tensor_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (index_type))))))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (index_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (index_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (index_type))))))))))))
+
+================================================================================
+tensor.insert
+================================================================================
+func.func @insert(%arg0: f32, %arg1: index, %arg2: tensor<?x?x?xf32>) {
+  %0 = tensor.insert %arg0 into %arg2[%arg1, %arg1, %arg1] : tensor<?x?x?xf32>
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (float_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+tensor.from_elements and tensor.reshape
+================================================================================
+func.func @tensor.reshape(%t1: tensor<?x10xf32>) -> tensor<2x2x5xf32> {
+  %two = arith.constant 2 : i64
+  %five = arith.constant 5 : i64
+  %shape = tensor.from_elements %two, %two, %five : tensor<3xi64>
+  %reshaped = tensor.reshape %t1(%shape) : (tensor<?x10xf32>, tensor<3xi64>) -> tensor<2x2x5xf32>
+  return %reshaped : tensor<2x2x5xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (function_type
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (integer_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+tensor.pad
+================================================================================
+func.func @pad_dynamic(%arg0: tensor<1x2x2x?xf32>, %low: index, %high: index,
+                  %pad_value: f32) -> tensor<6x?x?x?xf32> {
+  %0 = tensor.pad %arg0 low[2, %low, 3, 3] high[3, 3, %high, 2] {
+    ^bb0(%arg1: index, %arg2: index, %arg3: index, %arg4: index):
+      tensor.yield %pad_value : f32
+    } : tensor<1x2x2x?xf32> to tensor<6x?x?x?xf32>
+  return %0 : tensor<6x?x?x?xf32>
+}
+
+func.func @pad_nofold_same_static_shape(%arg0: tensor<5x6xf32>, %a: index)
+    -> tensor<5x6xf32> {
+  %cst = arith.constant 0.000000e+00 : f32
+  %0 = tensor.pad %arg0 nofold low[%a, 0] high[0, %a] {
+        ^bb0(%arg1: index, %arg2: index):
+          tensor.yield %cst : f32
+  } : tensor<5x6xf32> to tensor<5x6xf32>
+  return %0 : tensor<5x6xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (float_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (integer_literal)
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (value_use)
+                  (integer_literal)
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (index_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (index_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (index_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (index_type)))))
+                      (operation
+                        (custom_operation
+                          (tensor_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))))))))))
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (float_literal)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (nofold_attr)
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (value_use)
+                  (region
+                    (block
+                      (block_label
+                        (caret_id)
+                        (block_arg_list
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (index_type)))
+                          (value_use)
+                          (type
+                            (builtin_type
+                              (index_type)))))
+                      (operation
+                        (custom_operation
+                          (tensor_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (float_type))))))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+tensor.splat
+================================================================================
+func.func @test_splat_op(%s : f32) {
+  %v = tensor.splat %s : tensor<8xf32>
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (float_type))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+tensor.reshape
+================================================================================
+func.func @tensor_reshape(%unranked: tensor<*xf32>, %shape: tensor<1xi32>) {
+  %dyn_vec = tensor.reshape %unranked(%shape)
+               : (tensor<*xf32>, tensor<1xi32>) -> tensor<?xf32>
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (integer_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (function_type
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (integer_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+tensor.pack and tensor.unpack
+================================================================================
+func.func @pack_nc_to_ncnc(%source: tensor<128x256xf32>, %dest: tensor<4x16x32x16xf32>) -> tensor<128x256xf32> {
+  %0 = tensor.pack %source inner_dims_pos = [0, 1] inner_tiles = [32, 16] into %dest : tensor<128x256xf32> -> tensor<4x16x32x16xf32>
+  %1 = tensor.empty() : tensor<128x256xf32>
+  %2 = tensor.unpack %0 inner_dims_pos = [0, 1] inner_tiles = [32, 16] into %1 : tensor<4x16x32x16xf32> -> tensor<128x256xf32>
+  return %2 : tensor<128x256xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (inner_dims_pos_attr
+                    (integer_literal)
+                    (integer_literal))
+                  (inner_tiles_attr
+                    (integer_literal)
+                    (integer_literal))
+                  (value_use)
+                  (function_type
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (inner_dims_pos_attr
+                    (integer_literal)
+                    (integer_literal))
+                  (inner_tiles_attr
+                    (integer_literal)
+                    (integer_literal))
+                  (value_use)
+                  (function_type
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))
+                    (type
+                      (builtin_type
+                        (tensor_type
+                          (dim_list
+                            (float_type)))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+memref.alloc, memref.cast, and memref.copy
+================================================================================
+func.func @memref_copy() {
+  %0 = memref.alloc() : memref<2xf32>
+  %1 = memref.cast %0 : memref<2xf32> to memref<*xf32>
+  %2 = memref.alloc() : memref<2xf32>
+  %3 = memref.cast %0 : memref<2xf32> to memref<*xf32>
+  memref.copy %1, %3 : memref<*xf32> to memref<*xf32>
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+memref.expand_shape and memref.collapse_shape
+================================================================================
+func.func @expand_collapse_shape_dynamic(%arg0: memref<?x?x?xf32>,
+         %arg1: memref<?x?x?xf32, strided<[?, ?, 1], offset: 0>>,
+         %arg2: memref<?x?x?xf32, strided<[?, ?, 1], offset: ?>>,
+         %arg3: memref<?x42xf32, strided<[42, 1], offset: 0>>) {
+  %0 = memref.collapse_shape %arg0 [[0, 1], [2]] :
+    memref<?x?x?xf32> into memref<?x?xf32>
+  %r0 = memref.expand_shape %0 [[0, 1], [2]] :
+    memref<?x?xf32> into memref<?x4x?xf32>
+  %1 = memref.collapse_shape %arg1 [[0, 1], [2]] :
+    memref<?x?x?xf32, strided<[?, ?, 1], offset: 0>> into
+    memref<?x?xf32, strided<[?, 1], offset: 0>>
+  %r1 = memref.expand_shape %1 [[0, 1], [2]] :
+    memref<?x?xf32, strided<[?, 1], offset: 0>> into
+    memref<?x4x?xf32, strided<[?, ?, 1], offset: 0>>
+  %2 = memref.collapse_shape %arg2 [[0, 1], [2]] :
+    memref<?x?x?xf32, strided<[?, ?, 1], offset: ?>> into
+    memref<?x?xf32, strided<[?, 1], offset: ?>>
+  %r2 = memref.expand_shape %2 [[0, 1], [2]] :
+    memref<?x?xf32, strided<[?, 1], offset: ?>> into
+    memref<?x4x?xf32, strided<[?, ?, 1], offset: ?>>
+  %3 = memref.collapse_shape %arg3 [[0, 1]] :
+    memref<?x42xf32, strided<[42, 1], offset: 0>> into
+    memref<?xf32, strided<[1]>>
+  %r3 = memref.expand_shape %3 [[0, 1]] :
+    memref<?xf32, strided<[1]>> into memref<?x42xf32>
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))
+                (attribute_value
+                  (builtin_attribute
+                    (strided_layout
+                      (integer_literal)))))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))
+                (attribute_value
+                  (builtin_attribute
+                    (strided_layout))))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))
+                (attribute_value
+                  (builtin_attribute
+                    (strided_layout
+                      (integer_literal))))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (nested_idx_list
+                    (nested_idx_list
+                      (integer_literal)
+                      (integer_literal))
+                    (nested_idx_list
+                      (integer_literal)))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (nested_idx_list
+                    (nested_idx_list
+                      (integer_literal)
+                      (integer_literal))
+                    (nested_idx_list
+                      (integer_literal)))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (nested_idx_list
+                    (nested_idx_list
+                      (integer_literal)
+                      (integer_literal))
+                    (nested_idx_list
+                      (integer_literal)))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout
+                              (integer_literal)))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout
+                              (integer_literal))))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (nested_idx_list
+                    (nested_idx_list
+                      (integer_literal)
+                      (integer_literal))
+                    (nested_idx_list
+                      (integer_literal)))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout
+                              (integer_literal)))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout
+                              (integer_literal))))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (nested_idx_list
+                    (nested_idx_list
+                      (integer_literal)
+                      (integer_literal))
+                    (nested_idx_list
+                      (integer_literal)))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout)))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (nested_idx_list
+                    (nested_idx_list
+                      (integer_literal)
+                      (integer_literal))
+                    (nested_idx_list
+                      (integer_literal)))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout)))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (nested_idx_list
+                    (nested_idx_list
+                      (integer_literal)
+                      (integer_literal)))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout
+                              (integer_literal)))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout)))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (nested_idx_list
+                    (nested_idx_list
+                      (integer_literal)
+                      (integer_literal)))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+memref.realloc
+================================================================================
+func.func @memref_realloc_sd(%src : memref<2xf32>, %d : index) -> memref<?xf32>{
+  %0 = memref.realloc %src(%d) : memref<2xf32> to memref<?xf32>
+  return %0 : memref<?xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (memref_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+memref.prefetch
+================================================================================
+func.func @prefetch_locality_hint(%i : index) {
+  %0 = memref.alloc() : memref<10xf32>
+  memref.prefetch %0[%i], read, locality<3>, data  : memref<10xf32>
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (value_use)
+                  (isWrite_attr)
+                  (localityHint_attr
+                    (integer_literal))
+                  (isDataCache_attr)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+memref.rank
+================================================================================
+func.func @rank(%t : memref<4x4x?xf32>) {
+  %0 = memref.rank %t : memref<4x4x?xf32>
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+memref.store
+================================================================================
+func.func @truncation_spillover(%arg0 : memref<?xi32>) -> index {
+    %c0 = arith.constant 0 : index
+    %c1 = arith.constant 1 : index
+    %c2 = arith.constant 2 : index
+    %c49 = arith.constant 49 : index
+    %0 = scf.for %arg1 = %c0 to %c2 step %c1 iter_args(%arg2 = %c0) -> index {
+        %1 = arith.divsi %arg2, %c49 : index
+        %2 = arith.index_cast %1 : index to i32
+        memref.store %2, %arg0[%c0] : memref<?xi32>
+        %3 = arith.addi %arg2, %arg1 : index
+        scf.yield %3 : index
+    }
+  func.return %0 : index
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (integer_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (index_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (scf_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (index_type)))
+                  (region
+                    (entry_block
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (index_type))))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (index_type)))
+                            (type
+                              (builtin_type
+                                (integer_type))))))
+                      (operation
+                        (custom_operation
+                          (memref_dialect
+                            (value_use)
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (memref_type
+                                  (dim_list
+                                    (integer_type))))))))
+                      (operation
+                        (op_result
+                          (value_use))
+                        (custom_operation
+                          (arith_dialect
+                            (value_use)
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (index_type))))))
+                      (operation
+                        (custom_operation
+                          (scf_dialect
+                            (value_use)
+                            (type
+                              (builtin_type
+                                (index_type)))))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (index_type))))))))))))
+
+================================================================================
+memref.reinterpret_cast
+================================================================================
+func.func @memref_reinterpret_cast_static_to_dynamic_sizes(%in: memref<?xf32>)
+    -> memref<10x?xf32, strided<[?, 1], offset: ?>> {
+  %out = memref.reinterpret_cast %in to
+           offset: [1], sizes: [10, 10], strides: [1, 1]
+           : memref<?xf32> to memref<10x?xf32, strided<[?, 1], offset: ?>>
+  return %out : memref<10x?xf32, strided<[?, 1], offset: ?>>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (memref_type
+                  (dim_list
+                    (float_type))
+                  (attribute_value
+                    (builtin_attribute
+                      (strided_layout))))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout)))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))
+                        (attribute_value
+                          (builtin_attribute
+                            (strided_layout)))))))))))))))
+
+================================================================================
+cf.assert
+================================================================================
+func.func @assert(%arg : i1) {
+  cf.assert %arg, "Some message in case this assertion fails."
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type))))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (cf_dialect
+                  (value_use)
+                  (string_literal))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+vector.splat
+================================================================================
+func.func @signExtendConstantSplat() -> vector<4xi16> {
+  %c-2 = arith.constant -2 : i8
+  %splat = vector.splat %c-2 : vector<4xi8>
+  %ext = arith.extsi %splat : vector<4xi8> to vector<4xi16>
+  return %ext : vector<4xi16>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))))))))
+
+================================================================================
+arith.cmpi with string parameter
+================================================================================
+func.func @notCmpEQ(%arg0: i8, %arg1: i8) -> i1 {
+  %true = arith.constant true
+  %cmp = arith.cmpi "eq", %arg0, %arg1 : i8
+  %ncmp = arith.xori %cmp, %true : i1
+  return %ncmp : i1
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (integer_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (bool_literal))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (string_literal)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type))))))))))))
+
+================================================================================
+bufferization.alloc_tensor
+================================================================================
+func.func @test_alloc_tensor_op(%t: tensor<?x5xf32>, %sz: index)
+  -> tensor<?x5xf32>
+{
+  %0 = bufferization.alloc_tensor(%sz) : tensor<?x5xf32>
+  %1 = bufferization.alloc_tensor() copy(%t) : tensor<?x5xf32>
+  %2 = bufferization.alloc_tensor() : tensor<5x6xf32>
+  %3 = bufferization.alloc_tensor(%sz, %sz) : tensor<?x?xf32>
+  %4 = bufferization.alloc_tensor() copy(%t) {escape = true} : tensor<?x5xf32>
+  %5 = bufferization.alloc_tensor() copy(%t) {escape = false} : tensor<?x5xf32>
+  %c100 = arith.constant 100 : index
+  %6 = bufferization.alloc_tensor() size_hint=%c100 : tensor<100x100xf64, #CSR>
+  %7 = bufferization.alloc_tensor(%sz) {memory_space = "foo"} : tensor<?xf32>
+  return %1 : tensor<?x5xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (float_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (bufferization_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (bufferization_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (bufferization_dialect
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (bufferization_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (bufferization_dialect
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (bool_literal)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (bufferization_dialect
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (bool_literal)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (bufferization_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))
+                        (tensor_encoding
+                          (attribute_value
+                            (attribute_alias)))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (bufferization_dialect
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (string_literal)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))))))))
+
+================================================================================
+vector.transfer_read and vector.transfer_write
+================================================================================
+func.func @vector_transfer_ops(%arg0: memref<?x?xf32>,
+                          %arg1 : memref<?x?xvector<4x3xf32>>,
+                          %arg2 : memref<?x?xvector<4x3xi32>>,
+                          %arg3 : memref<?x?xvector<4x3xindex>>,
+                          %arg4 : memref<?x?x?xf32>) {
+  %c3 = arith.constant 3 : index
+  %cst = arith.constant 3.0 : f32
+  %f0 = arith.constant 0.0 : f32
+  %c0 = arith.constant 0 : i32
+  %i0 = arith.constant 0 : index
+  %i1 = arith.constant 1 : i1
+
+  %vf0 = vector.splat %f0 : vector<4x3xf32>
+  %v0 = vector.splat %c0 : vector<4x3xi32>
+  %vi0 = vector.splat %i0 : vector<4x3xindex>
+  %m = arith.constant dense<[0, 0, 1, 0, 1]> : vector<5xi1>
+  %m2 = vector.splat %i1 : vector<4x5xi1>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %f0 {permutation_map = affine_map<(d0, d1)->(d0)>} : memref<?x?xf32>, vector<128xf32>
+  %1 = vector.transfer_read %arg0[%c3, %c3], %f0 {permutation_map = affine_map<(d0, d1)->(d1, d0)>} : memref<?x?xf32>, vector<3x7xf32>
+  %2 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d0)>} : memref<?x?xf32>,  vector<128xf32>
+  %3 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d1)>} : memref<?x?xf32>,  vector<128xf32>
+  %4 = vector.transfer_read %arg1[%c3, %c3], %vf0 {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>
+  %5 = vector.transfer_read %arg1[%c3, %c3], %vf0 {in_bounds = [false, true]} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>
+  %6 = vector.transfer_read %arg2[%c3, %c3], %v0 : memref<?x?xvector<4x3xi32>>, vector<5x24xi8>
+  %7 = vector.transfer_read %arg3[%c3, %c3], %vi0 : memref<?x?xvector<4x3xindex>>, vector<5x48xi8>
+  %8 = vector.transfer_read %arg0[%c3, %c3], %f0, %m : memref<?x?xf32>, vector<5xf32>
+  %9 = vector.transfer_read %arg4[%c3, %c3, %c3], %f0, %m2 {permutation_map = affine_map<(d0, d1, d2)->(d1, d0, 0)>} : memref<?x?x?xf32>, vector<5x4x8xf32>
+
+  vector.transfer_write %0, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0)>} : vector<128xf32>, memref<?x?xf32>
+  vector.transfer_write %1, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d1, d0)>} : vector<3x7xf32>, memref<?x?xf32>
+  vector.transfer_write %4, %arg1[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : vector<1x1x4x3xf32>, memref<?x?xvector<4x3xf32>>
+  vector.transfer_write %5, %arg1[%c3, %c3] {in_bounds = [false, false]} : vector<1x1x4x3xf32>, memref<?x?xvector<4x3xf32>>
+  vector.transfer_write %6, %arg2[%c3, %c3] : vector<5x24xi8>, memref<?x?xvector<4x3xi32>>
+  vector.transfer_write %7, %arg3[%c3, %c3] : vector<5x48xi8>, memref<?x?xvector<4x3xindex>>
+  vector.transfer_write %8, %arg0[%c3, %c3], %m : vector<5xf32>, memref<?x?xf32>
+
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (vector_type
+                    (vector_dim_list)
+                    (float_type))))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (vector_type
+                    (vector_dim_list)
+                    (integer_type))))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (vector_type
+                    (vector_dim_list)
+                    (index_type))))))
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (float_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (float_literal)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (float_literal)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (index_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (tensor_literal
+                    (nested_idx_list
+                      (integer_literal)
+                      (integer_literal)
+                      (integer_literal)
+                      (integer_literal)
+                      (integer_literal)))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (vector_type
+                            (vector_dim_list)
+                            (float_type))))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (bool_literal)
+                          (bool_literal)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (vector_type
+                            (vector_dim_list)
+                            (float_type))))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (vector_type
+                            (vector_dim_list)
+                            (integer_type))))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (vector_type
+                            (vector_dim_list)
+                            (index_type))))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)
+                              (integer_literal)))))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))
+            (operation
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)))))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)))))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (builtin_attribute
+                            (affine_map
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)
+                              (bare_id)))))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (vector_type
+                            (vector_dim_list)
+                            (float_type)))))))))
+            (operation
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (attribute
+                    (dictionary_attribute
+                      (attribute_entry
+                        (bare_id)
+                        (attribute_value
+                          (bool_literal)
+                          (bool_literal)))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (vector_type
+                            (vector_dim_list)
+                            (float_type)))))))))
+            (operation
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (vector_type
+                            (vector_dim_list)
+                            (integer_type)))))))))
+            (operation
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (vector_type
+                            (vector_dim_list)
+                            (index_type)))))))))
+            (operation
+              (custom_operation
+                (vector_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))

mlir/utils/tree-sitter-mlir/test/corpus/type.txt

+================================================================================
+Tensor type of known dimensions
+================================================================================
+func.func @test_addi_tensor(%arg0 : tensor<8x8xi64>, %arg1 : tensor<8x8xi64>) -> tensor<8x8xi64> {
+  %0 = arith.addi %arg0, %arg1 : tensor<8x8xi64>
+  return %0 : tensor<8x8xi64>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (integer_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (integer_type))))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (tensor_type
+                  (dim_list
+                    (integer_type)))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))))))))
+
+================================================================================
+vector type with one dimension
+================================================================================
+func.func @test_addi_vector(%arg0 : vector<8xi64>, %arg1 : vector<8xi64>) -> vector<8xi64> {
+  %0 = arith.addi %arg0, %arg1 : vector<8xi64>
+  return %0 : vector<8xi64>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (vector_type
+                (vector_dim_list)
+                (integer_type))))
+          (value_use)
+          (type
+            (builtin_type
+              (vector_type
+                (vector_dim_list)
+                (integer_type)))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))))))))
+
+================================================================================
+vector type without dimensions
+================================================================================
+func.func @test_cmpi_vector_0d(%arg0 : vector<i64>, %arg1 : vector<i64>) -> vector<i1> {
+  %0 = arith.cmpi ult, %arg0, %arg1 : vector<i64>
+  return %0 : vector<i1>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (vector_type
+                (integer_type))))
+          (value_use)
+          (type
+            (builtin_type
+              (vector_type
+                (integer_type)))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (vector_type
+                  (integer_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (integer_type)))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (integer_type)))))))))))))
+
+================================================================================
+vector type with multiple dimensions
+================================================================================
+func.func @cmpi_equal_vector_operands(%arg0: vector<1x8xi64>)
+    -> (vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>,
+        vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>,
+  vector<1x8xi1>, vector<1x8xi1>) {
+  %0 = arith.cmpi eq, %arg0, %arg0 : vector<1x8xi64>
+  %1 = arith.cmpi sle, %arg0, %arg0 : vector<1x8xi64>
+  %2 = arith.cmpi sge, %arg0, %arg0 : vector<1x8xi64>
+  %3 = arith.cmpi ule, %arg0, %arg0 : vector<1x8xi64>
+  %4 = arith.cmpi uge, %arg0, %arg0 : vector<1x8xi64>
+  %5 = arith.cmpi ne, %arg0, %arg0 : vector<1x8xi64>
+  %6 = arith.cmpi slt, %arg0, %arg0 : vector<1x8xi64>
+  %7 = arith.cmpi sgt, %arg0, %arg0 : vector<1x8xi64>
+  %8 = arith.cmpi ult, %arg0, %arg0 : vector<1x8xi64>
+  %9 = arith.cmpi ugt, %arg0, %arg0 : vector<1x8xi64>
+  return %0, %1, %2, %3, %4, %5, %6, %7, %8, %9
+      : vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>,
+        vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>, vector<1x8xi1>,
+  vector<1x8xi1>, vector<1x8xi1>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (vector_type
+                (vector_dim_list)
+                (integer_type)))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type))))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))))))))
+
+================================================================================
+Scalable vector type
+================================================================================
+func.func @test_addi_scalable_vector(%arg0 : vector<[8]xi64>, %arg1 : vector<[8]xi64>)
+  -> vector<[8]xi64> {
+  %0 = arith.addi %arg0, %arg1 : vector<[8]xi64>
+  return %0 : vector<[8]xi64>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (vector_type
+                (vector_dim_list)
+                (integer_type))))
+          (value_use)
+          (type
+            (builtin_type
+              (vector_type
+                (vector_dim_list)
+                (integer_type)))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (integer_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (integer_type)))))))))))))
+
+================================================================================
+!llvm.ptr dialect type
+================================================================================
+llvm.func @byvalattr(%arg0: !llvm.ptr<i32> {llvm.byval}) {
+  llvm.return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (llvm_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (dialect_type
+              (pretty_dialect_item
+                (dialect_namespace)
+                (dialect_ident)
+                (pretty_dialect_item_body))))
+          (attribute
+            (dictionary_attribute
+              (attribute_entry
+                (bare_id)))))
+        (region
+          (entry_block
+            (operation
+              (custom_operation
+                (llvm_dialect)))))))))
+
+================================================================================
+Linalg matmul with memref of unknown dimensions
+================================================================================
+func.func @matmul(%arg0: memref<?xi8>, %M: index, %N: index, %K: index) {
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %A = memref.view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32>
+  %B = memref.view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32>
+  %C = memref.view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32>
+  linalg.matmul ins(%A, %B: memref<?x?xf32>, memref<?x?xf32>)
+                outs(%C: memref<?x?xf32>)
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (memref_type
+                (dim_list
+                  (integer_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type)))
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (integer_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (integer_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (memref_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (integer_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (linalg_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type)))))
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (memref_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+Various tensors of dimensions `?` and `*` using tensor.cast
+================================================================================
+func.func @cast(%arg0: tensor<*xf32>, %arg1 : tensor<4x4xf32>, %arg2: tensor<?x?xf32>) {
+  %0 = tensor.cast %arg0 : tensor<*xf32> to tensor<?x?xf32>
+  %1 = tensor.cast %arg1 : tensor<4x4xf32> to tensor<*xf32>
+  %2 = tensor.cast %arg2 : tensor<?x?xf32> to tensor<4x?xf32>
+  %3 = tensor.cast %2 : tensor<4x?xf32> to tensor<?x?xf32>
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type)))))
+          (value_use)
+          (type
+            (builtin_type
+              (tensor_type
+                (dim_list
+                  (float_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+Dense and sparse matrix literals
+================================================================================
+func.func @fold_extract(%arg0 : index) -> (f32, f16, f16, i32, complex<f32>) {
+  %const_0 = arith.constant 0 : index
+  %const_1 = arith.constant 1 : index
+  %const_3 = arith.constant 3 : index
+
+  %0 = arith.constant dense<4.0> : tensor<4xf32>
+  %ext_1 = tensor.extract %0[%arg0] : tensor<4xf32>
+
+  // Fold an extract into a sparse with a sparse index.
+  %1 = arith.constant sparse<[[0, 0, 0], [1, 1, 1]],  [-5.0, -2.0]> : tensor<4x4x4xf16>
+  %ext_2 = tensor.extract %1[%const_1, %const_1, %const_1] : tensor<4x4x4xf16>
+
+  // Fold an extract into a sparse with a non sparse index.
+  %2 = arith.constant sparse<[[1, 1, 1]],  [-2.0]> : tensor<2x2x2xf16>
+  %ext_3 = tensor.extract %2[%const_0, %const_0, %const_0] : tensor<2x2x2xf16>
+
+  // Fold an extract into a dense tensor.
+  %3 = arith.constant dense<[[[1, -2, 1, 36]], [[0, 2, -1, 64]]]> : tensor<2x1x4xi32>
+  %ext_4 = tensor.extract %3[%const_1, %const_0, %const_3] : tensor<2x1x4xi32>
+
+  // Fold an extract into a complex constant.
+  %4 = arith.constant dense<(1.2, 2.3)> : tensor<complex<f32>>
+  %ext_5 = tensor.extract %4[] : tensor<complex<f32>>
+
+  return %ext_1, %ext_2, %ext_3, %ext_4, %ext_5 : f32, f16, f16, i32, complex<f32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (index_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (float_type)))
+            (type
+              (builtin_type
+                (float_type)))
+            (type
+              (builtin_type
+                (float_type)))
+            (type
+              (builtin_type
+                (integer_type)))
+            (type
+              (builtin_type
+                (complex_type
+                  (float_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (tensor_literal
+                    (float_literal))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (comment)
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (tensor_literal
+                    (nested_idx_list
+                      (nested_idx_list
+                        (integer_literal)
+                        (integer_literal)
+                        (integer_literal))
+                      (nested_idx_list
+                        (integer_literal)
+                        (integer_literal)
+                        (integer_literal)))
+                    (nested_idx_list
+                      (float_literal)
+                      (float_literal)))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (comment)
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (tensor_literal
+                    (nested_idx_list
+                      (nested_idx_list
+                        (integer_literal)
+                        (integer_literal)
+                        (integer_literal)))
+                    (nested_idx_list
+                      (float_literal)))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (float_type))))))))
+            (comment)
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (tensor_literal
+                    (nested_idx_list
+                      (nested_idx_list
+                        (nested_idx_list
+                          (integer_literal)
+                          (integer_literal)
+                          (integer_literal)
+                          (integer_literal)))
+                      (nested_idx_list
+                        (nested_idx_list
+                          (integer_literal)
+                          (integer_literal)
+                          (integer_literal)
+                          (integer_literal)))))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (integer_type))))))))
+            (comment)
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (tensor_literal
+                    (complex_literal
+                      (float_literal)
+                      (float_literal)))
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (complex_type
+                            (float_type)))))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (tensor_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (tensor_type
+                        (dim_list
+                          (complex_type
+                            (float_type)))))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (float_type)))
+                  (type
+                    (builtin_type
+                      (float_type)))
+                  (type
+                    (builtin_type
+                      (float_type)))
+                  (type
+                    (builtin_type
+                      (integer_type)))
+                  (type
+                    (builtin_type
+                      (complex_type
+                        (float_type)))))))))))))
+
+================================================================================
+Empty dense literal
+================================================================================
+func.func @empty_dense_literal() -> () {
+  "foo2"(){bar = dense<> : tensor<0xi32>} : () -> ()
+  return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens))
+        (region
+          (entry_block
+            (operation
+              (generic_operation
+                (string_literal)
+                (attribute
+                  (dictionary_attribute
+                    (attribute_entry
+                      (bare_id)
+                      (attribute_value
+                        (tensor_literal)
+                        (type
+                          (builtin_type
+                            (tensor_type
+                              (dim_list
+                                (integer_type)))))))))
+                (function_type)))
+            (operation
+              (custom_operation
+                (func_dialect)))))))))
+
+================================================================================
+!llvm.struct dialect type
+================================================================================
+llvm.func @return_s_long() ->
+  !llvm.struct<"long", (i32, struct<(i32, i1)>, f32, ptr<func<void ()>>)>
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (llvm_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (func_return
+          (type_list_attr_parens
+            (type
+              (dialect_type
+                (pretty_dialect_item
+                  (dialect_namespace)
+                  (dialect_ident)
+                  (pretty_dialect_item_body
+                    (pretty_dialect_item_body)
+                    (pretty_dialect_item_body
+                      (pretty_dialect_item_body))))))))))))
+
+================================================================================
+Type alias definition
+================================================================================
+!baz = i64
+!qux = !llvm.struct<(!baz)>
+!rec = !llvm.struct<"a", (ptr<struct<"a">>)>
+llvm.func @aliases() {
+  "some.op"() : () -> !llvm.struct<(i32, f32, !qux)>
+  "some.op"() : () -> !rec
+  llvm.return
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (type_alias_def
+    (type
+      (builtin_type
+        (integer_type))))
+  (type_alias_def
+    (type
+      (dialect_type
+        (pretty_dialect_item
+          (dialect_namespace)
+          (dialect_ident)
+          (pretty_dialect_item_body)))))
+  (type_alias_def
+    (type
+      (dialect_type
+        (pretty_dialect_item
+          (dialect_namespace)
+          (dialect_ident)
+          (pretty_dialect_item_body
+            (pretty_dialect_item_body
+              (pretty_dialect_item_body)))))))
+  (operation
+    (custom_operation
+      (llvm_dialect
+        (symbol_ref_id)
+        (func_arg_list)
+        (region
+          (entry_block
+            (operation
+              (generic_operation
+                (string_literal)
+                (function_type
+                  (type
+                    (dialect_type
+                      (pretty_dialect_item
+                        (dialect_namespace)
+                        (dialect_ident)
+                        (pretty_dialect_item_body)))))))
+            (operation
+              (generic_operation
+                (string_literal)
+                (function_type
+                  (type
+                    (type_alias)))))
+            (operation
+              (custom_operation
+                (llvm_dialect)))))))))
+
+================================================================================
+negative constant value_use
+================================================================================
+func.func @indexCastFold(%arg0: i8) -> index {
+  %c-2 = arith.constant -2 : i8
+  %idx = arith.index_cast %c-2 : i8 to index
+  return %idx : index
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (integer_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (index_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (integer_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (integer_type)))
+                  (type
+                    (builtin_type
+                      (index_type))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (index_type))))))))))))
+
+================================================================================
+inf value_use
+================================================================================
+func.func @test_maxf(%arg0 : f32) -> f32 {
+  %c0 = arith.constant 0.0 : f32
+  %-inf = arith.constant 0xFF800000 : f32
+  %0 = arith.maxf %-inf, %arg0 : f32
+  return %0 : f32
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (float_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (float_type)))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (float_literal)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (integer_literal)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (op_result
+                (value_use))
+              (custom_operation
+                (arith_dialect
+                  (value_use)
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (float_type))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (float_type))))))))))))
+
+================================================================================
+array literal
+================================================================================
+func.func @foo(%a : f32) -> vector<1x2xf32> {
+  %0 = "test_create_broadcast"(%a) {broadcast_dims = array<i64: 0, 1>} : (f32) -> vector<1x2xf32>
+  return %0: vector<1x2xf32>
+}
+--------------------------------------------------------------------------------
+
+(toplevel
+  (operation
+    (custom_operation
+      (func_dialect
+        (symbol_ref_id)
+        (func_arg_list
+          (value_use)
+          (type
+            (builtin_type
+              (float_type))))
+        (func_return
+          (type_list_attr_parens
+            (type
+              (builtin_type
+                (vector_type
+                  (vector_dim_list)
+                  (float_type))))))
+        (region
+          (entry_block
+            (operation
+              (op_result
+                (value_use))
+              (generic_operation
+                (string_literal)
+                (value_use)
+                (attribute
+                  (dictionary_attribute
+                    (attribute_entry
+                      (bare_id)
+                      (attribute_value
+                        (array_literal
+                          (type
+                            (builtin_type
+                              (integer_type)))
+                          (integer_literal)
+                          (integer_literal))))))
+                (function_type
+                  (type
+                    (builtin_type
+                      (float_type)))
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))
+            (operation
+              (custom_operation
+                (func_dialect
+                  (value_use)
+                  (type
+                    (builtin_type
+                      (vector_type
+                        (vector_dim_list)
+                        (float_type)))))))))))))

mlir/utils/tree-sitter-mlir/test/highlight/attribute.mlir

+func.func @depthwise_conv_1d_nwc_wcm(%input: tensor<1x12x8xf32>, %filter: tensor<3x8x8xf32>)
+// <- function.builtin
+//        ^ function
+//                                   ^ variable.parameter
+//                                           ^ type.builtin
+//                                                               ^ variable.parameter
+//                                                                        ^ type.builtin
+  -> tensor<1x10x8x8xf32> {
+// ^ operator
+//   ^ type.builtin
+  %zero = arith.constant 0.000000e+00 : f32
+// ^ variable
+//        ^ function.builtin
+//                       ^ number
+//                                      ^ type.builtin
+  %init = tensor.empty() : tensor<1x10x8x8xf32>
+// ^ variable
+//        ^ function.builtin
+//                         ^ type.builtin
+  %fill = linalg.fill ins(%zero : f32) outs(%init : tensor<1x10x8x8xf32>) -> tensor<1x10x8x8xf32>
+// ^ variable
+//        ^ function.builtin
+//                    ^ keyword
+//                        ^ variable
+//                                ^ type.builtin
+//                                     ^ keyword
+  %0 = linalg.depthwise_conv_1d_nwc_wcm {dilations = dense<1> : tensor<1xi64>,
+// ^ variable
+//     ^ function.builtin
+//                                       ^ attribute
+//                                                   ^ constant.builtin
+    strides = dense<1> : tensor<1xi64>}
+//            ^ constant.builtin
+    ins(%input, %filter : tensor<1x12x8xf32>, tensor<3x8x8xf32>)
+//      ^ variable.parameter
+//              ^ variable.parameter
+    outs(%fill : tensor<1x10x8x8xf32>) -> tensor<1x10x8x8xf32>
+//       ^ variable
+  return %0 : tensor<1x10x8x8xf32>
+// ^ function.builtin
+//       ^ variable
+}
+
+func.func @fastmath(%arg0: f32, %arg1: f32) {
+// <- function.builtin
+//        ^ function
+//                  ^ variable.parameter
+//                         ^ type.builtin
+//                              ^ variable.parameter
+//                                     ^ type.builtin
+  %5 = arith.negf %arg0 fastmath<fast> : f32
+//     ^ function.builtin
+//                      ^ attribute
+  %6 = arith.addf %arg0, %arg1 fastmath<none> : f32
+//     ^ function.builtin
+//                             ^ attribute
+  %8 = arith.mulf %arg0, %arg1 fastmath<reassoc,nnan,ninf,nsz,arcp,contract,afn> : f32
+//     ^ function.builtin
+//                             ^ attribute
+  return
+// ^ function.builtin
+}
+
+#map0 = affine_map<(d0, d1) -> (d0, d1)>
+// <- attribute
+//      ^ attribute
+#map1 = affine_map<(d0, d1) -> (d0)>
+// <- attribute
+//      ^ attribute
+#map2 = affine_map<(d0) -> (d0)>
+// <- attribute
+//      ^ attribute
+
+func.func @add_broadcast_mul_fusion(%arg0: tensor<?xf32>, %arg1 : tensor<?xf32>,
+  %arg2 : tensor<?x?xf32>) -> tensor<?x?xf32>
+{
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %0 = tensor.dim %arg0, %c0 : tensor<?xf32>
+  %1 = tensor.empty(%0) : tensor<?xf32>
+  %2 = linalg.generic {indexing_maps = [#map2, #map2, #map2], iterator_types = ["parallel"]}
+//                                      ^ attribute
+//                                             ^ attribute
+//                                                    ^ attribute
+      ins(%arg0, %arg1 : tensor<?xf32>, tensor<?xf32>)
+//    ^ keyword
+      outs(%1 : tensor<?xf32>) {
+//    ^ keyword
+    ^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
+      %3 = arith.addf %arg3, %arg4 : f32
+      linalg.yield %3 : f32
+  } -> tensor<?xf32>
+  %3 = tensor.dim %arg2, %c1 : tensor<?x?xf32>
+  %4 = tensor.empty(%0, %3) : tensor<?x?xf32>
+  %5 = linalg.generic {indexing_maps = [#map1, #map0, #map0], iterator_types = ["parallel", "parallel"]}
+//     ^ function.builtin
+      ins(%2, %arg2 : tensor<?xf32>, tensor<?x?xf32>)
+      outs(%4 : tensor<?x?xf32>){
+    ^bb0(%arg5: f32, %arg6: f32, %arg7: f32):
+      %6 = arith.mulf %arg5, %arg6 : f32
+      linalg.yield %6 : f32
+    } -> tensor<?x?xf32>
+  return %5 : tensor<?x?xf32>
+}
+
+func.func @broadcast(%input: tensor<8x32xf32>,
+                     %init: tensor<8x16x32xf32>) -> tensor<8x16x32xf32> {
+  %bcast = linalg.broadcast
+//         ^ function.builtin
+      ins(%input:tensor<8x32xf32>)
+//    ^ keyword
+      outs(%init:tensor<8x16x32xf32>)
+//    ^ keyword
+      dimensions = [1]
+//    ^ attribute
+  func.return %bcast : tensor<8x16x32xf32>
+}

mlir/utils/tree-sitter-mlir/test/highlight/controlflow.mlir

+func.func @simple(i64, i1) -> i64 {
+// <- function.builtin
+//        ^ function
+//               ^ punctuation.bracket
+//                ^ type.builtin
+//                   ^ punctuation.delimeter
+//                     ^ type.builtin
+//                       ^ punctuation.bracket
+//                         ^ operator
+//                            ^ type.builtin
+//                                ^ punctuation.bracket
+^bb0(%a: i64, %cond: i1):
+// <- tag
+//   ^ variable.parameter
+//       ^ type.builtin
+//            ^ variable.parameter
+//                   ^ type.builtin
+  cf.cond_br %cond, ^bb1, ^bb2
+// ^ function.builtin
+//           ^ variable.parameter
+//                  ^ tag
+//                        ^ tag
+
+^bb1:
+// <- tag
+  cf.br ^bb3(%a: i64)    // Branch passes %a as the argument
+// ^ function.builtin
+//      ^ tag
+//           ^ variable.parameter
+//               ^ type.builtin
+//                       ^ comment
+
+^bb2:
+// <- tag
+  %b = arith.addi %a, %a : i64
+// ^ variable
+//   ^ operator
+//     ^ function.builtin
+//                ^ variable.parameter
+//                    ^ variable.parameter
+//                         ^ type.builtin
+  cf.br ^bb3(%b: i64)    // Branch passes %b as the argument
+// ^ function.builtin
+//      ^ tag
+//           ^ variable
+//               ^ type.builtin
+//                       ^ comment
+^bb3(%c: i64):
+// <- tag
+//   ^ variable.parameter
+//        ^ type.builtin
+  cf.br ^bb4(%c, %a : i64, i64)
+// ^ function.builtin
+//      ^ tag
+//           ^ variable.parameter
+//               ^ variable.parameter
+//                    ^ type.builtin
+//                         ^ type.builtin
+^bb4(%d : i64, %e : i64):
+// <- tag
+//   ^ variable.parameter
+//        ^ type.builtin
+//             ^ variable.parameter
+//                  ^ type.builtin
+  %0 = arith.addi %d, %e : i64
+// ^ variable
+//   ^ operator
+//     ^ function.builtin
+//                ^ variable.parameter
+//                    ^ variable.parameter
+//                          ^ type.builtin
+  return %0 : i64   // Return is also a terminator.
+// ^ function.builtin
+//       ^ variable
+//            ^ type.builtin
+//                  ^ comment
+}
+// <- punctuation.bracket

mlir/utils/tree-sitter-mlir/test/highlight/downstream.mlir

+func.func @sort_memref(%input1: memref<?x?xf32>, %input2: memref<?x?xi32>,
+// <- function.builtin
+//        ^ function
+//                     ^ variable.parameter
+//                              ^ type.builtin
+                       %init1: memref<?x?xf32>, %init2: memref<?x?xi32>) {
+  thlo.sort
+      ins(%input1: memref<?x?xf32>, %input2: memref<?x?xi32>)
+//    ^ keyword
+//                                  ^ variable.parameter
+      outs(%init1: memref<?x?xf32>, %init2: memref<?x?xi32>)
+//    ^ keyword
+//                                  ^ variable.parameter
+      { dimension = 0 : i64, is_stable = true }
+//                                       ^ constant.builtin
+      (%e11: f32, %e12: f32, %e21: i32, %e22: i32) {
+        %gt = arith.cmpf ogt, %e11, %e12: f32
+//            ^ function.builtin
+//                       ^ keyword
+//                            ^ variable
+//                                  ^ variable
+//                                        ^ type.builtin
+        thlo.yield %gt : i1
+      }
+  func.return
+// ^ function.builtin
+}

mlir/utils/tree-sitter-mlir/test/highlight/func.mlir

+func.func @test_addi(%arg0 : i64, %arg1 : i64) -> i64 {
+// <- function.builtin
+//        ^ function
+//                  ^ punctuation.bracket
+//                   ^ variable.parameter
+//                         ^ punctuation.delimeter
+//                           ^ type.builtin
+//                              ^ punctuation.delimeter
+//                                ^ variable.parameter
+//                                        ^ type.builtin
+//                                           ^ punctuation.bracket
+//                                             ^ operator
+//                                                ^ type.builtin
+//                                                    ^ punctuation.bracket
+  %0 = arith.addi %arg0, %arg1 : i64
+// ^ variable
+//   ^ operator
+//     ^ function.builtin
+//                ^ variable.parameter
+//                       ^ variable.parameter
+//                               ^ type.builtin
+  return %0 : i64
+// ^ function.builtin
+//       ^ variable
+//            ^ type.builtin
+}
+// <- punctuation.bracket

mlir/utils/tree-sitter-mlir/test/highlight/type.mlir

+!baz = i64
+// <- type
+//     ^ type.builtin
+!qux = !llvm.struct<(!baz)>
+// <- type
+//     ^ type
+!rec = !llvm.struct<"a", (ptr<struct<"a">>)>
+// <- type
+//     ^ type
+llvm.func @aliases() {
+// <- function.builtin
+//        ^ function
+  "some.op"() : () -> !llvm.struct<(i32, f32, !qux)>
+//                    ^ type
+  "some.op"() : () -> !rec
+//                    ^ type
+  llvm.return
+// ^ function.builtin
+}