[mlir] Change the syntax of AffineMapAttr and IntegerSetAttr to avoid conflicts with function types.

[rriddle]

Summary

The current syntax for AffineMapAttr and IntegerSetAttr conflict with function types, making it currently impossible to round-trip function types(and e.g. FuncOp) in the IR. This revision changes the syntax for the attributes by wrapping them in a keyword. AffineMapAttr is wrapped with affine_map<> and IntegerSetAttr is wrapped with affine_set<>.

[nicolasvasilache]

This is most welcome, thanks!

[merge_guards_bot]

Unit tests: fail. 61168 tests passed, 1 failed and 728 were skipped.

failed: libc++.std/thread/thread_mutex/thread_mutex_requirements/thread_mutex_requirements_mutex/thread_mutex_class/try_lock.pass.cpp

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[bondhugula]

How about just using a space after the keyword instead of angular brackets? The angular bracket right before/after the parenthesis looks a bit clumsy, and there is no specialization being implied on the map/set. It's a character less with the space FWIW. And we could drop affine_ as well - those are the only maps and sets, and it prevents repetition at several places (like affine.apply affine_map, affine.if affine_set ..., affine.for %i = affine_map...).

With the space and affine_ dropped:

affine.for %j = 0 to map (d0) -> (d0 - d0 mod 4) (%i)

#map1 = map (d0, d1) -> ((d0 * 2048 + d1 * 256) floordiv 32)

memref<512 x 512 x i32, map (d0, d1) -> (d0, d1), 2>

affine.if set (d0, d1) : ...

[rriddle]

In D72429#1811319, @bondhugula wrote:

How about just using a space after the keyword instead of angular brackets? The angular bracket right before/after the parenthesis looks a bit clumsy, and there is no specialization being implied on the

I don't see it as a specialization, it is a grouping mechanism that clearly delineate the scope of the attribute. We use this in many other places and doesn't imply that. I personally find the space to create a clumsier syntax as it makes it more difficult for me to tell what is actually part of the syntax. For example, there are many cases where we end up something like () : () () or (...) -> (...) (...). For me it is much easier to read something like: set<() : ()> () or map<() -> ()> (). Is there some other delimiter grouping that would be less clumsy for you? {} perhaps? set{() : ()}()/map{() -> ()}()?

map/set. It's a character less with the space FWIW. And we could drop affine_ as well - those are the only maps and sets, and it prevents repetition at several places (like affine.apply affine_map, affine.if > affine_set ..., affine.for %i = affine_map...).

Happy to drop the 'affine_', but it should be noted that this only removed ambiguity for the affine dialect. There are other users of these attributes that don't have this problem.

[ftynse]

I support the reasoning for having delimiters around the actual map. I've always found the cases of immediate inline application confusing, especially for maps: (d0)[s0] -> (d0,s0)(%0)[%1].

I am also supportive of keeping the affine_ prefix in the name, since it clearly indicates the affine-ness of the attribute, e.g. the kind of sets/maps that can be expressed. We may eventually consider other similar attributes, like permutation-only maps, that could be clearly denoted now. I don't think repetition is a big problem, we are doing an IR after all, and we repeat types for all uses of a value, for example. If it proves to be annoying, we could consider having a special syntax for affine loops and branches that supports "inline" maps and sets without the affine_map token at all. We already have special syntax for affine loads and stores anyway, so it can be adapted and reused.

mlir/docs/Dialects/Affine.md

302

This looks like it would take an unprefixed affine map. There may be other places that say they consume "affine-map" rather than "affine-map-attribute".

[rriddle]

Address comments.

[rriddle]

In D72429#1811545, @ftynse wrote:

I support the reasoning for having delimiters around the actual map. I've always found the cases of immediate inline application confusing, especially for maps: (d0)[s0] -> (d0,s0)(%0)[%1].

I am also supportive of keeping the affine_ prefix in the name, since it clearly indicates the affine-ness of the attribute, e.g. the kind of sets/maps that can be expressed. We may eventually consider other similar attributes, like permutation-only maps, that could be clearly denoted now. I don't think repetition is a big problem, we are doing an IR after all, and we repeat types for all uses of a value, for example. If it proves to be annoying, we could consider having a special syntax for affine loops and branches that supports "inline" maps and sets without the affine_map token at all. We already have special syntax for affine loads and stores anyway, so it can be adapted and reused.

+1 This is exactly what I was thinking.

[merge_guards_bot]

Unit tests: pass. 61499 tests passed, 0 failed and 769 were skipped.

clang-tidy: pass.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[rriddle]

Rebase on recent changes.

[merge_guards_bot]

Unit tests: pass. 61656 tests passed, 0 failed and 778 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[bondhugula]

In D72429#1811545, @ftynse wrote:

I don't think repetition is a big problem, we are doing an IR after all, and we repeat types for all uses of a value, for example. If it proves to be

The type is printed for each use because one'd like to know about the value used by looking at the op locally and without having to search for its definition -- the latter would be a readability killer.

[bondhugula]

In D72429#1811324, @rriddle wrote:

In D72429#1811319, @bondhugula wrote:

How about just using a space after the keyword instead of angular brackets? The angular bracket right before/after the parenthesis looks a bit clumsy, and there is no specialization being implied on the

I don't see it as a specialization, it is a grouping mechanism that clearly delineate the scope of the attribute. We use this in many other places and doesn't imply that. I personally find the space to create a clumsier syntax as it makes it more difficult for me to tell what is actually part of the syntax. For example, there are many cases where we end up something like () : () () or (...) -> (...) (...). For me it is much easier to read

Hmm... I didn't see the delineation to be an issue because wherever the map typically appears, it either ends a line (in outlined definitions), has a trailing comma or '>', or often has a non-empty operand list following (%x, %y).

Is there some other delimiter grouping that would be less clumsy for you? {} perhaps? set{() : ()}()/map{() -> ()}()?

I think the angular brackets are better or as good as any other delimiter.

map/set. It's a character less with the space FWIW. And we could drop affine_ as well - those are the only maps and sets, and it prevents repetition at several places (like affine.apply affine_map, affine.if > affine_set ..., affine.for %i = affine_map...).

Happy to drop the 'affine_', but it should be noted that this only removed ambiguity for the affine dialect. There are other users of these attributes that don't have this problem.

Note that the ones I listed above are the most common users; those that appear as attributes on ops without a custom form are far fewer, and those aren't an issue as well when outlined due to the #map and #set prefix.

This is all really a bikeshed.

[rriddle]

Rebase.

[merge_guards_bot]

Unit tests: pass. 61744 tests passed, 0 failed and 780 were skipped.

clang-tidy: unknown.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[mehdi_amini]

In D72429#1813367, @bondhugula wrote:

The type is printed for each use because one'd like to know about the value used by looking at the op locally and without having to search for its definition -- the latter would be a readability killer.

I thought the type is printed for each use because they could appear before the def in a CFG?

Most programming languages are including the type for variable definitions only and not every use, yet they are readable, what is the fundamental difference you see in the IR?

mlir/docs/Dialects/Affine.md

 type. Dimensions are declared in parentheses and symbols are declared in square
 brackets.
 
 Examples:
 
 ```mlir
 // A 2d to 3d affine mapping.
 // d0/d1 are dimensions, s0 is a symbol
-#affine_map2to3 = (d0, d1)[s0] -> (d0, d1 + s0, d1 - s0)
+#affine_map2to3 = affine_map<(d0, d1)[s0] -> (d0, d1 + s0, d1 - s0)>
 ```
 
 Dimensional identifiers correspond to the dimensions of the underlying structure
 being represented (a map, set, or more concretely a loop nest or a tensor); for
 example, a three-dimensional loop nest has three dimensional identifiers. Symbol
 identifiers represent an unknown quantity that can be treated as constant for a
 region of interest.
 

 dim-and-symbol-use-list ::= dim-use-list symbol-use-list?
 ```
 
 SSA values bound to dimensions and symbols must always have 'index' type.
 
 Example:
 
 ```mlir
-#affine_map2to3 = (d0, d1)[s0] -> (d0, d1 + s0, d1 - s0)
+#affine_map2to3 = affine_map<(d0, d1)[s0] -> (d0, d1 + s0, d1 - s0)>
 // Binds %N to the s0 symbol in affine_map2to3.
 %x = alloc()[%N] : memref<40x50xf32, #affine_map2to3>
 ```
 
 ### Restrictions on Dimensions and Symbols
 
 The affine dialect imposes certain restrictions on dimension and symbolic
 identifiers to enable powerful analysis and transformation. A symbolic

 Affine mappings may be defined inline at the point of use, or may be hoisted to
 the top of the file and given a name with an affine map definition, and used by
 name.
 
 Examples:
 
 ```mlir
 // Affine map out-of-line definition and usage example.
-#affine_map42 = (d0, d1)[s0] -> (d0, d0 + d1 + s0 floordiv 2)
+#affine_map42 = affine_map<(d0, d1)[s0] -> (d0, d0 + d1 + s0 floordiv 2)>
 
 // Use an affine mapping definition in an alloc operation, binding the
 // SSA value %N to the symbol s0.
 %a = alloc()[%N] : memref<4x4xf32, #affine_map42>
 
 // Same thing with an inline affine mapping definition.
-%b = alloc()[%N] : memref<4x4xf32, (d0, d1)[s0] -> (d0, d0 + d1 + s0 floordiv 2)>
+%b = alloc()[%N] : memref<4x4xf32, affine_map<(d0, d1)[s0] -> (d0, d0 + d1 + s0 floordiv 2)>>
 ```
 
 ### Semi-affine maps
 
 Semi-affine maps are extensions of affine maps to allow multiplication,
 `floordiv`, `ceildiv`, and `mod` with respect to symbolic identifiers.
 Semi-affine maps are thus a strict superset of affine maps.
 

 syntax above are only allowed to contain identifiers from dims and symbols. A
 set with no constraints is a set that is unbounded along all of the set's
 dimensions.
 
 Example:
 
 ```mlir
 // A example two-dimensional integer set with two symbols.
-#set42 = (d0, d1)[s0, s1]
-   : (d0 >= 0, -d0 + s0 - 1 >= 0, d1 >= 0, -d1 + s1 - 1 >= 0)
+#set42 = affine_set<(d0, d1)[s0, s1]
+   : (d0 >= 0, -d0 + s0 - 1 >= 0, d1 >= 0, -d1 + s1 - 1 >= 0)>
 
 // Inside a Region
 affine.if #set42(%i, %j)[%M, %N] {
   ...
 }
 ```
 
 `d0` and `d1` correspond to dimensional identifiers of the set, while `s0` and
 `s1` are symbol identifiers.
 
 ## Operations
 
 #### 'affine.apply' operation
 
 Syntax:
 
 ```
-operation ::= ssa-id `=` `affine.apply` affine-map dim-and-symbol-use-list
+operation ::= ssa-id `=` `affine.apply` affine-map-attribute dim-and-symbol-use-list
 ```
 
 The `affine.apply` operation applies an
 [affine mapping](#affine-expressions) to a list of SSA values,
 yielding a single SSA value. The number of dimension and symbol arguments to
 affine.apply must be equal to the respective number of dimensional and symbolic
 inputs to the affine mapping; the `affine.apply` operation always returns one
 value. The input operands and result must all have 'index' type.
 
 Example:
 
 ```mlir
-#map10 = (d0, d1) -> (d0 floordiv 8 + d1 floordiv 128)
+#map10 = affine_map<(d0, d1) -> (d0 floordiv 8 + d1 floordiv 128)>
 ...
 %1 = affine.apply #map10 (%s, %t)
 
 // Inline example.
-%2 = affine.apply (i)[s0] -> (i+s0) (%42)[%n]
+%2 = affine.apply affine_map<(i)[s0] -> (i+s0)> (%42)[%n]
 ```
 
 #### 'affine.for' operation
 
 Syntax:
 
 ```
 operation   ::= `affine.for` ssa-id `=` lower-bound `to` upper-bound
                       (`step` integer-literal)? `{` op* `}`
 
-lower-bound ::= `max`? affine-map dim-and-symbol-use-list | shorthand-bound
-upper-bound ::= `min`? affine-map dim-and-symbol-use-list | shorthand-bound
+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
 ```
 
 The `affine.for` operation represents an affine loop nest. It has one region
 containing its body. This region must contain one block that terminates with
 [`affine.terminator`](#affineterminator-operation). *Note:* when `affine.for` is
 printed in custom format, the terminator is omitted. The block has one argument
 of [`index`](../LangRef.md#index-type) type that represents the induction

 syntaxes: the form that accepts a single 'ssa-id' (e.g. `%N`) is shorthand for
 applying that SSA value to a function that maps a single symbol to itself, e.g.,
 `()[s]->(s)()[%N]`. The integer literal form (e.g. `-42`) is shorthand for a
 nullary mapping function that returns the constant value (e.g. `()->(-42)()`).
 
 Example showing reverse iteration of the inner loop:
 
 ```mlir
-#map57 = (d0)[s0] -> (s0 - d0 - 1)
+#map57 = affine_map<(d0)[s0] -> (s0 - d0 - 1)>
 
 func @simple_example(%A: memref<?x?xf32>, %B: memref<?x?xf32>) {
   %N = dim %A, 0 : memref<?x?xf32>
   affine.for %i = 0 to %N step 1 {
     affine.for %j = 0 to %N {   // implicitly steps by 1
       %0 = affine.apply #map57(%j)[%N]
       %tmp = call @F1(%A, %i, %0) : (memref<?x?xf32>, index, index)->(f32)
       call @F2(%tmp, %B, %i, %0) : (f32, memref<?x?xf32>, index, index)->()
     }
   }
   return
 }
 ```
 
 #### 'affine.if' operation
 
 Syntax:
 
 ```
 operation    ::= `affine.if` if-op-cond `{` op* `}` (`else` `{` op* `}`)?
-if-op-cond ::= integer-set dim-and-symbol-use-list
+if-op-cond ::= integer-set-attr dim-and-symbol-use-list
 ```
 
 The `affine.if` operation restricts execution to a subset of the loop iteration
 space defined by an integer set (a conjunction of affine constraints). A single
 `affine.if` may end with an optional `else` clause.
 
 The condition of the `affine.if` is represented by an
 [integer set](#integer-sets) (a conjunction of affine constraints),
 and the SSA values bound to the dimensions and symbols in the integer set. The
 [same restrictions](#restrictions-on-dimensions-and-symbols) hold for these SSA
 values as for all bindings of SSA values to dimensions and symbols.
 
 The `affine.if` operation contains two regions for the "then" and "else"
 clauses. The latter may be empty (i.e. contain no blocks), meaning the absence
 of the else clause. When non-empty, both regions must contain exactly one block
 terminating with [`affine.terminator`](#affineterminator-operation). *Note:*
 when `affine.if` is printed in custom format, the terminator is omitted. These
 blocks must not have any arguments.
 
 Example:
 
 ```mlir
-#set = (d0, d1)[s0]: (d0 - 10 >= 0, s0 - d0 - 9 >= 0,
-                      d1 - 10 >= 0, s0 - d1 - 9 >= 0)
+#set = affine_set<(d0, d1)[s0]: (d0 - 10 >= 0, s0 - d0 - 9 >= 0,
+                                 d1 - 10 >= 0, s0 - d1 - 9 >= 0)>
 func @reduced_domain_example(%A, %X, %N) : (memref<10xi32>, i32, i32) {
   affine.for %i = 0 to %N {
      affine.for %j = 0 to %N {
        %0 = affine.apply #map42(%j)
        %tmp = call @S1(%X, %i, %0)
        affine.if #set(%i, %j)[%N] {
           %1 = affine.apply #map43(%i, %j)
           call @S2(%tmp, %A, %i, %1)

 
 ```
 
 #### 'affine.min' operation
 
 Syntax:
 
 ```
-operation ::= ssa-id `=` `affine.min` affine-map dim-and-symbol-use-list
+operation ::= ssa-id `=` `affine.min` affine-map-attribute dim-and-symbol-use-list
 ```
 
 The `affine.min` operation applies an
 [affine mapping](#affine-expressions) to a list of SSA values, and returns the
 minimum value of all result expressions. The number of dimension and symbol
 arguments to affine.min must be equal to the respective number of dimensional
 and symbolic inputs to the affine mapping; the `affine.min` operation always
 returns one value. The input operands and result must all have 'index' type.
 
 Example:
 
 ```mlir
 
-%0 = affine.min (d0)[s0] -> (1000, d0 + 512, s0) (%arg0)[%arg1]
+%0 = affine.min affine_map<(d0)[s0] -> (1000, d0 + 512, s0)> (%arg0)[%arg1]
 
 ```
 
 #### `affine.terminator` operation
 
 Syntax:
 
 ```

mlir/docs/Dialects/Standard.md

 For example, a `dma_start` operation that transfers 32 vector elements from a
 memref `%src` at location `[%i, %j]` to memref `%dst` at `[%k, %l]` would be
 specified as shown below.
 
 Example:
 
 ```mlir
 %size = constant 32 : index
-%tag = alloc() : memref<1 x i32, (d0) -> (d0), 4>
+%tag = alloc() : memref<1 x i32, affine_map<(d0) -> (d0)>, 4>
 %idx = constant 0 : index
 dma_start %src[%i, %j], %dst[%k, %l], %size, %tag[%idx] :
-     memref<40 x 8 x vector<16xf32>, (d0, d1) -> (d0, d1), 0>,
-     memref<2 x 4 x vector<16xf32>, (d0, d1) -> (d0, d1), 2>,
-     memref<1 x i32>, (d0) -> (d0), 4>
+     memref<40 x 8 x vector<16xf32>, affine_map<(d0, d1) -> (d0, d1)>, 0>,
+     memref<2 x 4 x vector<16xf32>, affine_map<(d0, d1) -> (d0, d1)>, 2>,
+     memref<1 x i32>, affine_map<(d0) -> (d0)>, 4>
 ```
 
 ### 'dma_wait' operation
 
 Syntax:
 
 ```
 operation ::= `dma_wait` ssa-use`[`ssa-use-list`]` `,` ssa-use `:` memref-type
 ```
 
 Blocks until the completion of a DMA operation associated with the tag element
 specified with a tag memref and its indices. The operands include the tag memref
 followed by its indices and the number of elements associated with the DMA being
 waited on. The indices of the tag memref have the same restrictions as
 load/store indices.
 
 Example:
 
 ```mlir
-dma_wait %tag[%idx], %size : memref<1 x i32, (d0) -> (d0), 4>
+dma_wait %tag[%idx], %size : memref<1 x i32, affine_map<(d0) -> (d0)>, 4>
 ```
 
 ### 'extract_element' operation
 
 Syntax:
 
 ```
 operation ::= ssa-id `=` `extract_element` ssa-use `[` ssa-use-list `]` `:` type

 [symbols](../LangRef.md#dimensions-and-symbols), results of a
 [`constant` operation](#constant-operation), or the result of an `affine.apply`
 operation that can in turn take as arguments all of the aforementioned SSA
 values or the recursively result of such an `affine.apply` operation.
 
 Example:
 
 ```mlir
-%1 = affine.apply (d0, d1) -> (3*d0) (%i, %j)
-%2 = affine.apply (d0, d1) -> (d1+1) (%i, %j)
+%1 = affine.apply affine_map<(d0, d1) -> (3*d0)> (%i, %j)
+%2 = affine.apply affine_map<(d0, d1) -> (d1+1)> (%i, %j)
 %12 = load %A[%1, %2] : memref<8x?xi32, #layout, memspace0>
 
 // Example of an indirect load (treated as non-affine)
-%3 = affine.apply (d0) -> (2*d0 + 1)(%12)
+%3 = affine.apply affine_map<(d0) -> (2*d0 + 1)>(%12)
 %13 = load %A[%3, %2] : memref<4x?xi32, #layout, memspace0>
 ```
 
 **Context:** The `load` and `store` operations are specifically crafted to fully
 resolve a reference to an element of a memref, and (in affine `affine.if` and
 `affine.for` operations) the compiler can follow use-def chains (e.g. through
 [`affine.apply`](Affine.md#affineapply-operation) operations) to precisely
 analyze references at compile-time using polyhedral techniques. This is possible

mlir/docs/LangRef.md

 The notionally dynamic value of a memref value includes the address of the
 buffer allocated, as well as the symbols referred to by the shape, layout map,
 and index maps.
 
 Examples of memref static type
 
 ```mlir
 // Identity index/layout map
-#identity = (d0, d1) -> (d0, d1)
+#identity = affine_map<(d0, d1) -> (d0, d1)>
 
 // Column major layout.
-#col_major = (d0, d1, d2) -> (d2, d1, d0)
+#col_major = affine_map<(d0, d1, d2) -> (d2, d1, d0)>
 
 // A 2-d tiled layout with tiles of size 128 x 256.
-#tiled_2d_128x256 = (d0, d1) -> (d0 div 128, d1 div 256, d0 mod 128, d1 mod 256)
+#tiled_2d_128x256 = affine_map<(d0, d1) -> (d0 div 128, d1 div 256, d0 mod 128, d1 mod 256)>
 
 // A tiled data layout with non-constant tile sizes.
-#tiled_dynamic = (d0, d1)[s0, s1] -> (d0 floordiv s0, d1 floordiv s1,
-                              d0 mod s0, d1 mod s1)
+#tiled_dynamic = affine_map<(d0, d1)[s0, s1] -> (d0 floordiv s0, d1 floordiv s1,
+                             d0 mod s0, d1 mod s1)>
 
 // A layout that yields a padding on two at either end of the minor dimension.
-#padded = (d0, d1) -> (d0, (d1 + 2) floordiv 2, (d1 + 2) mod 2)
+#padded = affine_map<(d0, d1) -> (d0, (d1 + 2) floordiv 2, (d1 + 2) mod 2)>
 
 
 // The dimension list "16x32" defines the following 2D index space:
 //
 //   { (i, j) : 0 <= i < 16, 0 <= j < 32 }
 //
 memref<16x32xf32, #identity, memspace0>
 

 // f32 elements.
 %T = alloc(%M, %N) [%B1, %B2] : memref<?x?xf32, #tiled_dynamic>
 
 // A memref that has a two-element padding at either end. The allocation size
 // will fit 16 * 68 float elements of data.
 %P = alloc() : memref<16x64xf32, #padded>
 
 // Affine map with symbol 's0' used as offset for the first dimension.
-#imapS = (d0, d1) [s0] -> (d0 + s0, d1)
+#imapS = affine_map<(d0, d1) [s0] -> (d0 + s0, d1)>
 // Allocate memref and bind the following symbols:
 // '%n' is bound to the dynamic second dimension of the memref type.
 // '%o' is bound to the symbol 's0' in the affine map of the memref type.
 %n = ...
 %o = ...
 %A = alloc (%n)[%o] : <16x?xf32, #imapS>
 ```
 

 an identifier that can be used in the place of the attribute that it defines.
 These aliases *must* be defined before their uses. Alias names may not contain a
 '.', since those names are reserved for
 [dialect attributes](#dialect-attribute-values).
 
 Example:
 
 ```mlir
-#map = (d0) -> (d0 + 10)
+#map = affine_map<(d0) -> (d0 + 10)>
 
 // Using the original attribute.
-%b = affine.apply (d0) -> (d0 + 10) (%a)
+%b = affine.apply affine_map<(d0) -> (d0 + 10)> (%a)
 
 // Using the attribute alias.
 %b = affine.apply #map(%a)
 ```
 
 ### Dialect Attribute Values
 
 Similarly to operations, dialects may define custom attribute values. The
standard-attribute ::=   affine-map-attribute
                        | unit-attribute
 ```
 
 #### AffineMap Attribute
 
 Syntax:
 
 ```
-affine-map-attribute ::= affine-map
+affine-map-attribute ::= `affine_map` `<` affine-map `>`
 ```
 
 An affine-map attribute is an attribute that represents a affine-map object.
 
 #### Array Attribute
 
 Syntax:
 

 the specified integer or index type. The default type for this attribute, if one
 is not specified, is a 64-bit integer.
 
 ##### Integer Set Attribute
 
 Syntax:
 
 ```
-integer-set-attribute ::= affine-map
+integer-set-attribute ::= `affine_set` `<` integer-set `>`
 ```
 
 An integer-set attribute is an attribute that represents an integer-set object.
 
 #### String Attribute
 
 Syntax:
 

mlir/include/mlir/IR/DialectImplementation.h

ParseResult parseAttribute(AttrType &result, Type type = {}) {
 
     // Check for the right kind of attribute.
     result = attr.dyn_cast<AttrType>();
     if (!result)
       return emitError(loc, "invalid kind of attribute specified");
     return success();
   }
 
+  /// Parse an affine map instance into 'map'.
+  virtual ParseResult parseAffineMap(AffineMap &map) = 0;
+
+  /// Parse an integer set instance into 'set'.
+  virtual ParseResult printIntegerSet(IntegerSet &set) = 0;
+
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a type.
   virtual ParseResult parseType(Type &result) = 0;
 
   /// Parse a type of a specific kind, e.g. a FunctionType.

mlir/include/mlir/IR/OpImplementation.h

public:
   virtual ParseResult
   parseOptionalAttrDict(SmallVectorImpl<NamedAttribute> &result) = 0;
 
   /// Parse a named dictionary into 'result' if the `attributes` keyword is
   /// present.
   virtual ParseResult
   parseOptionalAttrDictWithKeyword(SmallVectorImpl<NamedAttribute> &result) = 0;
 
+  /// Parse an affine map instance into 'map'.
+  virtual ParseResult parseAffineMap(AffineMap &map) = 0;
+
+  /// Parse an integer set instance into 'set'.
+  virtual ParseResult printIntegerSet(IntegerSet &set) = 0;
+
   //===--------------------------------------------------------------------===//
   // Identifier Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse an @-identifier and store it (without the '@' symbol) in a string
   /// attribute named 'attrName'.
   ParseResult parseSymbolName(StringAttr &result, StringRef attrName,
                               SmallVectorImpl<NamedAttribute> &attrs) {

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

static void print(OpAsmPrinter &p, TransposeOp op) {
   p.printOptionalAttrDict(op.getAttrs(),
                           {TransposeOp::getPermutationAttrName()});
   p << " : " << op.view().getType();
 }
 
 static ParseResult parseTransposeOp(OpAsmParser &parser,
                                     OperationState &result) {
   OpAsmParser::OperandType view;
-  AffineMapAttr permutation;
+  AffineMap permutation;
   MemRefType type;
-  return failure(parser.parseOperand(view) ||
-                 parser.parseAttribute(permutation,
-                                       TransposeOp::getPermutationAttrName(),
-                                       result.attributes) ||
-                 parser.parseOptionalAttrDict(result.attributes) ||
-                 parser.parseColonType(type) ||
-                 parser.resolveOperand(view, type, result.operands) ||
-                 parser.addTypeToList(type, result.types));
+  if (parser.parseOperand(view) || parser.parseAffineMap(permutation) ||
+      parser.addTypeToList(type, result.types))
+    return failure();
+
+  result.addAttribute(TransposeOp::getPermutationAttrName(),
+                      AffineMapAttr::get(permutation));
+  return success();
 }
 
 //===----------------------------------------------------------------------===//
 // YieldOp
 //===----------------------------------------------------------------------===//
 
 static void print(OpAsmPrinter &p, YieldOp op) {
   p << op.getOperationName();

mlir/lib/IR/AsmPrinter.cpp

void ModulePrinter::printAttribute(Attribute attr, bool mayElideType) {
   case StandardAttributes::Array:
     os << '[';
     interleaveComma(attr.cast<ArrayAttr>().getValue(), [&](Attribute attr) {
       printAttribute(attr, /*mayElideType=*/true);
     });
     os << ']';
     break;
   case StandardAttributes::AffineMap:
+    os << "affine_map<";
     attr.cast<AffineMapAttr>().getValue().print(os);
+    os << '>';
 
     // AffineMap always elides the type.
     return;
   case StandardAttributes::IntegerSet:
+    os << "affine_set<";
     attr.cast<IntegerSetAttr>().getValue().print(os);
-    break;
+    os << '>';
+
+    // IntegerSet always elides the type.
+    return;
   case StandardAttributes::Type:
     printType(attr.cast<TypeAttr>().getValue());
     break;
   case StandardAttributes::SymbolRef: {
     auto refAttr = attr.dyn_cast<SymbolRefAttr>();
     printSymbolReference(refAttr.getRootReference(), os);
     for (FlatSymbolRefAttr nestedRef : refAttr.getNestedReferences()) {
       os << "::";

mlir/lib/Parser/Parser.cpp

ParseResult parseOptionalTrailingLocation(Location &loc) {
     loc = directLoc;
     return success();
   }
 
   //===--------------------------------------------------------------------===//
   // Affine Parsing
   //===--------------------------------------------------------------------===//
 
+  /// Parse a reference to either an affine map, or an integer set.
   ParseResult parseAffineMapOrIntegerSetReference(AffineMap &map,
                                                   IntegerSet &set);
+  ParseResult parseAffineMapReference(AffineMap &map);
+  ParseResult parseIntegerSetReference(IntegerSet &set);
 
   /// Parse an AffineMap where the dim and symbol identifiers are SSA ids.
   ParseResult
   parseAffineMapOfSSAIds(AffineMap &map,
                          function_ref<ParseResult(bool)> parseElement);
 
 private:
   /// The Parser is subclassed and reinstantiated.  Do not add additional
public:
   //===--------------------------------------------------------------------===//
 
   /// Parse an arbitrary attribute and return it in result.
   ParseResult parseAttribute(Attribute &result, Type type) override {
     result = parser.parseAttribute(type);
     return success(static_cast<bool>(result));
   }
 
+  /// Parse an affine map instance into 'map'.
+  ParseResult parseAffineMap(AffineMap &map) override {
+    return parser.parseAffineMapReference(map);
+  }
+
+  /// Parse an integer set instance into 'set'.
+  ParseResult printIntegerSet(IntegerSet &set) override {
+    return parser.parseIntegerSetReference(set);
+  }
+
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   ParseResult parseType(Type &result) override {
     result = parser.parseType();
     return success(static_cast<bool>(result));
   }

 ///                      `:` (tensor-type | vector-type)
 ///                    | `opaque` `<` dialect-namespace  `,` hex-string-literal
 ///                      `>` `:` (tensor-type | vector-type)
 ///                    | extended-attribute
 ///
 Attribute Parser::parseAttribute(Type type) {
   switch (getToken().getKind()) {
   // Parse an AffineMap or IntegerSet attribute.
-  case Token::l_paren: {
-    // Try to parse an affine map or an integer set reference.
+  case Token::kw_affine_map: {
+    consumeToken(Token::kw_affine_map);
+
     AffineMap map;
-    IntegerSet set;
-    if (parseAffineMapOrIntegerSetReference(map, set))
-      return nullptr;
-    if (map)
-      return AffineMapAttr::get(map);
-    assert(set);
+    if (parseToken(Token::less, "expected '<' in affine map") ||
+        parseAffineMapReference(map) ||
+        parseToken(Token::greater, "expected '>' in affine map"))
+      return Attribute();
+  }
+  case Token::kw_affine_set: {
+    consumeToken(Token::kw_affine_set);
+
+    IntegerSet set;
+    if (parseToken(Token::less, "expected '<' in integer set") ||
+        parseIntegerSetReference(set) ||
+        parseToken(Token::greater, "expected '>' in integer set"))
+      return Attribute();
     return IntegerSetAttr::get(set);
   }
 
   // Parse an array attribute.
   case Token::l_square: {
     consumeToken(Token::l_square);
 
     SmallVector<Attribute, 4> elements;
IntegerSet AffineParser::parseIntegerSetConstraints(unsigned numDims,
   return IntegerSet::get(numDims, numSymbols, constraints, isEqs);
 }
 
 /// Parse an ambiguous reference to either and affine map or an integer set.
 ParseResult Parser::parseAffineMapOrIntegerSetReference(AffineMap &map,
                                                         IntegerSet &set) {
   return AffineParser(state).parseAffineMapOrIntegerSetInline(map, set);
 }
+ParseResult Parser::parseAffineMapReference(AffineMap &map) {
+  llvm::SMLoc curLoc = getToken().getLoc();
+  IntegerSet set;
+  if (parseAffineMapOrIntegerSetReference(map, set))
+    return failure();
+  if (set)
+    return emitError(curLoc, "expected AffineMap, but got IntegerSet");
+  return success();
+}
+ParseResult Parser::parseIntegerSetReference(IntegerSet &set) {
+  llvm::SMLoc curLoc = getToken().getLoc();
+  AffineMap map;
+  if (parseAffineMapOrIntegerSetReference(map, set))
+    return failure();
+  if (map)
+    return emitError(curLoc, "expected IntegerSet, but got AffineMap");
+  return success();
+}
 
 /// Parse an AffineMap of SSA ids. The callback 'parseElement' is used to
 /// parse SSA value uses encountered while parsing affine expressions.
 ParseResult
 Parser::parseAffineMapOfSSAIds(AffineMap &map,
                                function_ref<ParseResult(bool)> parseElement) {
   return AffineParser(state, /*allowParsingSSAIds=*/true, parseElement)
       .parseAffineMapOfSSAIds(map);
public:
   /// present.
   ParseResult parseOptionalAttrDictWithKeyword(
       SmallVectorImpl<NamedAttribute> &result) override {
     if (failed(parseOptionalKeyword("attributes")))
       return success();
     return parser.parseAttributeDict(result);
   }
 
+  /// Parse an affine map instance into 'map'.
+  ParseResult parseAffineMap(AffineMap &map) override {
+    return parser.parseAffineMapReference(map);
+  }
+
+  /// Parse an integer set instance into 'set'.
+  ParseResult printIntegerSet(IntegerSet &set) override {
+    return parser.parseIntegerSetReference(set);
+  }
+
   //===--------------------------------------------------------------------===//
   // Identifier Parsing
   //===--------------------------------------------------------------------===//
 
   /// Returns if the current token corresponds to a keyword.
   bool isCurrentTokenAKeyword() const {
     return parser.getToken().is(Token::bare_identifier) ||
            parser.getToken().isKeyword();

mlir/lib/Parser/TokenKinds.def

 TOK_OPERATOR(minus,              "-")
 TOK_OPERATOR(star,               "*")
 // TODO: More operator tokens
 
 // Keywords.  These turn "foo" into Token::kw_foo enums.
 
 // NOTE: Please key these alphabetized to make it easier to find something in
 // this list and to cater to OCD.
+TOK_KEYWORD(affine_map)
+TOK_KEYWORD(affine_set)
 TOK_KEYWORD(attributes)
 TOK_KEYWORD(bf16)
 TOK_KEYWORD(ceildiv)
 TOK_KEYWORD(complex)
 TOK_KEYWORD(dense)
 TOK_KEYWORD(f16)
 TOK_KEYWORD(f32)
 TOK_KEYWORD(f64)

mlir/test/AffineOps/canonicalize.mlir

 // RUN: mlir-opt %s -split-input-file -pass-pipeline='func(canonicalize)' | FileCheck %s
 
 // Affine maps for test case: compose_affine_maps_1dto2d_no_symbols
-// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0 - 1)
-// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0) -> (d0 + 1)
+// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 - 1)>
+// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
 
 // Affine maps for test case: compose_affine_maps_1dto2d_with_symbols
-// CHECK-DAG: [[MAP4:#map[0-9]+]] = (d0) -> (d0 - 4)
-// CHECK-DAG: [[MAP4b:#map[0-9]+]] = (d0) -> (d0 - 7)
-// CHECK-DAG: [[MAP7:#map[0-9]+]] = (d0) -> (d0 * 2 - 3)
-// CHECK-DAG: [[MAP7a:#map[0-9]+]] = (d0) -> (d0 * 2 + 1)
+// CHECK-DAG: [[MAP4:#map[0-9]+]] = affine_map<(d0) -> (d0 - 4)>
+// CHECK-DAG: [[MAP4b:#map[0-9]+]] = affine_map<(d0) -> (d0 - 7)>
+// CHECK-DAG: [[MAP7:#map[0-9]+]] = affine_map<(d0) -> (d0 * 2 - 3)>
+// CHECK-DAG: [[MAP7a:#map[0-9]+]] = affine_map<(d0) -> (d0 * 2 + 1)>
 
 // Affine map for test case: compose_affine_maps_d2_tile
-// CHECK-DAG: [[MAP8:#map[0-9]+]] = (d0, d1) -> (d1 + (d0 ceildiv 4) * 4 - (d1 floordiv 4) * 4)
-// CHECK-DAG: [[MAP8a:#map[0-9]+]] = (d0, d1) -> (d1 + (d0 ceildiv 8) * 8 - (d1 floordiv 8) * 8)
+// CHECK-DAG: [[MAP8:#map[0-9]+]] = affine_map<(d0, d1) -> (d1 + (d0 ceildiv 4) * 4 - (d1 floordiv 4) * 4)>
+// CHECK-DAG: [[MAP8a:#map[0-9]+]] = affine_map<(d0, d1) -> (d1 + (d0 ceildiv 8) * 8 - (d1 floordiv 8) * 8)>
 
 // Affine maps for test case: compose_affine_maps_dependent_loads
-// CHECK-DAG: [[MAP9:#map[0-9]+]] = (d0) -> (d0 + 3)
-// CHECK-DAG: [[MAP10:#map[0-9]+]] = (d0) -> (d0 * 3)
-// CHECK-DAG: [[MAP11:#map[0-9]+]] = (d0) -> ((d0 + 7) ceildiv 3)
-// CHECK-DAG: [[MAP12:#map[0-9]+]] = (d0) -> (d0 * 7 - 49)
+// CHECK-DAG: [[MAP9:#map[0-9]+]] = affine_map<(d0) -> (d0 + 3)>
+// CHECK-DAG: [[MAP10:#map[0-9]+]] = affine_map<(d0) -> (d0 * 3)>
+// CHECK-DAG: [[MAP11:#map[0-9]+]] = affine_map<(d0) -> ((d0 + 7) ceildiv 3)>
+// CHECK-DAG: [[MAP12:#map[0-9]+]] = affine_map<(d0) -> (d0 * 7 - 49)>
 
 // Affine maps for test case: compose_affine_maps_diamond_dependency
-// CHECK-DAG: [[MAP13A:#map[0-9]+]] = (d0) -> ((d0 + 6) ceildiv 8)
-// CHECK-DAG: [[MAP13B:#map[0-9]+]] = (d0) -> ((d0 * 4 - 4) floordiv 3)
+// CHECK-DAG: [[MAP13A:#map[0-9]+]] = affine_map<(d0) -> ((d0 + 6) ceildiv 8)>
+// CHECK-DAG: [[MAP13B:#map[0-9]+]] = affine_map<(d0) -> ((d0 * 4 - 4) floordiv 3)>
 
 // Affine maps for test case: partial_fold_map
-// CHECK-DAG: [[MAP15:#map[0-9]+]] = ()[s0] -> (s0 - 42)
+// CHECK-DAG: [[MAP15:#map[0-9]+]] = affine_map<()[s0] -> (s0 - 42)>
 
 // Affine maps for test cases: symbolic_composition_*
-// CHECK-DAG: [[map_symbolic_composition_a:#map[0-9]+]] = ()[s0] -> (s0 * 512)
-// CHECK-DAG: [[map_symbolic_composition_b:#map[0-9]+]] = ()[s0] -> (s0 * 4)
-// CHECK-DAG: [[map_symbolic_composition_c:#map[0-9]+]] = ()[s0, s1] -> (s0 * 3 + s1)
-// CHECK-DAG: [[map_symbolic_composition_d:#map[0-9]+]] = ()[s0, s1] -> (s1 * 3 + s0)
+// CHECK-DAG: [[map_symbolic_composition_a:#map[0-9]+]] = affine_map<()[s0] -> (s0 * 512)>
+// CHECK-DAG: [[map_symbolic_composition_b:#map[0-9]+]] = affine_map<()[s0] -> (s0 * 4)>
+// CHECK-DAG: [[map_symbolic_composition_c:#map[0-9]+]] = affine_map<()[s0, s1] -> (s0 * 3 + s1)>
+// CHECK-DAG: [[map_symbolic_composition_d:#map[0-9]+]] = affine_map<()[s0, s1] -> (s1 * 3 + s0)>
 
 // Affine maps for test cases: map_mix_dims_and_symbols_*
-// CHECK-DAG: [[map_mix_dims_and_symbols_b:#map[0-9]+]] = ()[s0, s1] -> (s1 + s0 * 42 + 6)
-// CHECK-DAG: [[map_mix_dims_and_symbols_c:#map[0-9]+]] = ()[s0, s1] -> (s1 * 4 + s0 * 168 - 4)
-// CHECK-DAG: [[map_mix_dims_and_symbols_d:#map[0-9]+]] = ()[s0, s1] -> ((s1 + s0 * 42 + 6) ceildiv 8)
-// CHECK-DAG: [[map_mix_dims_and_symbols_e:#map[0-9]+]] = ()[s0, s1] -> ((s1 * 4 + s0 * 168 - 4) floordiv 3)
+// CHECK-DAG: [[map_mix_dims_and_symbols_b:#map[0-9]+]] = affine_map<()[s0, s1] -> (s1 + s0 * 42 + 6)>
+// CHECK-DAG: [[map_mix_dims_and_symbols_c:#map[0-9]+]] = affine_map<()[s0, s1] -> (s1 * 4 + s0 * 168 - 4)>
+// CHECK-DAG: [[map_mix_dims_and_symbols_d:#map[0-9]+]] = affine_map<()[s0, s1] -> ((s1 + s0 * 42 + 6) ceildiv 8)>
+// CHECK-DAG: [[map_mix_dims_and_symbols_e:#map[0-9]+]] = affine_map<()[s0, s1] -> ((s1 * 4 + s0 * 168 - 4) floordiv 3)>
 
 // Affine maps for test case: symbolic_semi_affine
-// CHECK-DAG: [[symbolic_semi_affine:#map[0-9]+]] = (d0)[s0] -> (d0 floordiv (s0 + 1))
+// CHECK-DAG: [[symbolic_semi_affine:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 floordiv (s0 + 1))>
 
 // CHECK-LABEL: func @compose_affine_maps_1dto2d_no_symbols() {
 func @compose_affine_maps_1dto2d_no_symbols() {
   %0 = alloc() : memref<4x4xf32>
 
   affine.for %i0 = 0 to 15 {
     // Test load[%x, %x]
 
-    %x0 = affine.apply (d0) -> (d0 - 1) (%i0)
-    %x1_0 = affine.apply (d0, d1) -> (d0) (%x0, %x0)
-    %x1_1 = affine.apply (d0, d1) -> (d1) (%x0, %x0)
+    %x0 = affine.apply affine_map<(d0) -> (d0 - 1)> (%i0)
+    %x1_0 = affine.apply affine_map<(d0, d1) -> (d0)> (%x0, %x0)
+    %x1_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%x0, %x0)
 
     // CHECK: [[I0A:%[0-9]+]] = affine.apply [[MAP0]](%{{.*}})
     // CHECK-NEXT: load %0{{\[}}[[I0A]], [[I0A]]{{\]}}
     %v0 = load %0[%x1_0, %x1_1] : memref<4x4xf32>
 
     // Test load[%y, %y]
-    %y0 = affine.apply (d0) -> (d0 + 1) (%i0)
-    %y1_0 = affine.apply (d0, d1) -> (d0) (%y0, %y0)
-    %y1_1 = affine.apply (d0, d1) -> (d1) (%y0, %y0)
+    %y0 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0)
+    %y1_0 = affine.apply affine_map<(d0, d1) -> (d0)> (%y0, %y0)
+    %y1_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%y0, %y0)
 
     // CHECK-NEXT: [[I1A:%[0-9]+]] = affine.apply [[MAP1]](%{{.*}})
     // CHECK-NEXT: load %0{{\[}}[[I1A]], [[I1A]]{{\]}}
     %v1 = load %0[%y1_0, %y1_1] : memref<4x4xf32>
 
     // Test load[%x, %y]
-    %xy_0 = affine.apply (d0, d1) -> (d0) (%x0, %y0)
-    %xy_1 = affine.apply (d0, d1) -> (d1) (%x0, %y0)
+    %xy_0 = affine.apply affine_map<(d0, d1) -> (d0)> (%x0, %y0)
+    %xy_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%x0, %y0)
 
     // CHECK-NEXT: load %0{{\[}}[[I0A]], [[I1A]]{{\]}}
     %v2 = load %0[%xy_0, %xy_1] : memref<4x4xf32>
 
     // Test load[%y, %x]
-    %yx_0 = affine.apply (d0, d1) -> (d0) (%y0, %x0)
-    %yx_1 = affine.apply (d0, d1) -> (d1) (%y0, %x0)
+    %yx_0 = affine.apply affine_map<(d0, d1) -> (d0)> (%y0, %x0)
+    %yx_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%y0, %x0)
     // CHECK-NEXT: load %0{{\[}}[[I1A]], [[I0A]]{{\]}}
     %v3 = load %0[%yx_0, %yx_1] : memref<4x4xf32>
   }
   return
 }
 
 // CHECK-LABEL: func @compose_affine_maps_1dto2d_with_symbols() {
 func @compose_affine_maps_1dto2d_with_symbols() {
   %0 = alloc() : memref<4x4xf32>
 
   affine.for %i0 = 0 to 15 {
     // Test load[%x0, %x0] with symbol %c4
     %c4 = constant 4 : index
-    %x0 = affine.apply (d0)[s0] -> (d0 - s0) (%i0)[%c4]
+    %x0 = affine.apply affine_map<(d0)[s0] -> (d0 - s0)> (%i0)[%c4]
 
     // CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP4]](%{{.*}})
     // CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I0]]{{\]}}
     %v0 = load %0[%x0, %x0] : memref<4x4xf32>
 
     // Test load[%x0, %x1] with symbol %c4 captured by '%x0' map.
-    %x1 = affine.apply (d0) -> (d0 + 1) (%i0)
-    %y1 = affine.apply (d0, d1) -> (d0+d1) (%x0, %x1)
+    %x1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0)
+    %y1 = affine.apply affine_map<(d0, d1) -> (d0+d1)> (%x0, %x1)
     // CHECK-NEXT: [[I1:%[0-9]+]] = affine.apply [[MAP7]](%{{.*}})
     // CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I1]], [[I1]]{{\]}}
     %v1 = load %0[%y1, %y1] : memref<4x4xf32>
 
     // Test load[%x1, %x0] with symbol %c4 captured by '%x0' map.
-    %y2 = affine.apply (d0, d1) -> (d0 + d1) (%x1, %x0)
+    %y2 = affine.apply affine_map<(d0, d1) -> (d0 + d1)> (%x1, %x0)
     // CHECK-NEXT: [[I2:%[0-9]+]] = affine.apply [[MAP7]](%{{.*}})
     // CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I2]], [[I2]]{{\]}}
     %v2 = load %0[%y2, %y2] : memref<4x4xf32>
 
     // Test load[%x2, %x0] with symbol %c4 from '%x0' and %c5 from '%x2'
     %c5 = constant 5 : index
-    %x2 = affine.apply (d0)[s0] -> (d0 + s0) (%i0)[%c5]
-    %y3 = affine.apply (d0, d1) -> (d0 + d1) (%x2, %x0)
+    %x2 = affine.apply affine_map<(d0)[s0] -> (d0 + s0)> (%i0)[%c5]
+    %y3 = affine.apply affine_map<(d0, d1) -> (d0 + d1)> (%x2, %x0)
     // CHECK: [[I3:%[0-9]+]] = affine.apply [[MAP7a]](%{{.*}})
     // CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I3]], [[I3]]{{\]}}
     %v3 = load %0[%y3, %y3] : memref<4x4xf32>
   }
   return
 }
 
 // CHECK-LABEL: func @compose_affine_maps_2d_tile() {
 func @compose_affine_maps_2d_tile() {
   %0 = alloc() : memref<16x32xf32>
   %1 = alloc() : memref<16x32xf32>
 
   %c4 = constant 4 : index
   %c8 = constant 8 : index
 
   affine.for %i0 = 0 to 3 {
-    %x0 = affine.apply (d0)[s0] -> (d0 ceildiv s0) (%i0)[%c4]
+    %x0 = affine.apply affine_map<(d0)[s0] -> (d0 ceildiv s0)> (%i0)[%c4]
     affine.for %i1 = 0 to 3 {
-      %x1 = affine.apply (d0)[s0] -> (d0 ceildiv s0) (%i1)[%c8]
+      %x1 = affine.apply affine_map<(d0)[s0] -> (d0 ceildiv s0)> (%i1)[%c8]
       affine.for %i2 = 0 to 3 {
-        %x2 = affine.apply (d0)[s0] -> (d0 mod s0) (%i2)[%c4]
+        %x2 = affine.apply affine_map<(d0)[s0] -> (d0 mod s0)> (%i2)[%c4]
         affine.for %i3 = 0 to 3 {
-          %x3 = affine.apply (d0)[s0] -> (d0 mod s0) (%i3)[%c8]
+          %x3 = affine.apply affine_map<(d0)[s0] -> (d0 mod s0)> (%i3)[%c8]
 
-          %x40 = affine.apply (d0, d1, d2, d3)[s0, s1] ->
-            ((d0 * s0) + d2) (%x0, %x1, %x2, %x3)[%c4, %c8]
-          %x41 = affine.apply (d0, d1, d2, d3)[s0, s1] ->
-            ((d1 * s1) + d3) (%x0, %x1, %x2, %x3)[%c4, %c8]
+          %x40 = affine.apply affine_map<(d0, d1, d2, d3)[s0, s1] ->
+            ((d0 * s0) + d2)> (%x0, %x1, %x2, %x3)[%c4, %c8]
+          %x41 = affine.apply affine_map<(d0, d1, d2, d3)[s0, s1] ->
+            ((d1 * s1) + d3)> (%x0, %x1, %x2, %x3)[%c4, %c8]
           // CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP8]](%{{.*}}, %{{.*}})
           // CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP8a]](%{{.*}}, %{{.*}})
           // CHECK-NEXT: [[L0:%[0-9]+]] = load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
           %v0 = load %0[%x40, %x41] : memref<16x32xf32>
 
           // CHECK-NEXT: store [[L0]], %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
           store %v0, %1[%x40, %x41] : memref<16x32xf32>
         }
func @compose_affine_maps_dependent_loads() {
   %1 = alloc() : memref<16x32xf32>
 
   affine.for %i0 = 0 to 3 {
     affine.for %i1 = 0 to 3 {
       affine.for %i2 = 0 to 3 {
         %c3 = constant 3 : index
         %c7 = constant 7 : index
 
-        %x00 = affine.apply (d0, d1, d2)[s0, s1] -> (d0 + s0)
+        %x00 = affine.apply affine_map<(d0, d1, d2)[s0, s1] -> (d0 + s0)>
             (%i0, %i1, %i2)[%c3, %c7]
-        %x01 = affine.apply (d0, d1, d2)[s0, s1] -> (d1 - s1)
+        %x01 = affine.apply affine_map<(d0, d1, d2)[s0, s1] -> (d1 - s1)>
             (%i0, %i1, %i2)[%c3, %c7]
-        %x02 = affine.apply (d0, d1, d2)[s0, s1] -> (d2 * s0)
+        %x02 = affine.apply affine_map<(d0, d1, d2)[s0, s1] -> (d2 * s0)>
             (%i0, %i1, %i2)[%c3, %c7]
 
         // CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP9]](%{{.*}})
         // CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP4b]](%{{.*}})
         // CHECK: [[I2:%[0-9]+]] = affine.apply [[MAP10]](%{{.*}})
         // CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
         %v0 = load %0[%x00, %x01] : memref<16x32xf32>
 
         // CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I2]]{{\]}}
         %v1 = load %0[%x00, %x02] : memref<16x32xf32>
 
         // Swizzle %i0, %i1
         // CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I1]], [[I0]]{{\]}}
         %v2 = load %0[%x01, %x00] : memref<16x32xf32>
 
         // Swizzle %x00, %x01 and %c3, %c7
-        %x10 = affine.apply (d0, d1)[s0, s1] -> (d0 * s1)
+        %x10 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d0 * s1)>
            (%x01, %x00)[%c7, %c3]
-        %x11 = affine.apply (d0, d1)[s0, s1] -> (d1 ceildiv s0)
+        %x11 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d1 ceildiv s0)>
            (%x01, %x00)[%c7, %c3]
 
         // CHECK-NEXT: [[I2A:%[0-9]+]] = affine.apply [[MAP12]](%{{.*}})
         // CHECK-NEXT: [[I2B:%[0-9]+]] = affine.apply [[MAP11]](%{{.*}})
         // CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I2A]], [[I2B]]{{\]}}
         %v3 = load %0[%x10, %x11] : memref<16x32xf32>
       }
     }
   }
   return
 }
 
 // CHECK-LABEL: func @compose_affine_maps_diamond_dependency() {
 func @compose_affine_maps_diamond_dependency() {
   %0 = alloc() : memref<4x4xf32>
 
   affine.for %i0 = 0 to 15 {
-    %a = affine.apply (d0) -> (d0 - 1) (%i0)
-    %b = affine.apply (d0) -> (d0 + 7) (%a)
-    %c = affine.apply (d0) -> (d0 * 4) (%a)
-    %d0 = affine.apply (d0, d1) -> (d0 ceildiv 8) (%b, %c)
-    %d1 = affine.apply (d0, d1) -> (d1 floordiv 3) (%b, %c)
+    %a = affine.apply affine_map<(d0) -> (d0 - 1)> (%i0)
+    %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a)
+    %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a)
+    %d0 = affine.apply affine_map<(d0, d1) -> (d0 ceildiv 8)> (%b, %c)
+    %d1 = affine.apply affine_map<(d0, d1) -> (d1 floordiv 3)> (%b, %c)
     // CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP13A]](%{{.*}})
     // CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP13B]](%{{.*}})
     // CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
     %v = load %0[%d0, %d1] : memref<4x4xf32>
   }
 
   return
 }
 
 // CHECK-LABEL: func @arg_used_as_dim_and_symbol
 func @arg_used_as_dim_and_symbol(%arg0: memref<100x100xf32>, %arg1: index) {
   %c9 = constant 9 : index
   %1 = alloc() : memref<100x100xf32, 1>
   %2 = alloc() : memref<1xi32>
   affine.for %i0 = 0 to 100 {
     affine.for %i1 = 0 to 100 {
-      %3 = affine.apply (d0, d1)[s0, s1] -> (d1 + s0 + s1)
+      %3 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d1 + s0 + s1)>
         (%i0, %i1)[%arg1, %c9]
-      %4 = affine.apply (d0, d1, d3) -> (d3 - (d0 + d1))
+      %4 = affine.apply affine_map<(d0, d1, d3) -> (d3 - (d0 + d1))>
         (%arg1, %c9, %3)
       // CHECK: load %{{[0-9]+}}{{\[}}%{{.*}}, %{{.*}}{{\]}}
       %5 = load %1[%4, %arg1] : memref<100x100xf32, 1>
     }
   }
   return
 }
 
 // CHECK-LABEL: func @trivial_maps
 func @trivial_maps() {
   // CHECK-NOT: affine.apply
 
   %0 = alloc() : memref<10xf32>
   %c0 = constant 0 : index
   %cst = constant 0.000000e+00 : f32
   affine.for %i1 = 0 to 10 {
-    %1 = affine.apply ()[s0] -> (s0)()[%c0]
+    %1 = affine.apply affine_map<()[s0] -> (s0)>()[%c0]
     store %cst, %0[%1] : memref<10xf32>
     %2 = load %0[%c0] : memref<10xf32>
 
-    %3 = affine.apply ()[] -> (0)()[]
+    %3 = affine.apply affine_map<()[] -> (0)>()[]
     store %cst, %0[%3] : memref<10xf32>
     %4 = load %0[%c0] : memref<10xf32>
   }
   return
 }
 
 // CHECK-LABEL: func @partial_fold_map
 func @partial_fold_map(%arg1: index, %arg2: index) -> index {
   // TODO: Constant fold one index into affine.apply
   %c42 = constant 42 : index
-  %2 = affine.apply (d0, d1) -> (d0 - d1) (%arg1, %c42)
+  %2 = affine.apply affine_map<(d0, d1) -> (d0 - d1)> (%arg1, %c42)
   // CHECK: [[X:%[0-9]+]] = affine.apply [[MAP15]]()[%{{.*}}]
   return %2 : index
 }
 
 // CHECK-LABEL: func @symbolic_composition_a(%{{.*}}: index, %{{.*}}: index) -> index {
 func @symbolic_composition_a(%arg0: index, %arg1: index) -> index {
-  %0 = affine.apply (d0) -> (d0 * 4)(%arg0)
-  %1 = affine.apply ()[s0, s1] -> (8 * s0)()[%0, %arg0]
-  %2 = affine.apply ()[s0, s1] -> (16 * s1)()[%arg1, %1]
+  %0 = affine.apply affine_map<(d0) -> (d0 * 4)>(%arg0)
+  %1 = affine.apply affine_map<()[s0, s1] -> (8 * s0)>()[%0, %arg0]
+  %2 = affine.apply affine_map<()[s0, s1] -> (16 * s1)>()[%arg1, %1]
   // CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_a]]()[%{{.*}}]
   return %2 : index
 }
 
 // CHECK-LABEL: func @symbolic_composition_b(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index {
 func @symbolic_composition_b(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index {
-  %0 = affine.apply (d0) -> (d0)(%arg0)
-  %1 = affine.apply ()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)()[%0, %0, %0, %0]
+  %0 = affine.apply affine_map<(d0) -> (d0)>(%arg0)
+  %1 = affine.apply affine_map<()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>()[%0, %0, %0, %0]
   // CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_b]]()[%{{.*}}]
   return %1 : index
 }
 
 // CHECK-LABEL: func @symbolic_composition_c(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index {
 func @symbolic_composition_c(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index {
-  %0 = affine.apply (d0) -> (d0)(%arg0)
-  %1 = affine.apply (d0) -> (d0)(%arg1)
-  %2 = affine.apply ()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)()[%0, %0, %0, %1]
+  %0 = affine.apply affine_map<(d0) -> (d0)>(%arg0)
+  %1 = affine.apply affine_map<(d0) -> (d0)>(%arg1)
+  %2 = affine.apply affine_map<()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>()[%0, %0, %0, %1]
   // CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_c]]()[%{{.*}}, %{{.*}}]
   return %2 : index
 }
 
 // CHECK-LABEL: func @symbolic_composition_d(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index {
 func @symbolic_composition_d(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index {
-  %0 = affine.apply (d0) -> (d0)(%arg0)
-  %1 = affine.apply ()[s0] -> (s0)()[%arg1]
-  %2 = affine.apply ()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)()[%0, %0, %0, %1]
+  %0 = affine.apply affine_map<(d0) -> (d0)>(%arg0)
+  %1 = affine.apply affine_map<()[s0] -> (s0)>()[%arg1]
+  %2 = affine.apply affine_map<()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)>()[%0, %0, %0, %1]
   // CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_d]]()[%{{.*}}, %{{.*}}]
   return %2 : index
 }
 
 
 // CHECK-LABEL: func @mix_dims_and_symbols_b(%arg0: index, %arg1: index) -> index {
 func @mix_dims_and_symbols_b(%arg0: index, %arg1: index) -> index {
-  %a = affine.apply (d0)[s0] -> (d0 - 1 + 42 * s0) (%arg0)[%arg1]
-  %b = affine.apply (d0) -> (d0 + 7) (%a)
+  %a = affine.apply affine_map<(d0)[s0] -> (d0 - 1 + 42 * s0)> (%arg0)[%arg1]
+  %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a)
   // CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_b]]()[%{{.*}}, %{{.*}}]
 
   return %b : index
 }
 
 // CHECK-LABEL: func @mix_dims_and_symbols_c(%arg0: index, %arg1: index) -> index {
 func @mix_dims_and_symbols_c(%arg0: index, %arg1: index) -> index {
-  %a = affine.apply (d0)[s0] -> (d0 - 1 + 42 * s0) (%arg0)[%arg1]
-  %b = affine.apply (d0) -> (d0 + 7) (%a)
-  %c = affine.apply (d0) -> (d0 * 4) (%a)
+  %a = affine.apply affine_map<(d0)[s0] -> (d0 - 1 + 42 * s0)> (%arg0)[%arg1]
+  %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a)
+  %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a)
   // CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_c]]()[%{{.*}}, %{{.*}}]
   return %c : index
 }
 
 // CHECK-LABEL: func @mix_dims_and_symbols_d(%arg0: index, %arg1: index) -> index {
 func @mix_dims_and_symbols_d(%arg0: index, %arg1: index) -> index {
-  %a = affine.apply (d0)[s0] -> (d0 - 1 + 42 * s0) (%arg0)[%arg1]
-  %b = affine.apply (d0) -> (d0 + 7) (%a)
-  %c = affine.apply (d0) -> (d0 * 4) (%a)
-  %d = affine.apply ()[s0] -> (s0 ceildiv 8) ()[%b]
+  %a = affine.apply affine_map<(d0)[s0] -> (d0 - 1 + 42 * s0)> (%arg0)[%arg1]
+  %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a)
+  %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a)
+  %d = affine.apply affine_map<()[s0] -> (s0 ceildiv 8)> ()[%b]
   // CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_d]]()[%{{.*}}, %{{.*}}]
   return %d : index
 }
 
 // CHECK-LABEL: func @mix_dims_and_symbols_e(%arg0: index, %arg1: index) -> index {
 func @mix_dims_and_symbols_e(%arg0: index, %arg1: index) -> index {
-  %a = affine.apply (d0)[s0] -> (d0 - 1 + 42 * s0) (%arg0)[%arg1]
-  %b = affine.apply (d0) -> (d0 + 7) (%a)
-  %c = affine.apply (d0) -> (d0 * 4) (%a)
-  %d = affine.apply ()[s0] -> (s0 ceildiv 8) ()[%b]
-  %e = affine.apply (d0) -> (d0 floordiv 3) (%c)
+  %a = affine.apply affine_map<(d0)[s0] -> (d0 - 1 + 42 * s0)> (%arg0)[%arg1]
+  %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a)
+  %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a)
+  %d = affine.apply affine_map<()[s0] -> (s0 ceildiv 8)> ()[%b]
+  %e = affine.apply affine_map<(d0) -> (d0 floordiv 3)> (%c)
   // CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_e]]()[%{{.*}}, %{{.*}}]
   return %e : index
 }
 
 // CHECK-LABEL: func @mix_dims_and_symbols_f(%arg0: index, %arg1: index) -> index {
 func @mix_dims_and_symbols_f(%arg0: index, %arg1: index) -> index {
-  %a = affine.apply (d0)[s0] -> (d0 - 1 + 42 * s0) (%arg0)[%arg1]
-  %b = affine.apply (d0) -> (d0 + 7) (%a)
-  %c = affine.apply (d0) -> (d0 * 4) (%a)
-  %d = affine.apply ()[s0] -> (s0 ceildiv 8) ()[%b]
-  %e = affine.apply (d0) -> (d0 floordiv 3) (%c)
-  %f = affine.apply (d0, d1)[s0, s1] -> (d0 - s1 +  d1 - s0) (%d, %e)[%e, %d]
+  %a = affine.apply affine_map<(d0)[s0] -> (d0 - 1 + 42 * s0)> (%arg0)[%arg1]
+  %b = affine.apply affine_map<(d0) -> (d0 + 7)> (%a)
+  %c = affine.apply affine_map<(d0) -> (d0 * 4)> (%a)
+  %d = affine.apply affine_map<()[s0] -> (s0 ceildiv 8)> ()[%b]
+  %e = affine.apply affine_map<(d0) -> (d0 floordiv 3)> (%c)
+  %f = affine.apply affine_map<(d0, d1)[s0, s1] -> (d0 - s1 +  d1 - s0)> (%d, %e)[%e, %d]
   // CHECK: {{.*}} = constant 0 : index
 
   return %f : index
 }
 
 // CHECK-LABEL: func @mix_dims_and_symbols_g(%arg0: index, %arg1: index) -> (index, index, index) {
 func @mix_dims_and_symbols_g(%M: index, %N: index) -> (index, index, index) {
-  %K = affine.apply (d0) -> (4*d0) (%M)
-  %res1 = affine.apply ()[s0, s1] -> (4 * s0)()[%N, %K]
-  %res2 = affine.apply ()[s0, s1] -> (s1)()[%N, %K]
-  %res3 = affine.apply ()[s0, s1] -> (1024)()[%N, %K]
+  %K = affine.apply affine_map<(d0) -> (4*d0)> (%M)
+  %res1 = affine.apply affine_map<()[s0, s1] -> (4 * s0)>()[%N, %K]
+  %res2 = affine.apply affine_map<()[s0, s1] -> (s1)>()[%N, %K]
+  %res3 = affine.apply affine_map<()[s0, s1] -> (1024)>()[%N, %K]
   // CHECK-DAG: {{.*}} = constant 1024 : index
   // CHECK-DAG: {{.*}} = affine.apply [[map_symbolic_composition_b]]()[%{{.*}}]
   // CHECK-DAG: {{.*}} = affine.apply [[map_symbolic_composition_b]]()[%{{.*}}]
   return %res1, %res2, %res3 : index, index, index
 }
 
 // CHECK-LABEL: func @symbolic_semi_affine(%arg0: index, %arg1: index, %arg2: memref<?xf32>) {
 func @symbolic_semi_affine(%M: index, %N: index, %A: memref<?xf32>) {
   %f1 = constant 1.0 : f32
   affine.for %i0 = 1 to 100 {
-    %1 = affine.apply ()[s0] -> (s0 + 1) ()[%M]
-    %2 = affine.apply (d0)[s0] -> (d0 floordiv s0) (%i0)[%1]
+    %1 = affine.apply affine_map<()[s0] -> (s0 + 1)> ()[%M]
+    %2 = affine.apply affine_map<(d0)[s0] -> (d0 floordiv s0)> (%i0)[%1]
     // CHECK-DAG: {{.*}} = affine.apply [[symbolic_semi_affine]](%{{.*}})[%{{.*}}]
     store %f1, %A[%2] : memref<?xf32>
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = ()[s0] -> (0, s0)
-// CHECK: [[MAP1:#map[0-9]+]] = ()[s0] -> (100, s0)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<()[s0] -> (0, s0)>
+// CHECK: [[MAP1:#map[0-9]+]] = affine_map<()[s0] -> (100, s0)>
 
 // CHECK-LABEL:  func @constant_fold_bounds(%arg0: index) {
 func @constant_fold_bounds(%N : index) {
   // CHECK:      constant 3 : index
   // CHECK-NEXT: "foo"() : () -> index
   %c9 = constant 9 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
-  %c3 = affine.apply (d0, d1) -> (d0 + d1) (%c1, %c2)
+  %c3 = affine.apply affine_map<(d0, d1) -> (d0 + d1)> (%c1, %c2)
   %l = "foo"() : () -> index
 
   // CHECK:  affine.for %{{.*}} = 5 to 7 {
-  affine.for %i = max (d0, d1) -> (0, d0 + d1)(%c2, %c3) to min (d0, d1) -> (d0 - 2, 32*d1) (%c9, %c1) {
+  affine.for %i = max affine_map<(d0, d1) -> (0, d0 + d1)> (%c2, %c3) to min affine_map<(d0, d1) -> (d0 - 2, 32*d1)> (%c9, %c1) {
     "foo"(%i, %c3) : (index, index) -> ()
   }
 
   // Bound takes a non-constant argument but can still be folded.
   // CHECK:  affine.for %{{.*}} = 1 to 7 {
-  affine.for %j = max (d0) -> (0, 1)(%N) to min (d0, d1) -> (7, 9)(%N, %l) {
+  affine.for %j = max affine_map<(d0) -> (0, 1)> (%N) to min affine_map<(d0, d1) -> (7, 9)> (%N, %l) {
     "foo"(%j, %c3) : (index, index) -> ()
   }
 
   // None of the bounds can be folded.
   // CHECK: affine.for %{{.*}} = max [[MAP0]]()[%{{.*}}] to min [[MAP1]]()[%{{.*}}] {
-  affine.for %k = max ()[s0] -> (0, s0) ()[%l] to min ()[s0] -> (100, s0)()[%N] {
+  affine.for %k = max affine_map<()[s0] -> (0, s0)> ()[%l] to min affine_map<()[s0] -> (100, s0)> ()[%N] {
     "foo"(%k, %c3) : (index, index) -> ()
   }
   return
 }
 
 // -----
 
 // CHECK-LABEL:  func @fold_empty_loop() {
 func @fold_empty_loop() {
   // CHECK-NOT: affine.for
   affine.for %i = 0 to 10 {
   }
   return
 }
 // CHECK: return
 
 // -----
 
-// CHECK-DAG: [[SET:#set[0-9]+]] = (d0, d1)[s0] : (d0 >= 0, -d0 + 1022 >= 0, d1 >= 0, -d1 + s0 - 2 >= 0)
+// CHECK-DAG: [[SET:#set[0-9]+]] = affine_set<(d0, d1)[s0] : (d0 >= 0, -d0 + 1022 >= 0, d1 >= 0, -d1 + s0 - 2 >= 0)>
 
 // CHECK-LABEL: func @canonicalize_affine_if
 // CHECK-SAME: [[M:%.*]]: index,
 // CHECK-SAME: [[N:%.*]]: index)
 func @canonicalize_affine_if(%M : index, %N : index) {
   %c1022 = constant 1022 : index
   // Drop unused operand %M, propagate %c1022, and promote %N to symbolic.
   affine.for %i = 0 to 1024 {
     affine.for %j = 0 to %N {
       // CHECK: affine.if [[SET]](%{{.*}}, %{{.*}}){{\[}}[[N]]{{\]}}
-      affine.if (d0, d1, d2, d3)[s0] : (d1 >= 0, d0 - d1 >= 0, d2 >= 0, d3 - d2 - 2 >= 0) (%c1022, %i, %j, %N)[%M] {
+      affine.if affine_set<(d0, d1, d2, d3)[s0] : (d1 >= 0, d0 - d1 >= 0, d2 >= 0, d3 - d2 - 2 >= 0)> (%c1022, %i, %j, %N)[%M] {
         "foo"() : () -> ()
       }
       "bar"() : () -> ()
     }
   }
   return
 }
 
 // -----
 
-// CHECK-DAG: [[LBMAP:#map[0-9]+]] = ()[s0] -> (0, s0)
-// CHECK-DAG: [[UBMAP:#map[0-9]+]] = ()[s0] -> (1024, s0 + s0)
+// CHECK-DAG: [[LBMAP:#map[0-9]+]] = affine_map<()[s0] -> (0, s0)>
+// CHECK-DAG: [[UBMAP:#map[0-9]+]] = affine_map<()[s0] -> (1024, s0 + s0)>
 
 // CHECK-LABEL: func @canonicalize_bounds
 // CHECK-SAME: [[M:%.*]]: index,
 // CHECK-SAME: [[N:%.*]]: index)
 func @canonicalize_bounds(%M : index, %N : index) {
   %c0 = constant 0 : index
   %c1024 = constant 1024 : index
   // Drop unused operand %N, drop duplicate operand %M, propagate %c1024, and
   // promote %M to a symbolic one.
   // CHECK: affine.for %{{.*}} = 0 to min [[UBMAP]](){{\[}}[[M]]{{\]}}
-  affine.for %i = 0 to min (d0, d1, d2, d3) -> (d0, d1 + d2) (%c1024, %M, %M, %N) {
+  affine.for %i = 0 to min affine_map<(d0, d1, d2, d3) -> (d0, d1 + d2)> (%c1024, %M, %M, %N) {
     "foo"() : () -> ()
   }
   // Promote %M to symbolic position.
   // CHECK: affine.for %{{.*}} = 0 to #map{{[0-9]+}}(){{\[}}[[M]]{{\]}}
-  affine.for %i = 0 to (d0) -> (4 * d0) (%M) {
+  affine.for %i = 0 to affine_map<(d0) -> (4 * d0)> (%M) {
     "foo"() : () -> ()
   }
   // Lower bound canonicalize.
   // CHECK: affine.for %{{.*}} = max [[LBMAP]](){{\[}}[[N]]{{\]}} to [[M]]
-  affine.for %i = max (d0, d1) -> (d0, d1) (%c0, %N) to %M {
+  affine.for %i = max affine_map<(d0, d1) -> (d0, d1)> (%c0, %N) to %M {
     "foo"() : () -> ()
   }
   return
 }
 
 // -----
 
 // Compose maps into affine load and store ops.
 
-// CHECK-DAG: #map{{[0-9]+}} = (d0) -> (d0 + 1)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0) -> (d0 + 1)>
 
 // CHECK-LABEL: @compose_into_affine_load_store
 func @compose_into_affine_load_store(%A : memref<1024xf32>, %u : index) {
   %cf1 = constant 1.0 : f32
   // CHECK: affine.for %[[IV:.*]] = 0 to 1024
   affine.for %i = 0 to 1024 {
     // Make sure the unused operand (%u below) gets dropped as well.
-    %idx = affine.apply (d0, d1) -> (d0 + 1) (%i, %u)
+    %idx = affine.apply affine_map<(d0, d1) -> (d0 + 1)> (%i, %u)
     affine.load %A[%idx] : memref<1024xf32>
     affine.store %cf1, %A[%idx] : memref<1024xf32>
     // CHECK-NEXT: affine.load %{{.*}}[%[[IV]] + 1]
     // CHECK-NEXT: affine.store %cst, %{{.*}}[%[[IV]] + 1]
 
     // Map remains the same, but operand changes on composition.
-    %copy = affine.apply (d0) -> (d0) (%i)
+    %copy = affine.apply affine_map<(d0) -> (d0)> (%i)
     affine.load %A[%copy] : memref<1024xf32>
     // CHECK-NEXT: affine.load %{{.*}}[%[[IV]]]
   }
   return
 }
 
 // -----
 
 func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) {
   %c511 = constant 511 : index
   %c1 = constant 0 : index
-  %0 = affine.min (d0)[s0] -> (1000, d0 + 512, s0 + 1) (%c1)[%c511]
+  %0 = affine.min affine_map<(d0)[s0] -> (1000, d0 + 512, s0 + 1)> (%c1)[%c511]
   "op0"(%0) : (index) -> ()
   // CHECK:       %[[CST:.*]] = constant 512 : index
   // CHECK-NEXT:  "op0"(%[[CST]]) : (index) -> ()
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
 func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) {
   %c3 = constant 3 : index
   %c20 = constant 20 : index
-  %0 = affine.min (d0)[s0] -> (1000, d0 floordiv 4, (s0 mod 5) + 1) (%c20)[%c3]
+  %0 = affine.min affine_map<(d0)[s0] -> (1000, d0 floordiv 4, (s0 mod 5) + 1)> (%c20)[%c3]
   "op0"(%0) : (index) -> ()
   // CHECK:       %[[CST:.*]] = constant 4 : index
   // CHECK-NEXT:  "op0"(%[[CST]]) : (index) -> ()
   // CHECK-NEXT:  return
   return
 }

mlir/test/AffineOps/dma.mlir

 // RUN: mlir-opt %s -split-input-file | FileCheck %s
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d0, d1)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
 
 // Test with loop IVs.
 func @test0(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
-  %1 = alloc() : memref<100x100xf32, (d0, d1) -> (d0, d1), 2>
+  %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
   %2 = alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0, %i1], %1[%i0, %i1], %2[%c0], %c64
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d0, d1)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
 
 // Test with loop IVs and optional stride arguments.
 func @test1(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
-  %1 = alloc() : memref<100x100xf32, (d0, d1) -> (d0, d1), 2>
+  %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
   %2 = alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   %c128 = constant 128 : index
   %c256 = constant 256 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0, %i1], %1[%i0, %i1], %2[%c0], %c64, %c128, %c256
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1, d2) -> (d0, d1 + d2 + 5)
-// CHECK: [[MAP1:#map[0-9]+]] = (d0, d1, d2) -> (d0 + d1, d2)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0, d1 + d2 + 5)>
+// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 + d1, d2)>
 
 // Test with loop IVs and symbols (without symbol keyword).
 func @test2(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
-  %1 = alloc() : memref<100x100xf32, (d0, d1) -> (d0, d1), 2>
+  %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
   %2 = alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0 + %arg0, %i1], %1[%i0, %i1 + %arg1 + 5],
                        %2[%c0], %c64
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}} + %{{.*}} + 5], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1)[s0] -> (d0, d1 + s0 + 7)
-// CHECK: [[MAP1:#map[0-9]+]] = (d0, d1)[s0] -> (d0 + s0, d1)
-// CHECK: [[MAP1:#map[0-9]+]] = (d0, d1) -> (d0 + d1 + 11)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0, d1 + s0 + 7)>
+// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>
+// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1 + 11)>
 
 // Test with loop IVs and symbols (with symbol keyword).
 func @test3(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
-  %1 = alloc() : memref<100x100xf32, (d0, d1) -> (d0, d1), 2>
+  %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
   %2 = alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0 + symbol(%arg0), %i1],
                        %1[%i0, %i1 + symbol(%arg1) + 7],
                        %2[%i0 + %i1 + 11], %c64
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}} + symbol(%{{.*}}) + 7], %{{.*}}[%{{.*}} + %{{.*}} + 11], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1)[s0] -> (d0, (d1 + s0) mod 9 + 7)
-// CHECK: [[MAP1:#map[0-9]+]] = (d0, d1)[s0] -> ((d0 + s0) floordiv 3, d1)
-// CHECK: [[MAP2:#map[0-9]+]] = (d0, d1) -> (d0 + d1 + 11)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0, (d1 + s0) mod 9 + 7)>
+// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> ((d0 + s0) floordiv 3, d1)>
+// CHECK: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1 + 11)>
 
 // Test with loop IVs, symbols and constants in nested affine expressions.
 func @test4(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   %1 = alloc() : memref<100x100xf32, 2>
   %2 = alloc() : memref<1xi32>
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {

mlir/test/AffineOps/inlining.mlir

 // RUN: mlir-opt %s -inline -mlir-disable-inline-simplify | FileCheck %s
 
 // Basic test that functions within affine operations are inlined.
 func @func_with_affine_ops(%N: index) {
   %c = constant 200 : index
   affine.for %i = 1 to 10 {
-    affine.if (i)[N] : (i - 2 >= 0, 4 - i >= 0)(%i)[%c]  {
-      %w = affine.apply (d0,d1)[s0] -> (d0+d1+s0) (%i, %i) [%N]
+    affine.if affine_set<(i)[N] : (i - 2 >= 0, 4 - i >= 0)>(%i)[%c]  {
+      %w = affine.apply affine_map<(d0,d1)[s0] -> (d0+d1+s0)> (%i, %i) [%N]
     }
   }
   return
 }
 
 // CHECK-LABEL: func @inline_with_affine_ops
 func @inline_with_affine_ops() {
   %c = constant 1 : index

mlir/test/AffineOps/invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // -----
 
 func @affine_apply_operand_non_index(%arg0 : i32) {
   // Custom parser automatically assigns all arguments the `index` so we must
   // use the generic syntax here to exercise the verifier.
   // expected-error@+1 {{operands must be of type 'index'}}
-  %0 = "affine.apply"(%arg0) {map = (d0) -> (d0)} : (i32) -> (index)
+  %0 = "affine.apply"(%arg0) {map = affine_map<(d0) -> (d0)>} : (i32) -> (index)
   return
 }
 
 // -----
 
 func @affine_apply_resul_non_index(%arg0 : index) {
   // Custom parser automatically assigns `index` as the result type so we must
   // use the generic syntax here to exercise the verifier.
   // expected-error@+1 {{result must be of type 'index'}}
-  %0 = "affine.apply"(%arg0) {map = (d0) -> (d0)} : (index) -> (i32)
+  %0 = "affine.apply"(%arg0) {map = affine_map<(d0) -> (d0)>} : (index) -> (i32)
   return
 }
 
 // -----
 
-#map = (d0)[s0] -> (d0 + s0)
+#map = affine_map<(d0)[s0] -> (d0 + s0)>
 
 func @affine_for_lower_bound_invalid_dim(%arg : index) {
   affine.for %n0 = 0 to 7 {
     %dim = addi %arg, %arg : index
 
     // expected-error@+1 {{operand cannot be used as a dimension id}}
     affine.for %n1 = 0 to #map(%dim)[%arg] {
     }
   }
   return
 }
 
 // -----
 
-#map = (d0)[s0] -> (d0 + s0)
+#map = affine_map<(d0)[s0] -> (d0 + s0)>
 
 func @affine_for_upper_bound_invalid_dim(%arg : index) {
   affine.for %n0 = 0 to 7 {
     %dim = addi %arg, %arg : index
 
     // expected-error@+1 {{operand cannot be used as a dimension id}}
     affine.for %n1 = #map(%dim)[%arg] to 7 {
     }
func @affine_load_invalid_dim(%M : memref<10xi32>) {
   ^bb1:
     br ^bb1
   }) : () -> ()
   return
 }
 
 // -----
 
-#map0 = (d0)[s0] -> (d0 + s0)
+#map0 = affine_map<(d0)[s0] -> (d0 + s0)>
 
 func @affine_for_lower_bound_invalid_sym() {
   affine.for %i0 = 0 to 7 {
     // expected-error@+1 {{operand cannot be used as a symbol}}
     affine.for %n0 = #map0(%i0)[%i0] to 7 {
     }
   }
   return
 }
 
 // -----
 
-#map0 = (d0)[s0] -> (d0 + s0)
+#map0 = affine_map<(d0)[s0] -> (d0 + s0)>
 
 func @affine_for_upper_bound_invalid_sym() {
   affine.for %i0 = 0 to 7 {
     // expected-error@+1 {{operand cannot be used as a symbol}}
     affine.for %n0 = 0 to #map0(%i0)[%i0] {
     }
   }
   return
 }
 
 // -----
 
-#set0 = (i)[N] : (i >= 0, N - i >= 0)
+#set0 = affine_set<(i)[N] : (i >= 0, N - i >= 0)>
 
 func @affine_if_invalid_dim(%arg : index) {
   affine.for %n0 = 0 to 7 {
     %dim = addi %arg, %arg : index
 
     // expected-error@+1 {{operand cannot be used as a dimension id}}
     affine.if #set0(%dim)[%n0] {}
   }
   return
 }
 
 // -----
 
-#set0 = (i)[N] : (i >= 0, N - i >= 0)
+#set0 = affine_set<(i)[N] : (i >= 0, N - i >= 0)>
 
 func @affine_if_invalid_sym() {
   affine.for %i0 = 0 to 7 {
     // expected-error@+1 {{operand cannot be used as a symbol}}
     affine.if #set0(%i0)[%i0] {}
   }
   return
 }
 
 // -----
 
-#set0 = (i)[N] : (i >= 0, N - i >= 0)
+#set0 = affine_set<(i)[N] : (i >= 0, N - i >= 0)>
 
 func @affine_if_invalid_dimop_dim(%arg0: index, %arg1: index, %arg2: index, %arg3: index) {
   affine.for %n0 = 0 to 7 {
     %0 = alloc(%arg0, %arg1, %arg2, %arg3) : memref<?x?x?x?xf32>
     %dim = dim %0, 0 : memref<?x?x?x?xf32>
 
     // expected-error@+1 {{operand cannot be used as a dimension id}}
     affine.if #set0(%dim)[%n0] {}
func @affine_store_missing_l_square(%C: memref<4096x4096xf32>) {
   return
 }
 
 // -----
 
 // CHECK-LABEL: @affine_min
 func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) {
   // expected-error@+1 {{operand count and affine map dimension and symbol count must match}}
-  %0 = affine.min (d0) -> (d0) (%arg0, %arg1)
+  %0 = affine.min affine_map<(d0) -> (d0)> (%arg0, %arg1)
 
   return
 }
 
 // -----
 
 // CHECK-LABEL: @affine_min
 func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) {
   // expected-error@+1 {{operand count and affine map dimension and symbol count must match}}
-  %0 = affine.min ()[s0] -> (s0) (%arg0, %arg1)
+  %0 = affine.min affine_map<()[s0] -> (s0)> (%arg0, %arg1)
 
   return
 }
 
 // -----
 
 // CHECK-LABEL: @affine_min
 func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) {
   // expected-error@+1 {{operand count and affine map dimension and symbol count must match}}
-  %0 = affine.min (d0) -> (d0) ()
+  %0 = affine.min affine_map<(d0) -> (d0)> ()
 
   return
 }

mlir/test/AffineOps/load-store-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 func @load_too_many_subscripts(%arg0: memref<?x?xf32>, %arg1: index, %arg2: index, %arg3: index) {
   // expected-error@+1 {{expects the number of subscripts to be equal to memref rank}}
   "affine.load"(%arg0, %arg1, %arg2, %arg3) : (memref<?x?xf32>, index, index, index) -> f32
 }
 
 // -----
 
 func @load_too_many_subscripts_map(%arg0: memref<?x?xf32>, %arg1: index, %arg2: index, %arg3: index) {
   // expected-error@+1 {{op expects as many subscripts as affine map inputs}}
   "affine.load"(%arg0, %arg1, %arg2, %arg3)
-    {map = (i, j) -> (i, j) } : (memref<?x?xf32>, index, index, index) -> f32
+    {map = affine_map<(i, j) -> (i, j)> } : (memref<?x?xf32>, index, index, index) -> f32
 }
 
 // -----
 
 func @load_too_few_subscripts(%arg0: memref<?x?xf32>, %arg1: index) {
   // expected-error@+1 {{expects the number of subscripts to be equal to memref rank}}
   "affine.load"(%arg0, %arg1) : (memref<?x?xf32>, index) -> f32
 }
 
 // -----
 
 func @load_too_few_subscripts_map(%arg0: memref<?x?xf32>, %arg1: index) {
   // expected-error@+1 {{op expects as many subscripts as affine map inputs}}
   "affine.load"(%arg0, %arg1)
-    {map = (i, j) -> (i, j) } : (memref<?x?xf32>, index) -> f32
+    {map = affine_map<(i, j) -> (i, j)> } : (memref<?x?xf32>, index) -> f32
 }
 
 // -----
 
 func @store_too_many_subscripts(%arg0: memref<?x?xf32>, %arg1: index, %arg2: index,
                                 %arg3: index, %val: f32) {
   // expected-error@+1 {{expects the number of subscripts to be equal to memref rank}}
   "affine.store"(%val, %arg0, %arg1, %arg2, %arg3) : (f32, memref<?x?xf32>, index, index, index) -> ()
 }
 
 // -----
 
 func @store_too_many_subscripts_map(%arg0: memref<?x?xf32>, %arg1: index, %arg2: index,
                                     %arg3: index, %val: f32) {
   // expected-error@+1 {{op expects as many subscripts as affine map inputs}}
   "affine.store"(%val, %arg0, %arg1, %arg2, %arg3)
-    {map = (i, j) -> (i, j) } : (f32, memref<?x?xf32>, index, index, index) -> ()
+    {map = affine_map<(i, j) -> (i, j)> } : (f32, memref<?x?xf32>, index, index, index) -> ()
 }
 
 // -----
 
 func @store_too_few_subscripts(%arg0: memref<?x?xf32>, %arg1: index, %val: f32) {
   // expected-error@+1 {{expects the number of subscripts to be equal to memref rank}}
   "affine.store"(%val, %arg0, %arg1) : (f32, memref<?x?xf32>, index) -> ()
 }
 
 // -----
 
 func @store_too_few_subscripts_map(%arg0: memref<?x?xf32>, %arg1: index, %val: f32) {
   // expected-error@+1 {{op expects as many subscripts as affine map inputs}}
   "affine.store"(%val, %arg0, %arg1)
-    {map = (i, j) -> (i, j) } : (f32, memref<?x?xf32>, index) -> ()
+    {map = affine_map<(i, j) -> (i, j)> } : (f32, memref<?x?xf32>, index) -> ()
 }
 
 // -----
 
 func @load_non_affine_index(%arg0 : index) {
   %0 = alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     %1 = muli %i0, %arg0 : index

mlir/test/AffineOps/load-store.mlir

 // RUN: mlir-opt %s -split-input-file | FileCheck %s
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d0, d1)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
 
 // Test with just loop IVs.
 func @test0(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0, %i1] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d0 + 3, d1 + 7)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3, d1 + 7)>
 
 // Test with loop IVs and constants.
 func @test1(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
       affine.store %1, %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1, d2, d3) -> (d0 + d1, d2 + d3)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2, d3) -> (d0 + d1, d2 + d3)>
 
 // Test with loop IVs and function args without 'symbol' keyword (should
 // be parsed as dim identifiers).
 func @test2(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
       affine.store %1, %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1)[s0, s1] -> (d0 + s0, d1 + s1)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d0 + s0, d1 + s1)>
 
 // Test with loop IVs and function args with 'symbol' keyword (should
 // be parsed as symbol identifiers).
 func @test3(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + symbol(%arg0), %i1 + symbol(%arg1)]
         : memref<100x100xf32>
       affine.store %1, %0[%i0 + symbol(%arg0), %i1 + symbol(%arg1)]
         : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + symbol(%{{.*}})] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + symbol(%{{.*}})] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1)[s0, s1] -> ((d0 + s0) floordiv 3 + 11, (d1 + s1) mod 4 + 7)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> ((d0 + s0) floordiv 3 + 11, (d1 + s1) mod 4 + 7)>
 
 // Test with loop IVs, symbols and constants in nested affine expressions.
 func @test4(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[(%i0 + symbol(%arg0)) floordiv 3 + 11,
                           (%i1 + symbol(%arg1)) mod 4 + 7] : memref<100x100xf32>
       affine.store %1, %0[(%i0 + symbol(%arg0)) floordiv 3 + 11,
                           (%i1 + symbol(%arg1)) mod 4 + 7] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[(%{{.*}} + symbol(%{{.*}})) floordiv 3 + 11, (%{{.*}} + symbol(%{{.*}})) mod 4 + 7] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[(%{{.*}} + symbol(%{{.*}})) floordiv 3 + 11, (%{{.*}} + symbol(%{{.*}})) mod 4 + 7] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1, d2) -> (d0, d1, d2)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
 
 // Test with swizzled loop IVs.
 func @test5(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<10x10x10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
         %1 = affine.load %0[%i2, %i0, %i1] : memref<10x10x10xf32>
         affine.store %1, %0[%i2, %i0, %i1] : memref<10x10x10xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<10x10x10xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<10x10x10xf32>
       }
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1, d2, d3, d4) -> (d0 + d1, d2 + d3, d3 + d1 + d4)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2, d3, d4) -> (d0 + d1, d2 + d3, d3 + d1 + d4)>
 
 // Test with swizzled loop IVs, duplicate args, and function args used as dims.
 // Dim identifiers are assigned in parse order:
 // d0 = %i2, d1 = %arg0, d2 = %i0, d3 = %i1, d4 = %arg1
 func @test6(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<10x10x10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
         %1 = affine.load %0[%i2 + %arg0, %i0 + %i1, %i1 + %arg0 + %arg1]
           : memref<10x10x10xf32>
         affine.store %1, %0[%i2 + %arg0, %i0 + %i1, %i1 + %arg0 + %arg1]
           : memref<10x10x10xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}, %{{.*}} + %{{.*}} + %{{.*}}] : memref<10x10x10xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}, %{{.*}} + %{{.*}} + %{{.*}}] : memref<10x10x10xf32>
       }
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1, d2)[s0, s1] -> (d0 + s0, d1 + d2, d2 + s0 + s1)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1] -> (d0 + s0, d1 + d2, d2 + s0 + s1)>
 
 // Test with swizzled loop IVs, duplicate args, and function args used as syms.
 // Dim and symbol identifiers are assigned in parse order:
 // d0 = %i2, d1 = %i0, d2 = %i1
 // s0 = %arg0, s1 = %arg1
 func @test6(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<10x10x10xf32>
   affine.for %i0 = 0 to 10 {
// CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + %{{.*}}, %{{.*}} + symbol(%{{.*}}) + symbol(%{{.*}})] : memref<10x10x10xf32>
       }
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0) -> (d0 + 1)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
 
 // Test with operands without special SSA name.
 func @test7() {
   %0 = alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
-    %1 = affine.apply (d1) -> (d1 + 1)(%i0)
+    %1 = affine.apply affine_map<(d1) -> (d1 + 1)>(%i0)
     %2 = affine.load %0[%1] : memref<10xf32>
     affine.store %2, %0[%1] : memref<10xf32>
 // CHECK: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
   }
   return
 }
 
 // -----
 
 // Test with zero-dimensional operands.
 func @zero_dim(%arg0 : memref<i32>, %arg1 : memref<i32>) {
   %0 = affine.load %arg0[] : memref<i32>
   affine.store %0, %arg1[] : memref<i32>
   // CHECK: affine.load %{{.*}}[] : memref<i32>
   // CHECK: affine.store %{{.*}}, %{{.*}}[] : memref<i32>
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d0 + 3, d1 + 7)
-// CHECK: [[MAP1:#map[0-9]+]] = (d0, d1) -> (d0 + 3, d1 + 11)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3, d1 + 7)>
+// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3, d1 + 11)>
 
 // Test with loop IVs and constants.
 func @test_prefetch(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
       affine.prefetch %0[%i0 + 3, %i1 + 11], write, locality<0>, data : memref<100x100xf32>
       // CHECK: affine.prefetch %{{.*}}[%{{.*}} + 3, %{{.*}} + 11], write, locality<0>, data : memref<100x100xf32>
       affine.prefetch %0[%i0, %i1 + 1], read, locality<3>, instr : memref<100x100xf32>
       // CHECK: affine.prefetch %{{.*}}[%{{.*}}, %{{.*}} + 1], read, locality<3>, instr : memref<100x100xf32>
     }
   }
   return
 }

mlir/test/AffineOps/memref-stride-calculation.mlir

 // CHECK: MemRefType offset: 0 strides: ?, 5, 1
   %4 = alloc(%0) : memref<?x4x5xf32>
 // CHECK: MemRefType offset: 0 strides: 20, 5, 1
   %5 = alloc(%0, %0) : memref<?x4x?xf32>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
   %6 = alloc(%0, %0, %0) : memref<?x?x?xf32>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
 
-  %11 = alloc() : memref<3x4x5xf32, (i, j, k)->(i, j, k)>
+  %11 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: 20, 5, 1
   %b11 = alloc() : memref<3x4x5xf32, offset: 0, strides: [20, 5, 1]>
 // CHECK: MemRefType offset: 0 strides: 20, 5, 1
-  %12 = alloc(%0) : memref<3x4x?xf32, (i, j, k)->(i, j, k)>
+  %12 = alloc(%0) : memref<3x4x?xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
-  %13 = alloc(%0) : memref<3x?x5xf32, (i, j, k)->(i, j, k)>
+  %13 = alloc(%0) : memref<3x?x5xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: ?, 5, 1
-  %14 = alloc(%0) : memref<?x4x5xf32, (i, j, k)->(i, j, k)>
+  %14 = alloc(%0) : memref<?x4x5xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: 20, 5, 1
-  %15 = alloc(%0, %0) : memref<?x4x?xf32, (i, j, k)->(i, j, k)>
+  %15 = alloc(%0, %0) : memref<?x4x?xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
-  %16 = alloc(%0, %0, %0) : memref<?x?x?xf32, (i, j, k)->(i, j, k)>
+  %16 = alloc(%0, %0, %0) : memref<?x?x?xf32, affine_map<(i, j, k)->(i, j, k)>>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
 
-  %21 = alloc()[%0] : memref<3x4x5xf32, (i, j, k)[M]->(32 * i + 16 * j + M * k + 1)>
+  %21 = alloc()[%0] : memref<3x4x5xf32, affine_map<(i, j, k)[M]->(32 * i + 16 * j + M * k + 1)>>
 // CHECK: MemRefType offset: 1 strides: 32, 16, ?
-  %22 = alloc()[%0] : memref<3x4x5xf32, (i, j, k)[M]->(32 * i + M * j + 16 * k + 3)>
+  %22 = alloc()[%0] : memref<3x4x5xf32, affine_map<(i, j, k)[M]->(32 * i + M * j + 16 * k + 3)>>
 // CHECK: MemRefType offset: 3 strides: 32, ?, 16
   %b22 = alloc(%0)[%0, %0] : memref<3x4x?xf32, offset: 0, strides: [?, ?, 1]>
 // CHECK: MemRefType offset: 0 strides: ?, ?, 1
-  %23 = alloc(%0)[%0] : memref<3x?x5xf32, (i, j, k)[M]->(M * i + 32 * j + 16 * k + 7)>
+  %23 = alloc(%0)[%0] : memref<3x?x5xf32, affine_map<(i, j, k)[M]->(M * i + 32 * j + 16 * k + 7)>>
 // CHECK: MemRefType offset: 7 strides: ?, 32, 16
   %b23 = alloc(%0)[%0] : memref<3x?x5xf32, offset: 0, strides: [?, 5, 1]>
 // CHECK: MemRefType offset: 0 strides: ?, 5, 1
-  %24 = alloc(%0)[%0] : memref<3x?x5xf32, (i, j, k)[M]->(M * i + 32 * j + 16 * k + M)>
+  %24 = alloc(%0)[%0] : memref<3x?x5xf32, affine_map<(i, j, k)[M]->(M * i + 32 * j + 16 * k + M)>>
 // CHECK: MemRefType offset: ? strides: ?, 32, 16
   %b24 = alloc(%0)[%0, %0] : memref<3x?x5xf32, offset: ?, strides: [?, 32, 16]>
 // CHECK: MemRefType offset: ? strides: ?, 32, 16
-  %25 = alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, (i, j, k)[M, N]->(M * i + N * j + k + 1)>
+  %25 = alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, affine_map<(i, j, k)[M, N]->(M * i + N * j + k + 1)>>
 // CHECK: MemRefType offset: 1 strides: ?, ?, 1
   %b25 = alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, offset: 1, strides: [?, ?, 1]>
 // CHECK: MemRefType offset: 1 strides: ?, ?, 1
-  %26 = alloc(%0)[] : memref<?xf32, (i)[M]->(i)>
+  %26 = alloc(%0)[] : memref<?xf32, affine_map<(i)[M]->(i)>>
 // CHECK: MemRefType offset: 0 strides: 1
-  %27 = alloc()[%0] : memref<5xf32, (i)[M]->(M)>
-// CHECK: MemRefType memref<5xf32, (d0)[s0] -> (s0)> cannot be converted to strided form
-  %28 = alloc()[%0] : memref<5xf32, (i)[M]->(123)>
-// CHECK: MemRefType memref<5xf32, (d0)[s0] -> (123)> cannot be converted to strided form
-  %29 = alloc()[%0] : memref<f32, ()[M]->(M)>
+  %27 = alloc()[%0] : memref<5xf32, affine_map<(i)[M]->(M)>>
+// CHECK: MemRefType memref<5xf32, affine_map<(d0)[s0] -> (s0)>> cannot be converted to strided form
+  %28 = alloc()[%0] : memref<5xf32, affine_map<(i)[M]->(123)>>
+// CHECK: MemRefType memref<5xf32, affine_map<(d0)[s0] -> (123)>> cannot be converted to strided form
+  %29 = alloc()[%0] : memref<f32, affine_map<()[M]->(M)>>
 // CHECK: MemRefType offset: ? strides:
-  %30 = alloc()[%0] : memref<f32, ()[M]->(123)>
+  %30 = alloc()[%0] : memref<f32, affine_map<()[M]->(123)>>
 // CHECK: MemRefType offset: 123 strides:
 
-  %100 = alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, (i, j, k)[M, N]->(i + j, j, k), (i, j, k)[M, N]->(M * i + N * j + k + 1)>
-// CHECK: MemRefType memref<?x?x16xf32, (d0, d1, d2)[s0, s1] -> (d0 + d1, d1, d2), (d0, d1, d2)[s0, s1] -> (d0 * s0 + d1 * s1 + d2 + 1)> cannot be converted to strided form
-  %101 = alloc() : memref<3x4x5xf32, (i, j, k)->(i floordiv 4 + j + k)>
-// CHECK: MemRefType memref<3x4x5xf32, (d0, d1, d2) -> (d0 floordiv 4 + d1 + d2)> cannot be converted to strided form
-  %102 = alloc() : memref<3x4x5xf32, (i, j, k)->(i ceildiv 4 + j + k)>
-// CHECK: MemRefType memref<3x4x5xf32, (d0, d1, d2) -> (d0 ceildiv 4 + d1 + d2)> cannot be converted to strided form
-  %103 = alloc() : memref<3x4x5xf32, (i, j, k)->(i mod 4 + j + k)>
-// CHECK: MemRefType memref<3x4x5xf32, (d0, d1, d2) -> (d0 mod 4 + d1 + d2)> cannot be converted to strided form
+  %100 = alloc(%0, %0)[%0, %0] : memref<?x?x16xf32, affine_map<(i, j, k)[M, N]->(i + j, j, k)>, affine_map<(i, j, k)[M, N]->(M * i + N * j + k + 1)>>
+// CHECK: MemRefType memref<?x?x16xf32, affine_map<(d0, d1, d2)[s0, s1] -> (d0 + d1, d1, d2)>, affine_map<(d0, d1, d2)[s0, s1] -> (d0 * s0 + d1 * s1 + d2 + 1)>> cannot be converted to strided form
+  %101 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i floordiv 4 + j + k)>>
+// CHECK: MemRefType memref<3x4x5xf32, affine_map<(d0, d1, d2) -> (d0 floordiv 4 + d1 + d2)>> cannot be converted to strided form
+  %102 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i ceildiv 4 + j + k)>>
+// CHECK: MemRefType memref<3x4x5xf32, affine_map<(d0, d1, d2) -> (d0 ceildiv 4 + d1 + d2)>> cannot be converted to strided form
+  %103 = alloc() : memref<3x4x5xf32, affine_map<(i, j, k)->(i mod 4 + j + k)>>
+// CHECK: MemRefType memref<3x4x5xf32, affine_map<(d0, d1, d2) -> (d0 mod 4 + d1 + d2)>> cannot be converted to strided form
 
-  %200 = alloc()[%0, %0, %0] : memref<3x4x5xf32, (i, j, k)[M, N, K]->(M * i + N * i + N * j + K * k - (M + N - 20)* i)>
+  %200 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * i + N * i + N * j + K * k - (M + N - 20)* i)>>
   // CHECK: MemRefType offset: 0 strides: 20, ?, ?
-  %201 = alloc()[%0, %0, %0] : memref<3x4x5xf32, (i, j, k)[M, N, K]->(M * i + N * i + N * K * j + K * K * k - (M + N - 20) * (i + 1))>
+  %201 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * i + N * i + N * K * j + K * K * k - (M + N - 20) * (i + 1))>>
   // CHECK: MemRefType offset: ? strides: 20, ?, ?
-  %202 = alloc()[%0, %0, %0] : memref<3x4x5xf32, (i, j, k)[M, N, K]->(M * (i + 1) + j + k - M)>
+  %202 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M * (i + 1) + j + k - M)>>
   // CHECK: MemRefType offset: 0 strides: ?, 1, 1
-  %203 = alloc()[%0, %0, %0] : memref<3x4x5xf32, (i, j, k)[M, N, K]->(M + M * (i + N * (j + K * k)))>
+  %203 = alloc()[%0, %0, %0] : memref<3x4x5xf32, affine_map<(i, j, k)[M, N, K]->(M + M * (i + N * (j + K * k)))>>
   // CHECK: MemRefType offset: ? strides: ?, ?, ?
 
   return
 }

mlir/test/AffineOps/ops.mlir

func @empty() {
 
   // CHECK: affine.if
   // CHECK-NEXT: } {some_attr = true}
   //
   // GENERIC:      "affine.if"()
   // GENERIC-NEXT:   "affine.terminator"() : () -> ()
   // GENERIC-NEXT: },  {
   // GENERIC-NEXT: })
-  affine.if () : () () {
+  affine.if affine_set<() : ()> () {
   } {some_attr = true}
 
   // CHECK: } else {
   // CHECK: } {some_attr = true}
   //
   // GENERIC:      "affine.if"()
   // GENERIC-NEXT:   "affine.terminator"() : () -> ()
   // GENERIC-NEXT: },  {
   // GENERIC-NEXT:   "foo"() : () -> ()
   // GENERIC-NEXT:   "affine.terminator"() : () -> ()
   // GENERIC-NEXT: })
-  affine.if () : () () {
+  affine.if affine_set<() : ()> () {
   } else {
     "foo"() : () -> ()
   } {some_attr = true}
 
   return
 }
 
 // Check that an explicit affine terminator is not printed in custom format.
func @affine_terminator() {
   affine.for %i = 0 to 10 {
     "affine.terminator"() : () -> ()
   }
   return
 }
 
 // -----
 
-// CHECK-DAG: #[[MAP0:map[0-9]+]] = (d0)[s0] -> (1000, d0 + 512, s0)
-// CHECK-DAG: #[[MAP1:map[0-9]+]] = (d0, d1)[s0] -> (d0 - d1, s0 + 512)
-// CHECK-DAG: #[[MAP2:map[0-9]+]] = ()[s0, s1] -> (s0 - s1, 11)
-// CHECK-DAG: #[[MAP3:map[0-9]+]] = () -> (77, 78, 79)
+// CHECK-DAG: #[[MAP0:map[0-9]+]] = affine_map<(d0)[s0] -> (1000, d0 + 512, s0)>
+// CHECK-DAG: #[[MAP1:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 - d1, s0 + 512)>
+// CHECK-DAG: #[[MAP2:map[0-9]+]] = affine_map<()[s0, s1] -> (s0 - s1, 11)>
+// CHECK-DAG: #[[MAP3:map[0-9]+]] = affine_map<() -> (77, 78, 79)>
 
 // CHECK-LABEL: @affine_min
 func @affine_min(%arg0 : index, %arg1 : index, %arg2 : index) {
   // CHECK: affine.min #[[MAP0]](%arg0)[%arg1]
-  %0 = affine.min (d0)[s0] -> (1000, d0 + 512, s0) (%arg0)[%arg1]
+  %0 = affine.min affine_map<(d0)[s0] -> (1000, d0 + 512, s0)> (%arg0)[%arg1]
   // CHECK: affine.min #[[MAP1]](%arg0, %arg1)[%arg2]
-  %1 = affine.min (d0, d1)[s0] -> (d0 - d1, s0 + 512) (%arg0, %arg1)[%arg2]
+  %1 = affine.min affine_map<(d0, d1)[s0] -> (d0 - d1, s0 + 512)> (%arg0, %arg1)[%arg2]
   // CHECK: affine.min #[[MAP2]]()[%arg1, %arg2]
-  %2 = affine.min ()[s0, s1] -> (s0 - s1, 11) ()[%arg1, %arg2]
+  %2 = affine.min affine_map<()[s0, s1] -> (s0 - s1, 11)> ()[%arg1, %arg2]
   // CHECK: affine.min #[[MAP3]]()
-  %3 = affine.min ()[] -> (77, 78, 79) ()[]
+  %3 = affine.min affine_map<()[] -> (77, 78, 79)> ()[]
   return
 }
 
 // -----
 
 func @valid_symbols(%arg0: index, %arg1: index, %arg2: index) {
   %c0 = constant 1 : index
   %c1 = constant 0 : index
   %0 = alloc(%arg0, %arg1) : memref<?x?xf32>
   affine.for %arg3 = 0 to %arg2 step 768 {
     %13 = dim %0, 1 : memref<?x?xf32>
     affine.for %arg4 = 0 to %13 step 264 {
       %18 = dim %0, 0 : memref<?x?xf32>
       %20 = std.subview %0[%c0, %c0][%18,%arg4][%c1,%c1] : memref<?x?xf32>
-                          to memref<?x?xf32, (d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>
-      %24 = dim %20, 0 : memref<?x?xf32, (d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>
+                          to memref<?x?xf32, affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>>
+      %24 = dim %20, 0 : memref<?x?xf32, affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>>
       affine.for %arg5 = 0 to %24 step 768 {
         "foo"() : () -> ()
       }
     }
   }
   return
 }

mlir/test/Conversion/StandardToLLVM/convert-memref-ops.mlir

 // RUN: mlir-opt -convert-std-to-llvm %s | FileCheck %s
 // RUN: mlir-opt -convert-std-to-llvm -convert-std-to-llvm-use-alloca=1 %s | FileCheck %s --check-prefix=ALLOCA
 
 // CHECK-LABEL: func @check_arguments(%arg0: !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">, %arg1: !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">, %arg2: !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">)
 func @check_arguments(%static: memref<10x20xf32>, %dynamic : memref<?x?xf32>, %mixed : memref<10x?xf32>) {
   return
 }
 
 //   CHECK-LABEL: func @check_strided_memref_arguments(
 // CHECK-COUNT-3:   !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">
-func @check_strided_memref_arguments(%static: memref<10x20xf32, (i,j)->(20 * i + j + 1)>,
-                                     %dynamic : memref<?x?xf32, (i,j)[M]->(M * i + j + 1)>,
-                                     %mixed : memref<10x?xf32, (i,j)[M]->(M * i + j + 1)>) {
+func @check_strided_memref_arguments(%static: memref<10x20xf32, affine_map<(i,j)->(20 * i + j + 1)>>,
+                                     %dynamic : memref<?x?xf32, affine_map<(i,j)[M]->(M * i + j + 1)>>,
+                                     %mixed : memref<10x?xf32, affine_map<(i,j)[M]->(M * i + j + 1)>>) {
   return
 }
 
 // CHECK-LABEL: func @check_static_return(%arg0: !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">) -> !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }"> {
 func @check_static_return(%static : memref<32x18xf32>) -> memref<32x18xf32> {
 // CHECK:  llvm.return %{{.*}} : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   return %static : memref<32x18xf32>
 }

mlir/test/Conversion/StandardToLLVM/convert-to-llvmir.mlir

func @view(%arg0 : index, %arg1 : index, %arg2 : index) {
   // CHECK: llvm.insertvalue %[[ARG2]], %{{.*}}[2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(1 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.insertvalue %[[ARG0]], %{{.*}}[3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mul %{{.*}}, %[[ARG1]]
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   %1 = view %0[%arg2][%arg0, %arg1]
-    : memref<2048xi8> to memref<?x?xf32, (d0, d1)[s0, s1] -> (d0 * s0 + d1 + s1)>
+    : memref<2048xi8> to memref<?x?xf32, affine_map<(d0, d1)[s0, s1] -> (d0 * s0 + d1 + s1)>>
 
   // Test two dynamic sizes and static offset.
   // CHECK: llvm.mlir.undef : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.extractvalue %{{.*}}[1] : !llvm<"{ i8*, i8*, i64, [1 x i64], [1 x i64] }">
   // CHECK: llvm.bitcast %{{.*}} : !llvm<"i8*"> to !llvm<"float*">
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(0 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(1 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.insertvalue %arg0, %{{.*}}[3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mul %{{.*}}, %[[ARG1]]
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   %2 = view %0[][%arg0, %arg1]
-    : memref<2048xi8> to memref<?x?xf32, (d0, d1)[s0] -> (d0 * s0 + d1)>
+    : memref<2048xi8> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * s0 + d1)>>
 
   // Test one dynamic size and dynamic offset.
   // CHECK: llvm.mlir.undef : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.extractvalue %{{.*}}[1] : !llvm<"{ i8*, i8*, i64, [1 x i64], [1 x i64] }">
   // CHECK: llvm.bitcast %{{.*}} : !llvm<"i8*"> to !llvm<"float*">
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.insertvalue %[[ARG2]], %{{.*}}[2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(1 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(4 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mul %{{.*}}, %[[ARG1]]
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   %3 = view %0[%arg2][%arg1]
-    : memref<2048xi8> to memref<4x?xf32, (d0, d1)[s0, s1] -> (d0 * s0 + d1 + s1)>
+    : memref<2048xi8> to memref<4x?xf32, affine_map<(d0, d1)[s0, s1] -> (d0 * s0 + d1 + s1)>>
 
   // Test one dynamic size and static offset.
   // CHECK: llvm.mlir.undef : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.extractvalue %{{.*}}[1] : !llvm<"{ i8*, i8*, i64, [1 x i64], [1 x i64] }">
   // CHECK: llvm.bitcast %{{.*}} : !llvm<"i8*"> to !llvm<"float*">
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(0 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(16 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(1 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.insertvalue %[[ARG0]], %{{.*}}[3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(4 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   %4 = view %0[][%arg0]
-    : memref<2048xi8> to memref<?x16xf32, (d0, d1) -> (d0 * 4 + d1)>
+    : memref<2048xi8> to memref<?x16xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>>
 
   // Test static sizes and static offset.
   // CHECK: llvm.mlir.undef : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.extractvalue %{{.*}}[1] : !llvm<"{ i8*, i8*, i64, [1 x i64], [1 x i64] }">
   // CHECK: llvm.bitcast %{{.*}} : !llvm<"i8*"> to !llvm<"float*">
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(0 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(4 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(1 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(64 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mlir.constant(4 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   %5 = view %0[][]
-    : memref<2048xi8> to memref<64x4xf32, (d0, d1) -> (d0 * 4 + d1)>
+    : memref<2048xi8> to memref<64x4xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>>
 
   // Test dynamic everything.
   // CHECK: llvm.mlir.undef : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.extractvalue %{{.*}}[1] : !llvm<"{ i8*, i8*, i64, [1 x i64], [1 x i64] }">
   // CHECK: llvm.bitcast %{{.*}} : !llvm<"i8*"> to !llvm<"float*">
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.insertvalue %[[ARG2]], %{{.*}}[2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[STRIDE_1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64
   // CHECK: llvm.insertvalue %[[STRIDE_1]], %{{.*}}[4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.insertvalue %[[ARG0]], %{{.*}}[3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: llvm.mul %[[STRIDE_1]], %[[ARG1]] : !llvm.i64
   // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   %6 = view %0[%arg2][%arg0, %arg1]
-    : memref<2048xi8> to memref<?x?xf32, (d0, d1)[s0, s1] -> (d0 * s0 + d1 + s1)>
+    : memref<2048xi8> to memref<?x?xf32, affine_map<(d0, d1)[s0, s1] -> (d0 * s0 + d1 + s1)>>
 
   return
 }
 
 // CHECK-LABEL: func @subview(
 // CHECK: %[[MEMREFPTR:.*]]: !llvm<{{.*}}>, %[[ARG0:.*]]: !llvm.i64, %[[ARG1:.*]]: !llvm.i64, %[[ARG2:.*]]: !llvm.i64
-func @subview(%0 : memref<64x4xf32, (d0, d1) -> (d0 * 4 + d1)>, %arg0 : index, %arg1 : index, %arg2 : index) {
+func @subview(%0 : memref<64x4xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>>, %arg0 : index, %arg1 : index, %arg2 : index) {
   // CHECK: %[[MEMREF:.*]] = llvm.load %[[MEMREFPTR]] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">
   // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC0:.*]] = llvm.insertvalue %{{.*}}, %[[DESC]][0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC1:.*]] = llvm.insertvalue %{{.*}}, %[[DESC0]][1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i64
   // CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i64
   // CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i64
   // CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i64
   // CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[ARG1]], %[[DESC2]][3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i64
   // CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC4]][3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i64
   // CHECK: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   %1 = subview %0[%arg0, %arg1][%arg0, %arg1][%arg0, %arg1] :
-    memref<64x4xf32, (d0, d1) -> (d0 * 4 + d1)> to memref<?x?xf32, (d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>
+    memref<64x4xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>> to memref<?x?xf32, affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>>
   return
 }
 
 // CHECK-LABEL: func @subview_const_size(
 // CHECK: %[[MEMREFPTR:.*]]: !llvm<{{.*}}>, %[[ARG0:.*]]: !llvm.i64, %[[ARG1:.*]]: !llvm.i64, %[[ARG2:.*]]: !llvm.i64
-func @subview_const_size(%0 : memref<64x4xf32, (d0, d1) -> (d0 * 4 + d1)>, %arg0 : index, %arg1 : index, %arg2 : index) {
+func @subview_const_size(%0 : memref<64x4xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>>, %arg0 : index, %arg1 : index, %arg2 : index) {
   // CHECK: %[[MEMREF:.*]] = llvm.load %[[MEMREFPTR]] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">
   // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC0:.*]] = llvm.insertvalue %{{.*}}, %[[DESC]][0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC1:.*]] = llvm.insertvalue %{{.*}}, %[[DESC0]][1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[CST4:.*]] = llvm.mlir.constant(4 : i64)
   // CHECK: %[[CST2:.*]] = llvm.mlir.constant(2 : i64)
   // CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i64
   // CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i64
   // CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i64
   // CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i64
   // CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[CST2]], %[[DESC2]][3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESCSTRIDE1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i64
   // CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[DESCSTRIDE1]], %[[DESC3]][4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[CST4]], %[[DESC4]][3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESCSTRIDE0:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i64
   // CHECK: llvm.insertvalue %[[DESCSTRIDE0]], %[[DESC5]][4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   %1 = subview %0[%arg0, %arg1][][%arg0, %arg1] :
-    memref<64x4xf32, (d0, d1) -> (d0 * 4 + d1)> to memref<4x2xf32, (d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>
+    memref<64x4xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>> to memref<4x2xf32, affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>>
   return
 }
 
 // CHECK-LABEL: func @subview_const_stride(
 // CHECK: %[[MEMREFPTR:.*]]: !llvm<{{.*}}>, %[[ARG0:.*]]: !llvm.i64, %[[ARG1:.*]]: !llvm.i64, %[[ARG2:.*]]: !llvm.i64
-func @subview_const_stride(%0 : memref<64x4xf32, (d0, d1) -> (d0 * 4 + d1)>, %arg0 : index, %arg1 : index, %arg2 : index) {
+func @subview_const_stride(%0 : memref<64x4xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>>, %arg0 : index, %arg1 : index, %arg2 : index) {
   // CHECK: %[[MEMREF:.*]] = llvm.load %[[MEMREFPTR]] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">
   // CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC0:.*]] = llvm.insertvalue %{{.*}}, %[[DESC]][0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC1:.*]] = llvm.insertvalue %{{.*}}, %[[DESC0]][1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEMREF]][4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEMREF]][4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[OFF:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[OFFINC:.*]] = llvm.mul %[[ARG0]], %[[STRIDE0]] : !llvm.i64
   // CHECK: %[[OFF1:.*]] = llvm.add %[[OFF]], %[[OFFINC]] : !llvm.i64
   // CHECK: %[[OFFINC1:.*]] = llvm.mul %[[ARG1]], %[[STRIDE1]] : !llvm.i64
   // CHECK: %[[OFF2:.*]] = llvm.add %[[OFF1]], %[[OFFINC1]] : !llvm.i64
   // CHECK: %[[DESC2:.*]] = llvm.insertvalue %[[OFF2]], %[[DESC1]][2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC3:.*]] = llvm.insertvalue %[[ARG1]], %[[DESC2]][3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[CST2:.*]] = llvm.mlir.constant(2 : i64)
   // CHECK: %[[DESC4:.*]] = llvm.insertvalue %[[CST2]], %[[DESC3]][4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[DESC5:.*]] = llvm.insertvalue %[[ARG0]], %[[DESC4]][3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   // CHECK: %[[CST4:.*]] = llvm.mlir.constant(4 : i64)
   // CHECK: llvm.insertvalue %[[CST4]], %[[DESC5]][4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
   %1 = subview %0[%arg0, %arg1][%arg0, %arg1][] :
-    memref<64x4xf32, (d0, d1) -> (d0 * 4 + d1)> to memref<?x?xf32, (d0, d1)[s0] -> (d0 * 4 + d1 * 2 + s0)>
+    memref<64x4xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * 4 + d1 * 2 + s0)>>
   return
 }
 
 // -----
 
 module {
   func @check_tanh_func_added_only_once_to_symbol_table(%f: f32, %lf: f64) -> () {
     %f0 = std.tanh %f : f32

mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir

 // RUN: mlir-opt %s -convert-std-to-llvm -split-input-file -verify-diagnostics | FileCheck %s
 
 // CHECK-LABEL: func @address_space(
 //       CHECK:   %{{.*}}: !llvm<"{ float addrspace(7)*, float addrspace(7)*, i64, [1 x i64], [1 x i64] }*">)
 //       CHECK:   llvm.load %{{.*}} : !llvm<"{ float addrspace(7)*, float addrspace(7)*, i64, [1 x i64], [1 x i64] }*">
-func @address_space(%arg0 : memref<32xf32, (d0) -> (d0), 7>) {
-  %0 = alloc() : memref<32xf32, (d0) -> (d0), 5>
+func @address_space(%arg0 : memref<32xf32, affine_map<(d0) -> (d0)>, 7>) {
+  %0 = alloc() : memref<32xf32, affine_map<(d0) -> (d0)>, 5>
   %1 = constant 7 : index
   // CHECK: llvm.load %{{.*}} : !llvm<"float addrspace(5)*">
-  %2 = load %0[%1] : memref<32xf32, (d0) -> (d0), 5>
+  %2 = load %0[%1] : memref<32xf32, affine_map<(d0) -> (d0)>, 5>
   std.return
 }
 
 // CHECK-LABEL: func @strided_memref(
 func @strided_memref(%ind: index) {
-  %0 = alloc()[%ind] : memref<32x64xf32, (i, j)[M] -> (32 + M * i + j)>
+  %0 = alloc()[%ind] : memref<32x64xf32, affine_map<(i, j)[M] -> (32 + M * i + j)>>
   std.return
 }
 
 // -----
 
 // This should not crash. The first operation cannot be converted, so the
 // second should not match. This attempts to convert `return` to `llvm.return`
 // and complains about non-LLVM types.
 func @unknown_source() -> i32 {
   %0 = "foo"() : () -> i32
   %1 = addi %0, %0 : i32
   // expected-error@+1 {{must be LLVM dialect type}}
   return %1 : i32
 }

mlir/test/Conversion/VectorToLoops/vector-to-loops.mlir

 // RUN: mlir-opt %s -test-convert-vector-to-loops | FileCheck %s
 
-// CHECK: #[[ADD:map[0-9]+]] = (d0, d1) -> (d0 + d1)
-// CHECK: #[[SUB:map[0-9]+]] = ()[s0] -> (s0 - 1)
+// CHECK: #[[ADD:map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1)>
+// CHECK: #[[SUB:map[0-9]+]] = affine_map<()[s0] -> (s0 - 1)>
 
 // CHECK-LABEL: func @materialize_read_1d() {
 func @materialize_read_1d() {
   %f0 = constant 0.0: f32
   %A = alloc () : memref<7x42xf32>
   affine.for %i0 = 0 to 7 step 4 {
     affine.for %i1 = 0 to 42 step 4 {
-      %f1 = vector.transfer_read %A[%i0, %i1], %f0 {permutation_map = (d0, d1) -> (d0)} : memref<7x42xf32>, vector<4xf32>
-      %ip1 = affine.apply (d0) -> (d0 + 1) (%i1)
-      %f2 = vector.transfer_read %A[%i0, %ip1], %f0 {permutation_map = (d0, d1) -> (d0)} : memref<7x42xf32>, vector<4xf32>
-      %ip2 = affine.apply (d0) -> (d0 + 2) (%i1)
-      %f3 = vector.transfer_read %A[%i0, %ip2], %f0 {permutation_map = (d0, d1) -> (d0)} : memref<7x42xf32>, vector<4xf32>
-      %ip3 = affine.apply (d0) -> (d0 + 3) (%i1)
-      %f4 = vector.transfer_read %A[%i0, %ip3], %f0 {permutation_map = (d0, d1) -> (d0)} : memref<7x42xf32>, vector<4xf32>
+      %f1 = vector.transfer_read %A[%i0, %i1], %f0 {permutation_map = affine_map<(d0, d1) -> (d0)>} : memref<7x42xf32>, vector<4xf32>
+      %ip1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i1)
+      %f2 = vector.transfer_read %A[%i0, %ip1], %f0 {permutation_map = affine_map<(d0, d1) -> (d0)>} : memref<7x42xf32>, vector<4xf32>
+      %ip2 = affine.apply affine_map<(d0) -> (d0 + 2)> (%i1)
+      %f3 = vector.transfer_read %A[%i0, %ip2], %f0 {permutation_map = affine_map<(d0, d1) -> (d0)>} : memref<7x42xf32>, vector<4xf32>
+      %ip3 = affine.apply affine_map<(d0) -> (d0 + 3)> (%i1)
+      %f4 = vector.transfer_read %A[%i0, %ip3], %f0 {permutation_map = affine_map<(d0, d1) -> (d0)>} : memref<7x42xf32>, vector<4xf32>
       // Both accesses in the load must be clipped otherwise %i1 + 2 and %i1 + 3 will go out of bounds.
       // CHECK: {{.*}} = select
       // CHECK: %[[FILTERED1:.*]] = select
       // CHECK: {{.*}} = select
       // CHECK: %[[FILTERED2:.*]] = select
       // CHECK-NEXT: %{{.*}} = load {{.*}}[%[[FILTERED1]], %[[FILTERED2]]] : memref<7x42xf32>
     }
   }
   return
 }
 
 // CHECK-LABEL: func @materialize_read_1d_partially_specialized
 func @materialize_read_1d_partially_specialized(%dyn1 : index, %dyn2 : index, %dyn4 : index) {
   %f0 = constant 0.0: f32
   %A = alloc (%dyn1, %dyn2, %dyn4) : memref<7x?x?x42x?xf32>
   affine.for %i0 = 0 to 7 {
     affine.for %i1 = 0 to %dyn1 {
       affine.for %i2 = 0 to %dyn2 {
         affine.for %i3 = 0 to 42 step 2 {
           affine.for %i4 = 0 to %dyn4 {
-            %f1 = vector.transfer_read %A[%i0, %i1, %i2, %i3, %i4], %f0 {permutation_map = (d0, d1, d2, d3, d4) -> (d3)} : memref<7x?x?x42x?xf32>, vector<4xf32>
-            %i3p1 = affine.apply (d0) -> (d0 + 1) (%i3)
-            %f2 = vector.transfer_read %A[%i0, %i1, %i2, %i3p1, %i4], %f0 {permutation_map = (d0, d1, d2, d3, d4) -> (d3)} : memref<7x?x?x42x?xf32>, vector<4xf32>
+            %f1 = vector.transfer_read %A[%i0, %i1, %i2, %i3, %i4], %f0 {permutation_map = affine_map<(d0, d1, d2, d3, d4) -> (d3)>} : memref<7x?x?x42x?xf32>, vector<4xf32>
+            %i3p1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i3)
+            %f2 = vector.transfer_read %A[%i0, %i1, %i2, %i3p1, %i4], %f0 {permutation_map = affine_map<(d0, d1, d2, d3, d4) -> (d3)>} : memref<7x?x?x42x?xf32>, vector<4xf32>
           }
         }
       }
     }
   }
   // CHECK: %[[tensor:[0-9]+]] = alloc
   // CHECK-NOT: {{.*}} dim %[[tensor]], 0
   // CHECK-NOT: {{.*}} dim %[[tensor]], 3
func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
   // Check that I0 + I4 (of size 3) read from first index load(L0, ...) and write into last index store(..., I4)
   // Check that I3 + I6 (of size 5) read from last index load(..., L3) and write into first index store(I6, ...)
   // Other dimensions are just accessed with I1, I2 resp.
   %A = alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
   affine.for %i0 = 0 to %M step 3 {
     affine.for %i1 = 0 to %N {
       affine.for %i2 = 0 to %O {
         affine.for %i3 = 0 to %P step 5 {
-          %f = vector.transfer_read %A[%i0, %i1, %i2, %i3], %f0 {permutation_map = (d0, d1, d2, d3) -> (d3, 0, d0)} : memref<?x?x?x?xf32>, vector<5x4x3xf32>
+          %f = vector.transfer_read %A[%i0, %i1, %i2, %i3], %f0 {permutation_map = affine_map<(d0, d1, d2, d3) -> (d3, 0, d0)>} : memref<?x?x?x?xf32>, vector<5x4x3xf32>
         }
       }
     }
   }
   return
 }
 
 // CHECK-LABEL:func @materialize_write(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
   // Check that I3 + I6 (of size 5) read from first index load(I6, ...) and write into last index store(..., S3)
   // Other dimension is just accessed with I2.
   %A = alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
   %f1 = constant dense<1.000000e+00> : vector<5x4x3xf32>
   affine.for %i0 = 0 to %M step 3 {
     affine.for %i1 = 0 to %N step 4 {
       affine.for %i2 = 0 to %O {
         affine.for %i3 = 0 to %P step 5 {
-          vector.transfer_write %f1, %A[%i0, %i1, %i2, %i3] {permutation_map = (d0, d1, d2, d3) -> (d3, d1, d0)} : vector<5x4x3xf32>, memref<?x?x?x?xf32>
+          vector.transfer_write %f1, %A[%i0, %i1, %i2, %i3] {permutation_map = affine_map<(d0, d1, d2, d3) -> (d3, d1, d0)>} : vector<5x4x3xf32>, memref<?x?x?x?xf32>
         }
       }
     }
   }
   return
 }

mlir/test/Dialect/Linalg/affine.mlir

 // RUN: mlir-opt %s -convert-linalg-to-affine-loops | FileCheck %s
 
 // Test that we can lower all the way to LLVM without crashing, don't check results here.
 // RUN: mlir-opt %s --convert-linalg-to-llvm -o=/dev/null 2>&1
 
-// CHECK-DAG: #[[strided2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
-// CHECK-DAG: #[[strided3D:.*]] = (d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)
+// CHECK-DAG: #[[strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+// CHECK-DAG: #[[strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
 
-// CHECK-DAG: #[[stride2Dilation1:.*]] = (d0, d1) -> (d0 * 2 + d1)
+// CHECK-DAG: #[[stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)>
 
 func @matmul(%arg0: memref<?xi8>, %M: index, %N: index, %K: index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %A = view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32, offset: ?, strides: [?, 1]>
   %B = view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32, offset: ?, strides: [?, 1]>
   %C = view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32, offset: ?, strides: [?, 1]>
   linalg.matmul(%A, %B, %C) : memref<?x?xf32, offset: ?, strides: [?, 1]>, memref<?x?xf32, offset: ?, strides: [?, 1]>, memref<?x?xf32, offset: ?, strides: [?, 1]>

mlir/test/Dialect/Linalg/fusion.mlir

 // RUN: mlir-opt %s -linalg-fusion | FileCheck %s
 
-#map0 = (d0) -> (d0 + 2)
-#map1 = (d0) -> (d0 + 4)
-#map2 = (d0) -> (d0 + 3)
-#map3 = (d0)[s0, s1] -> (d0 * s1 + s0)
-#map4 = (d0) -> (d0)
-#map5 = (d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)
-#map6 = (d0, d1) -> (d0, d1)
-// CHECK-DAG: #[[strided2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s0 + d1 * s1)
+#map0 = affine_map<(d0) -> (d0 + 2)>
+#map1 = affine_map<(d0) -> (d0 + 4)>
+#map2 = affine_map<(d0) -> (d0 + 3)>
+#map3 = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
+#map4 = affine_map<(d0) -> (d0)>
+#map5 = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
+#map6 = affine_map<(d0, d1) -> (d0, d1)>
+// CHECK-DAG: #[[strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s0 + d1 * s1)>
 
 func @f1(%A: memref<?x?xf32, offset: 0, strides: [?, 1]>, %B: memref<?x?xf32, offset: 0, strides: [?, 1]>, %C: memref<?x?xf32, offset: 0, strides: [?, 1]>, %D: memref<?x?xf32, offset: 0, strides: [?, 1]>, %E: memref<?x?xf32, offset: 0, strides: [?, 1]>) -> memref<?x?xf32, offset: 0, strides: [?, 1]> {
   %c0 = constant 0 : index
   %c4 = constant 4 : index
   %c3 = constant 3 : index
   %c2 = constant 2 : index
   %0 = dim %A, 0 : memref<?x?xf32, offset: 0, strides: [?, 1]>
   %1 = dim %A, 1 : memref<?x?xf32, offset: 0, strides: [?, 1]>

 //   CHECK:   linalg.matmul
 //   CHECK:   linalg.matmul
 //   CHECK:   loop.for
 //   CHECK:     loop.for
 //   CHECK:       loop.for
 //   CHECK:         linalg.matmul
 // CHECK-NOT:       linalg.matmul
 
-#id_2d = (i, j) -> (i, j)
+#id_2d = affine_map<(i, j) -> (i, j)>
 #pointwise_2d_trait = {
   args_in = 2,
   args_out = 1,
   indexing_maps = [#id_2d, #id_2d, #id_2d],
   iterator_types = ["parallel", "parallel"]
 }
 func @pointwise(%A: memref<?x?xf32, offset: 0, strides: [?, ?]>, %B: memref<?x?xf32, offset: 0, strides: [?, ?]>, %C: memref<?x?xf32, offset: 0, strides: [?, ?]>, %D: memref<?x?xf32, offset: 0, strides: [?, ?]>) {
   %c1 = constant 1 : index

mlir/test/Dialect/Linalg/invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 func @load_number_of_indices(%v : memref<f32>) {
   // expected-error @+2 {{incorrect number of indices for load}}
   %c0 = constant 0 : index
   load %v[%c0] : memref<f32>
 }
 
 // -----
 
-func @slice_number_of_indexings(%arg0: memref<?x?xf32, (i, j)[off, M]->(off + M * i + j)>) {
+func @slice_number_of_indexings(%arg0: memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>) {
   // expected-error @+2 {{expected 2 indexings, got 1}}
   %c0 = constant 0: index
-  %0 = linalg.slice %arg0[%c0] : memref<?x?xf32, (i, j)[off, M]->(off + M * i + j)>, index, memref<?x?xf32, (i, j)[off, M]->(off + M * i + j)>
+  %0 = linalg.slice %arg0[%c0] : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>, index, memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>
 }
 
 // -----
 
-func @slice_rank_vs_range_indices(%arg0: memref<?x?xf32, (i, j)[off, M]->(off + M * i + j)>) {
+func @slice_rank_vs_range_indices(%arg0: memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>) {
   // expected-error @+2 {{op expected rank of the view(1) to be the number of ranges(0)}}
   %c0 = constant 0: index
-  %0 = linalg.slice %arg0[%c0, %c0] : memref<?x?xf32, (i, j)[off, M]->(off + M * i + j)>, index, index, memref<?xf32, (i)[off]->(off + i)>
+  %0 = linalg.slice %arg0[%c0, %c0] : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>, index, index, memref<?xf32, affine_map<(i)[off]->(off + i)>>
 }
 
 // -----
 
 func @store_number_of_indices(%v : memref<f32>) {
   // expected-error @+3 {{store index operand count not equal to memref rank}}
   %c0 = constant 0 : index
   %f0 = constant 0.0 : f32
   store %f0, %v[%c0] : memref<f32>
 }
 
 // -----
 
-func @transpose_not_permutation(%v : memref<?x?xf32, (i, j)[off, M]->(off + M * i + j)>) {
+func @transpose_not_permutation(%v : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>) {
   // expected-error @+1 {{expected a permutation map}}
-  linalg.transpose %v (i, j) -> (i, i) : memref<?x?xf32, (i, j)[off, M]->(off + M * i + j)>
+  linalg.transpose %v (i, j) -> (i, i) : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>
 }
 
 // -----
 
-func @transpose_bad_rank(%v : memref<?x?xf32, (i, j)[off, M]->(off + M * i + j)>) {
+func @transpose_bad_rank(%v : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>) {
   // expected-error @+1 {{expected a permutation map of same rank as the view}}
-  linalg.transpose %v (i) -> (i) : memref<?x?xf32, (i, j)[off, M]->(off + M * i + j)>
+  linalg.transpose %v (i) -> (i) : memref<?x?xf32, affine_map<(i, j)[off, M]->(off + M * i + j)>>
 }
 
 // -----
 
-func @yield_parent(%arg0: memref<?xf32, (i)[off]->(off + i)>) {
+func @yield_parent(%arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
   // expected-error @+1 {{op expected 'linalg.generic' or 'linalg.indexed_generic' parent op}}
-  linalg.yield %arg0: memref<?xf32, (i)[off]->(off + i)>
+  linalg.yield %arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>
 }
 
 // -----
 
 func @generic_at_least_2_operands(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected 2 or more operands}}
   linalg.generic {
     args_in = 1,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
   } %arg0: memref<f32>
 }
 
 // -----
 
 func @generic_exactly_2_views(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected exactly 2 view operands}}
   linalg.generic {
     args_in = 1,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
   } %arg0, %arg0, %arg0: memref<f32>, memref<f32>, memref<f32>
 }
 
 // -----
 
 func @generic_undefined_fun(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected fun attribute to refer to a defined symbol}}
   linalg.generic {
     args_in = 1,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
   } %arg0, %arg0: memref<f32>, memref<f32>
 }
 
 // -----
 
 func @foo() { return }
 
 func @generic_mismatched_num_arguments(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected fun arguments to match number of views}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
   } %arg0: memref<f32>
 }
 
 // -----
 
 func @foo(%0: i32) { return }
 
 func @generic_mismatched_num_returns(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected fun results to match number of output views}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
   } %arg0: memref<f32>
 }
 
 // -----
 
 func @foo(%0: i32) -> i32 { return %0: i32 }
 
 func @generic_symbol_in_map(%arg0: memref<i32>) {
   // expected-error @+1 {{op expected indexing_map #0 to have no symbols}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ ()[N] -> (0) ],
+    indexing_maps =  [ affine_map<()[N] -> (0)> ],
     iterator_types = ["parallel"]
   } %arg0: memref<i32>
 }
 
 // -----
 
 func @foo(%0: i32) -> i32 { return %0: i32 }
 
 func @generic_wrong_dim_in_map(%arg0: memref<i32>) {
   // expected-error @+1 {{op expected indexing_map #0 to have 1 dim(s) to match the number of loops}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = ["parallel"]
   } %arg0: memref<i32>
 }
 
 // -----
 
 func @foo(%0: i32) -> i32 { return %0: i32 }
 
 func @generic_zero_d_view(%arg0: memref<i32>) {
   // expected-error @+1 {{op expected indexing_map #0 to be 0 to match 0-D view: 'memref<i32>'}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ () -> (1) ],
+    indexing_maps =  [ affine_map<() -> (1)> ],
     iterator_types = []
   } %arg0: memref<i32>
 }
 
 // -----
 
 func @foo(%0: f32) -> f32 { return %0: f32 }
 
-func @generic_one_d_view(%arg0: memref<?xf32, (i)[off]->(off + i)>) {
-  // expected-error @+1 {{op expected indexing_map #0 results to match view rank: 'memref<?xf32, (d0)[s0] -> (d0 + s0)>'}}
+func @generic_one_d_view(%arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
+  // expected-error @+1 {{op expected indexing_map #0 results to match view rank: 'memref<?xf32, affine_map<(d0)[s0] -> (d0 + s0)>>'}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ () -> (0, 0) ],
+    indexing_maps =  [ affine_map<() -> (0, 0)> ],
     iterator_types = []
-  } %arg0: memref<?xf32, (i)[off]->(off + i)>
+  } %arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>
 }
 
 // -----
 
 func @foo(%0: i32) -> f32 {
   %1 = constant 0.0: f32
   return %1: f32
 }
 
-func @generic_fun_arg_0_element_type(%arg0: memref<?xf32, (i)[off]->(off + i)>) {
+func @generic_fun_arg_0_element_type(%arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
   // expected-error @+1 {{op expected fun argument 0 of the same type as elemental type 'f32' of view 0}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
-  } %arg0: memref<?xf32, (i)[off]->(off + i)>
+  } %arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>
 }
 
 // -----
 
 func @foo(%0: f32) -> i4 {
   %1 = constant 1: i4
   return %1: i4
 }
 
-func @generic_fun_result_0_element_type(%arg0: memref<?xf32, (i)[off]->(off + i)>) {
+func @generic_fun_result_0_element_type(%arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
   // expected-error @+1 {{op expected fun result 0 of the same type as elemental type 'f32' of view 0}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
     fun = @foo,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
-  } %arg0: memref<?xf32, (i)[off]->(off + i)>
+  } %arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>
 }
 
 // -----
 
 func @foo(%0: f32, %1: f32) -> f32 { return %1: f32 }
 
-func @generic_singular_maps(%arg0: memref<?xf32, (i)[off]->(off + i)>, %arg1: memref<?xf32, (i)[off]->(off + i)>) {
+func @generic_singular_maps(%arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>, %arg1: memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
   // expected-error @+1 {{op expected the concatenation of maps in indexing_map to be invertible}}
   linalg.generic {
     args_in = 1,
     args_out = 1,
     fun = @foo,
     indexing_maps =  [
-      (i, j) -> (i + j) ,
-      (i, j) -> (i + j)
+      affine_map<(i, j) -> (i + j)>,
+      affine_map<(i, j) -> (i + j)>
     ],
     iterator_types = ["parallel","parallel"]
-  } %arg0, %arg1: memref<?xf32, (i)[off]->(off + i)>, memref<?xf32, (i)[off]->(off + i)>
+  } %arg0, %arg1: memref<?xf32, affine_map<(i)[off]->(off + i)>>, memref<?xf32, affine_map<(i)[off]->(off + i)>>
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 ///////////////////////////// Region tests /////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
 // -----
 
 func @generic_empty_region(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected region with 1 block}}
   linalg.generic {
     args_in = 1,
     args_out = 1,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
   } %arg0, %arg0 {
     ^bb1:
     ^bb2:
   }: memref<f32>, memref<f32>
 }
 
 // -----
 
 func @generic_mismatched_num_arguments(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected number of block arguments to match number of views}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
   } %arg0 {
     ^bb:
   }: memref<f32>
 }
 
 // -----
 
 func @generic_block_arg_type(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected block argument 0 of the same type as elemental type of output view: 'memref<f32>'}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps =  [ () -> (0) ],
+    indexing_maps =  [ affine_map<() -> (0)> ],
     iterator_types = []
   } %arg0 {
     ^bb(%i: i1):
   }: memref<f32>
 }
 
 // -----
 
 func @indexed_generic_block_arg_count(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected number of block arguments to match number of views + number of loops}}
   linalg.indexed_generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps =  [ (d0) -> (d0) ],
+    indexing_maps =  [ affine_map<(d0) -> (d0)> ],
     iterator_types = ["parallel"]
   } %arg0 {
     ^bb(%f: f32):
   }: memref<f32>
 }
 
 // -----
 
 func @indexed_generic_block_induction_var_arg_type(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected block argument 0 to be of IndexType}}
   linalg.indexed_generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps =  [ (d0) -> (d0) ],
+    indexing_maps =  [ affine_map<(d0) -> (d0)> ],
     iterator_types = ["parallel"]
   } %arg0 {
     ^bb(%i: f64, %f: f32):
   }: memref<f32>
 }
 
 // -----
 
 func @indexed_generic_block_arg_type(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected block argument 1 of the same type as elemental type of output view: 'memref<f32>'}}
   linalg.indexed_generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps =  [ (d0) -> (d0) ],
+    indexing_maps =  [ affine_map<(d0) -> (d0)> ],
     iterator_types = ["parallel"]
   } %arg0 {
     ^bb(%i: index, %f: i1):
   }: memref<f32>
 }
 
 // -----
 
 func @foo(%f: f32) -> (f32) {
   return %f : f32
 }
 func @indexed_generic_fun_arg_count(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected fun arguments to match number of views + number of loops}}
   linalg.indexed_generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps =  [ (d0) -> (d0) ],
+    indexing_maps =  [ affine_map<(d0) -> (d0)> ],
     iterator_types = ["parallel"],
     fun = @foo
   } %arg0:  memref<f32>
 }
 
 // -----
 
 func @foo(%i: i32, %val: f32) -> (f32) {
   return %val : f32
 }
 func @indexed_generic_fun_induction_var_arg_type(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected fun argument 0 to be of IndexType}}
   linalg.indexed_generic {
     args_in = 0,
     args_out = 1,
     iterator_types = ["parallel"],
-    indexing_maps = [ (i) -> (i) ],
+    indexing_maps = [ affine_map<(i) -> (i)> ],
     fun = @foo
   } %arg0 : memref<f32>
 }
 
 // -----
 
 func @foo(%i: index, %val: i1) -> (i1) {
   return %val : i1
 }
 func @indexed_generic_fun_arg_type(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected fun argument 1 of the same type as elemental type 'f32' of view 0}}
   linalg.indexed_generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps =  [ (d0) -> (d0) ],
+    indexing_maps =  [ affine_map<(d0) -> (d0)> ],
     iterator_types = ["parallel"],
     fun = @foo
   } %arg0: memref<f32>
 }
 
 // -----
 
 func @foo(%i: index, %val: i1) -> (i1, i1) {
   return %val, %val : i1, i1
 }
 func @indexed_generic_fun_result_count(%arg0: memref<f32>) {
   // expected-error @+1 {{op expected fun results to match number of output views}}
   linalg.indexed_generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps =  [ (d0) -> (d0) ],
+    indexing_maps =  [ affine_map<(d0) -> (d0)> ],
     iterator_types = ["parallel"],
     fun = @foo
   } %arg0: memref<f32>
 }
 
 // -----
 
 func @foo(%i: index, %val: i32) -> (f32) {
   %val_float = sitofp %val : i32 to f32
   return %val_float : f32
 }
 func @indexed_generic_fun_result_count(%arg0: memref<i32>) {
   // expected-error @+1 {{op expected fun result 0 of the same type as elemental type 'i32' of view 0}}
   linalg.indexed_generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps =  [ (d0) -> (d0) ],
+    indexing_maps =  [ affine_map<(d0) -> (d0)> ],
     iterator_types = ["parallel"],
     fun = @foo
   } %arg0: memref<i32>
 }
 
 // -----
 
-func @generic_fun_result_0_element_type(%arg0: memref<?xf32, (i)[off]->(off + i)>) {
+func @generic_fun_result_0_element_type(%arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
   // expected-error @+9 {{type of return operand 0 ('i1') doesn't match view element type ('f32')}}
   linalg.generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps = [ (i) -> (i) ],
+    indexing_maps = [ affine_map<(i) -> (i)> ],
     iterator_types = ["parallel"]
   } %arg0 {
     ^bb(%i: f32):
       %0 = constant 0: i1
       linalg.yield %0: i1
-  }: memref<?xf32, (i)[off]->(off + i)>
+  }: memref<?xf32, affine_map<(i)[off]->(off + i)>>
 }
 
 // -----
 
-func @generic_result_tensor_type(%arg0: memref<?xf32, (i)[off]->(off + i)>) {
+func @generic_result_tensor_type(%arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
   // expected-error @+1 {{op result #0 must be ranked tensor of any type values, but got 'f32'}}
   %0 = linalg.generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps = [ (i) -> (i) ],
+    indexing_maps = [ affine_map<(i) -> (i)> ],
     iterator_types = ["parallel"]
   } %arg0 {
     ^bb(%i: f32):
       linalg.yield %i: f32
-  }: memref<?xf32, (i)[off]->(off + i)> -> f32
+  }: memref<?xf32, affine_map<(i)[off]->(off + i)>> -> f32
 }
 
 // -----
 
-func @generic_result_tensor_count(%arg0: memref<?xf32, (i)[off]->(off + i)>) {
+func @generic_result_tensor_count(%arg0: memref<?xf32, affine_map<(i)[off]->(off + i)>>) {
   // expected-error @+1 {{op expected #output tensor operands (0) to match #results (1)}}
   %0 = linalg.generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps = [ (i) -> (i) ],
+    indexing_maps = [ affine_map<(i) -> (i)> ],
     iterator_types = ["parallel"]
   } %arg0 {
     ^bb(%i: f32):
       linalg.yield %i: f32
-  }: memref<?xf32, (i)[off]->(off + i)> -> tensor<?xf32>
+  }: memref<?xf32, affine_map<(i)[off]->(off + i)>> -> tensor<?xf32>
 }
 
 // -----
 
 func @generic_result_tensor_type(%arg0: tensor<?xf32>) {
   // expected-error @+1 {{op result #0 must be 'tensor<?xf32>', but got 'tensor<?x?xf32>'}}
   %0 = linalg.generic {
     args_in = 0,
     args_out = 1,
-    indexing_maps = [ (i) -> (i) ],
+    indexing_maps = [ affine_map<(i) -> (i)> ],
     iterator_types = ["parallel"]
   } %arg0 {
     ^bb(%i: f32):
       linalg.yield %i: f32
   }: tensor<?xf32> -> tensor<?x?xf32>
 }
 
 // -----

 
 // expected-error @+1 {{expected valid keyword}}
 !invalid_type = type !linalg<"?">
 
 // -----
 
 func @reshape(%arg0: memref<f32>) {
   // expected-error @+1 {{expected non-zero memref ranks}}
-  %0 = linalg.reshape %arg0 [()->(0)] : memref<f32> into memref<f32>
+  %0 = linalg.reshape %arg0 [affine_map<()->(0)>] : memref<f32> into memref<f32>
 }
 
 // -----
 
 func @reshape(%arg0: memref<?xf32>) {
   // expected-error @+1 {{expected to collapse or expand dims}}
-  %0 = linalg.reshape %arg0 [(i)->(i)] : memref<?xf32> into memref<?xf32>
+  %0 = linalg.reshape %arg0 [affine_map<(i)->(i)>] : memref<?xf32> into memref<?xf32>
 }
 
 // -----
 
 func @reshape(%arg0: memref<?x?x?xf32>) {
   // expected-error @+1 {{expected rank of the collapsed view(2) to be the number of reassociation maps(1)}}
-  %0 = linalg.reshape %arg0 [(i, j, k) -> (i, j)] :
+  %0 = linalg.reshape %arg0 [affine_map<(i, j, k) -> (i, j)>] :
     memref<?x?x?xf32> into memref<?x?xf32, offset: 0, strides: [?, 1]>
 }
 
 // -----
 
 func @reshape(%arg0: memref<?x?x?xf32>) {
   // expected-error @+1 {{expected reassociation map #0 of same rank as expanded memref(3), but got 1}}
-  %0 = linalg.reshape %arg0 [(i) -> (i), (i, j, k) -> (k)] :
+  %0 = linalg.reshape %arg0 [affine_map<(i) -> (i)>, affine_map<(i, j, k) -> (k)>] :
     memref<?x?x?xf32> into memref<?x?xf32, offset: 0, strides: [?, 1]>
 }
 
 // -----
 
 func @reshape(%arg0: memref<?x?x?xf32>) {
   // expected-error @+1 {{expected reassociation map #1 to be valid and contiguous}}
-  %0 = linalg.reshape %arg0 [(i, j, k) -> (i, j), (i, j, k) -> (k, j)] :
+  %0 = linalg.reshape %arg0 [affine_map<(i, j, k) -> (i, j)>, affine_map<(i, j, k) -> (k, j)>] :
     memref<?x?x?xf32> into memref<?x?xf32, offset: 0, strides: [?, 1]>
 }
 
 // -----
 
 func @reshape(%arg0: memref<?x?x?xf32>) {
-  // expected-error @+1 {{expected collapsed type to be 'memref<?x?xf32>', but got 'memref<?x?xf32, (d0, d1)[s0] -> (d0 * s0 + d1)>'}}
-  %0 = linalg.reshape %arg0 [(i, j, k) -> (i, j), (i, j, k) -> (k)] :
-    memref<?x?x?xf32> into memref<?x?xf32, (d0, d1)[s0] -> (d0 * s0 + d1)>
+  // expected-error @+1 {{expected collapsed type to be 'memref<?x?xf32>', but got 'memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * s0 + d1)>>'}}
+  %0 = linalg.reshape %arg0 [affine_map<(i, j, k) -> (i, j)>, affine_map<(i, j, k) -> (k)>] :
+    memref<?x?x?xf32> into memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * s0 + d1)>>
 }

mlir/test/Dialect/Linalg/llvm.mlir

 //       CHECK:   llvm.extractvalue {{.*}}[3, 0] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 //       CHECK:    llvm.insertvalue {{.*}}[3, 2] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 //       CHECK:   llvm.extractvalue {{.*}}[3, 1] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 //       CHECK:    llvm.insertvalue {{.*}}[3, 0] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 //       CHECK:   llvm.extractvalue {{.*}}[3, 2] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 //       CHECK:    llvm.insertvalue {{.*}}[3, 1] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 
 func @copy_transpose(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
-  linalg.copy(%arg0, %arg1) {inputPermutation = (i, j, k) -> (i, k, j),
-                             outputPermutation = (i, j, k) -> (k, j, i)}
+  linalg.copy(%arg0, %arg1) {inputPermutation = affine_map<(i, j, k) -> (i, k, j)>,
+                             outputPermutation = affine_map<(i, j, k) -> (k, j, i)>}
     : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
   return
 }
 // CHECK-LABEL: func @copy
 // Transpose input
 //         CHECK:   llvm.insertvalue {{.*}}[0] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 //         CHECK:    llvm.insertvalue {{.*}}[1] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 //         CHECK:    llvm.insertvalue {{.*}}[2] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">

 //         CHECK:    llvm.insertvalue {{.*}}[3, 1] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 //         CHECK:   llvm.extractvalue {{.*}}[3, 2] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 //         CHECK:    llvm.insertvalue {{.*}}[3, 0] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 // Call external copy after promoting input and output structs to pointers
 // CHECK-COUNT-2:   llvm.mlir.constant(1 : index){{.*[[:space:]].*}}llvm.alloca{{.*[[:space:]].*}}llvm.store
 //         CHECK:   llvm.call @linalg_copy_viewsxsxsxf32_viewsxsxsxf32(%{{.*}}, %{{.*}}) : (!llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }*">, !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }*">) -> ()
 
 #matmul_accesses = [
-  (m, n, k) -> (m, k),
-  (m, n, k) -> (k, n),
-  (m, n, k) -> (m, n)
+  affine_map<(m, n, k) -> (m, k)>,
+  affine_map<(m, n, k) -> (k, n)>,
+  affine_map<(m, n, k) -> (m, n)>
 ]
 #matmul_trait = {
   args_in = 2,
   args_out = 1,
   iterator_types = ["parallel", "parallel", "reduction"],
   indexing_maps = #matmul_accesses,
   library_call = "external_outerproduct_matmul"
 }
func @matmul_vec_indexed(%A: !matrix_type_A,
   return
 }
 // CHECK-LABEL: func @matmul_vec_indexed(
 //   CHECK: %[[ZERO:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64
 //   CHECK: llvm.call @external_indexed_outerproduct_matmul(%[[ZERO]], %[[ZERO]], %[[ZERO]], %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.i64, !llvm.i64, !llvm.i64, !llvm<"{ <4 x float>*, <4 x float>*, i64, [2 x i64], [2 x i64] }*">, !llvm<"{ <4 x float>*, <4 x float>*, i64, [2 x i64], [2 x i64] }*">, !llvm<"{ [4 x <4 x float>]*, [4 x <4 x float>]*, i64, [2 x i64], [2 x i64] }*">) -> ()
 
 func @reshape_static(%arg0: memref<3x4x5xf32>) {
   // Reshapes that expand and collapse back a contiguous tensor with some 1's.
-  %0 = linalg.reshape %arg0 [(i, j, k, l, m) -> (i, j),
-                             (i, j, k, l, m) -> (k),
-                             (i, j, k, l, m) -> (l, m)] :
+  %0 = linalg.reshape %arg0 [affine_map<(i, j, k, l, m) -> (i, j)>,
+                             affine_map<(i, j, k, l, m) -> (k)>,
+                             affine_map<(i, j, k, l, m) -> (l, m)>] :
     memref<3x4x5xf32> into memref<1x3x4x1x5xf32>
-  %r0 = linalg.reshape %0 [(i, j, k, l, m) -> (i, j),
-                           (i, j, k, l, m) -> (k),
-                           (i, j, k, l, m) -> (l, m)] :
+  %r0 = linalg.reshape %0 [affine_map<(i, j, k, l, m) -> (i, j)>,
+                           affine_map<(i, j, k, l, m) -> (k)>,
+                           affine_map<(i, j, k, l, m) -> (l, m)>] :
     memref<1x3x4x1x5xf32> into memref<3x4x5xf32>
   return
 }
 // CHECK-LABEL: func @reshape_static(
 //       CHECK: llvm.mlir.undef : !llvm<"{ float*, float*, i64, [5 x i64], [5 x i64] }">
 //       CHECK: llvm.extractvalue {{.*}}[0] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
 //       CHECK: llvm.insertvalue {{.*}}[0] : !llvm<"{ float*, float*, i64, [5 x i64], [5 x i64] }">
 //       CHECK: llvm.extractvalue {{.*}}[1] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">

mlir/test/Dialect/Linalg/loops.mlir

 // RUN: mlir-opt %s -convert-linalg-to-loops | FileCheck %s
 
 // Test that we can lower all the way to LLVM without crashing, don't check results here.
 // RUN: mlir-opt %s --convert-linalg-to-llvm -o=/dev/null 2>&1
 
-// CHECK-DAG: #[[strided1D:.*]] = (d0)[s0] -> (d0 + s0)
-// CHECK-DAG: #[[strided2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
-// CHECK-DAG: #[[strided3D:.*]] = (d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)
-// CHECK-DAG: #[[strided4D:.*]] = (d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)
-
-// CHECK-DAG: #[[Stride2Dilation1:.*]] = (d0, d1) -> (d0 * 2 + d1)
-// CHECK-DAG: #[[Stride2Dilation4:.*]] = (d0, d1) -> (d0 * 2 + d1 * 4)
-// CHECK-DAG: #[[Stride3Dilation5:.*]] = (d0, d1) -> (d0 * 3 + d1 * 5)
+// CHECK-DAG: #[[strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
+// CHECK-DAG: #[[strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+// CHECK-DAG: #[[strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
+// CHECK-DAG: #[[strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
+
+// CHECK-DAG: #[[Stride2Dilation1:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1)>
+// CHECK-DAG: #[[Stride2Dilation4:.*]] = affine_map<(d0, d1) -> (d0 * 2 + d1 * 4)>
+// CHECK-DAG: #[[Stride3Dilation5:.*]] = affine_map<(d0, d1) -> (d0 * 3 + d1 * 5)>
 
 
 func @matmul(%arg0: memref<?xi8>, %M: index, %N: index, %K: index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %A = view %arg0[%c0][%M, %K] : memref<?xi8> to memref<?x?xf32, offset: ?, strides: [?, 1]>
   %B = view %arg0[%c0][%K, %N] : memref<?xi8> to memref<?x?xf32, offset: ?, strides: [?, 1]>
   %C = view %arg0[%c0][%M, %N] : memref<?xi8> to memref<?x?xf32, offset: ?, strides: [?, 1]>
func @copy_view0(%arg0: memref<f32>, %arg1: memref<f32>) {
   linalg.copy(%arg0, %arg1) : memref<f32>, memref<f32>
   return
 }
 // CHECK-LABEL: func @copy_view0(%{{.*}}: memref<f32>, %{{.*}}: memref<f32>) {
 //       CHECK:   %{{.*}} = load %{{.*}}[] : memref<f32>
 //       CHECK:   store %{{.*}}, %{{.*}}[] : memref<f32>
 
 func @copy_view3(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
-  linalg.copy(%arg0, %arg1) {inputPermutation = (i, j, k) -> (i, k, j),
-                             outputPermutation = (i, j, k) -> (k, j, i)} :
+  linalg.copy(%arg0, %arg1) {inputPermutation = affine_map<(i, j, k) -> (i, k, j)>,
+                             outputPermutation = affine_map<(i, j, k) -> (k, j, i)>} :
     memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
   return
 }
 // CHECK-LABEL: func @copy_view3
 //       CHECK: (%{{.*}}: memref<?x?x?xf32, #[[strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[strided3D]]>) {
 //       CHECK:   loop.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //       CHECK:     loop.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
 //       CHECK:       loop.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {

 //       CHECK:                 %{{.*}} = addf %{{.*}}, %{{.*}} : f32
 //       CHECK:                 store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?x?xf32, #[[strided4D]]>
 
 func @foo(%0: f32, %1: f32, %2: f32) -> (f32, f32) {
   %f0 = constant 0.0 : f32
   return %f0, %f0 : f32, f32
 }
 #accesses = [
-  (i, j, k) -> (i, j),
-  (i, j, k) -> (i, j, k),
-  (i, j, k) -> (i, k, j)
+  affine_map<(i, j, k) -> (i, j)>,
+  affine_map<(i, j, k) -> (i, j, k)>,
+  affine_map<(i, j, k) -> (i, k, j)>
 ]
 #trait = {
   args_in = 1,
   args_out = 2,
   iterator_types = ["parallel", "parallel", "parallel"],
   indexing_maps = #accesses,
   fun = @foo,
   library_call = "some_external_function_name_1",

mlir/test/Dialect/Linalg/promote.mlir

 // RUN: mlir-opt %s -linalg-promote-subviews | FileCheck %s
 // RUN: mlir-opt %s -linalg-promote-subviews -test-linalg-promote-dynamic | FileCheck %s --check-prefix=DYNAMIC
 
-#map0 = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
-#map1 = (d0) -> (d0 + 2)
-#map2 = (d0) -> (d0 + 4)
-#map3 = (d0) -> (d0 + 3)
+#map0 = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+#map1 = affine_map<(d0) -> (d0 + 2)>
+#map2 = affine_map<(d0) -> (d0 + 4)>
+#map3 = affine_map<(d0) -> (d0 + 3)>
 
-// CHECK-DAG: #[[strided2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
-// CHECK-DAG: #[[strided2DnoOffset:.*]] = (d0, d1)[s0] -> (d0 * s0 + d1)
-// CHECK-DAG: #[[strided2D_dynamic:.*]] = (d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)
+// CHECK-DAG: #[[strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+// CHECK-DAG: #[[strided2DnoOffset:.*]] = affine_map<(d0, d1)[s0] -> (d0 * s0 + d1)>
+// CHECK-DAG: #[[strided2D_dynamic:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
 
 module {
   func @matmul(%A: memref<?xi8>, %M: index, %N: index, %K: index) {
     %c4 = constant 4 : index
     %c3 = constant 3 : index
     %c2 = constant 2 : index
     %c0 = constant 0 : index
     %c1 = constant 1 : index

mlir/test/Dialect/Linalg/roundtrip.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
 // TODO(pifon): Re-enable LLVM lowering test after IndexedGenericOp is lowered.
 //
 // Test that we can lower all the way to LLVM without crashing, don't check results here.
 // DISABLED: mlir-opt %s --convert-linalg-to-llvm -o=/dev/null 2>&1
 
-// CHECK-DAG: #[[strided1D:.*]] = (d0)[s0] -> (d0 + s0)
-// CHECK-DAG: #[[strided2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
-// CHECK-DAG: #[[strided2DOFF0:.*]] = (d0, d1)[s0] -> (d0 * s0 + d1)
-// CHECK-DAG: #[[strided3D:.*]] = (d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)
-// CHECK-DAG: #[[strided3DOFF0:.*]] = (d0, d1, d2)[s0, s1] -> (d0 * s0 + d1 * s1 + d2)
-// CHECK-DAG: #[[strided6D:.*]] = (d0, d1, d2, d3, d4, d5)[s0, s1, s2, s3, s4, s5] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4 + d4 * s5 + d5)
-
-// CHECK-DAG: #[[map0:.*]] = (d0, d1, d2) -> (d0, d2, d1)
-// CHECK-DAG: #[[map1:.*]] = (d0, d1, d2) -> (d2, d1, d0)
-
-// CHECK-DAG: #[[reshapeD01:.*]] = (d0, d1, d2) -> (d0, d1)
-// CHECK-DAG: #[[reshapeD2:.*]] = (d0, d1, d2) -> (d2)
-// CHECK-DAG: #[[reshapeD0:.*]] = (d0, d1, d2) -> (d0)
-// CHECK-DAG: #[[reshapeD12:.*]] = (d0, d1, d2) -> (d1, d2)
-// CHECK-DAG: #[[reshapeD012:.*]] = (d0, d1, d2) -> (d0, d1, d2)
-// CHECK-DAG: #[[reshape5D01:.*]] = (d0, d1, d2, d3, d4) -> (d0, d1)
-// CHECK-DAG: #[[reshape5D2:.*]] = (d0, d1, d2, d3, d4) -> (d2)
-// CHECK-DAG: #[[reshape5D34:.*]] = (d0, d1, d2, d3, d4) -> (d3, d4)
+// CHECK-DAG: #[[strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
+// CHECK-DAG: #[[strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+// CHECK-DAG: #[[strided2DOFF0:.*]] = affine_map<(d0, d1)[s0] -> (d0 * s0 + d1)>
+// CHECK-DAG: #[[strided3D:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
+// CHECK-DAG: #[[strided3DOFF0:.*]] = affine_map<(d0, d1, d2)[s0, s1] -> (d0 * s0 + d1 * s1 + d2)>
+// CHECK-DAG: #[[strided6D:.*]] = affine_map<(d0, d1, d2, d3, d4, d5)[s0, s1, s2, s3, s4, s5] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4 + d4 * s5 + d5)>
+
+// CHECK-DAG: #[[map0:.*]] = affine_map<(d0, d1, d2) -> (d0, d2, d1)>
+// CHECK-DAG: #[[map1:.*]] = affine_map<(d0, d1, d2) -> (d2, d1, d0)>
+
+// CHECK-DAG: #[[reshapeD01:.*]] = affine_map<(d0, d1, d2) -> (d0, d1)>
+// CHECK-DAG: #[[reshapeD2:.*]] = affine_map<(d0, d1, d2) -> (d2)>
+// CHECK-DAG: #[[reshapeD0:.*]] = affine_map<(d0, d1, d2) -> (d0)>
+// CHECK-DAG: #[[reshapeD12:.*]] = affine_map<(d0, d1, d2) -> (d1, d2)>
+// CHECK-DAG: #[[reshapeD012:.*]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
+// CHECK-DAG: #[[reshape5D01:.*]] = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1)>
+// CHECK-DAG: #[[reshape5D2:.*]] = affine_map<(d0, d1, d2, d3, d4) -> (d2)>
+// CHECK-DAG: #[[reshape5D34:.*]] = affine_map<(d0, d1, d2, d3, d4) -> (d3, d4)>
 
 func @range(%arg0: index, %arg1: index, %arg2: index) {
   %0 = linalg.range %arg0:%arg1:%arg2 : !linalg.range
   return
 }
 // CHECK-LABEL: func @range(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 //  CHECK-NEXT:  linalg.range %{{.*}}:%{{.*}}:%{{.*}} : !linalg.range
 
func @copy_view(%arg0: memref<?xf32, offset: ?, strides: [1]>, %arg1: memref<?xf32, offset: ?, strides: [1]>) {
   linalg.copy(%arg0, %arg1) : memref<?xf32, offset: ?, strides: [1]>, memref<?xf32, offset: ?, strides: [1]>
   return
 }
 // CHECK-LABEL: func @copy_view(
 //       CHECK:  %{{.*}}: memref<?xf32, #[[strided1D]]>, %{{.*}}: memref<?xf32, #[[strided1D]]>) {
 //       CHECK:   linalg.copy(%{{.*}}, %{{.*}}) : memref<?xf32, #[[strided1D]]>, memref<?xf32, #[[strided1D]]>
 
 func @copy_view3(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
-  linalg.copy(%arg0, %arg1) {inputPermutation = (i, j, k) -> (i, k, j),
-                             outputPermutation = (i, j, k) -> (k, j, i)} :
+  linalg.copy(%arg0, %arg1) {inputPermutation = affine_map<(i, j, k) -> (i, k, j)>,
+                             outputPermutation = affine_map<(i, j, k) -> (k, j, i)>} :
     memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
   return
 }
 // CHECK-LABEL: func @copy_view3(
 //       CHECK:  %{{.*}}: memref<?x?x?xf32, #[[strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[strided3D]]>) {
 //       CHECK:   linalg.copy(%{{.*}}, %{{.*}}) {inputPermutation = #[[map0]], outputPermutation = #[[map1]]} : memref<?x?x?xf32, #[[strided3D]]>, memref<?x?x?xf32, #[[strided3D]]>
 
 func @conv_view3(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg1: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, %arg2: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
   linalg.conv(%arg0, %arg1, %arg2) : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>, memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>
   return
 }
 // CHECK-LABEL: func @conv_view3(
 //       CHECK:  %{{.*}}: memref<?x?x?xf32, #[[strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[strided3D]]>, %{{.*}}: memref<?x?x?xf32, #[[strided3D]]>) {
 //       CHECK:   linalg.conv(%{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?x?xf32, #[[strided3D]]>, memref<?x?x?xf32, #[[strided3D]]>, memref<?x?x?xf32, #[[strided3D]]>
 
 func @conv_view6(%arg0: memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>, %arg1: memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>, %arg2: memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>) {
   linalg.conv(%arg0, %arg1, %arg2) {dilations = [4, 4, 5, 5], strides = [2, 2, 3, 3]} : memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>, memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>, memref<?x?x?x?x?x?xf32, offset: ?, strides: [?, ?, ?, ?, ?, 1]>
   return
 }
 // CHECK-LABEL: func @conv_view6(
 //       CHECK:  %{{.*}}: memref<?x?x?x?x?x?xf32, #[[strided6D]]>, %{{.*}}: memref<?x?x?x?x?x?xf32, #[[strided6D]]>, %{{.*}}: memref<?x?x?x?x?x?xf32, #[[strided6D]]>) {
 //       CHECK:   linalg.conv(%{{.*}}, %{{.*}}, %{{.*}}) {dilations = [4, 4, 5, 5], strides = [2, 2, 3, 3]} : memref<?x?x?x?x?x?xf32, #[[strided6D]]>, memref<?x?x?x?x?x?xf32, #[[strided6D]]>, memref<?x?x?x?x?x?xf32, #[[strided6D]]>
 
 #accesses = [
-  (i, j, k) -> (j, i),
-  (i, j, k) -> (i, k, i + j)
+  affine_map<(i, j, k) -> (j, i)>,
+  affine_map<(i, j, k) -> (i, k, i + j)>
 ]
 #trait = {
   args_in = 1,
   args_out = 1,
   indexing_maps = #accesses,
   iterator_types = ["parallel", "parallel", "parallel"],
   fun = @foo,
   library_call = "some_external_function_name_1"

 // CHECK-LABEL: func @indexed_generic
 //       CHECK:   linalg.indexed_generic {args_in = 1 : i64, args_out = 1 : i64, indexing_maps = [#{{.*}}, #{{.*}}],  iterator_types = ["parallel", "parallel", "parallel"], library_call = "some_external_function_name_2"} %{{.*}}, %{{.*}} {
 //       CHECK:    ^{{.*}}(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: vector<3x4xi4>, %{{.*}}: f32):
 //       CHECK:      linalg.yield %{{.*}} : f32
 //       CHECK:    } {foo = 1 : i64}: memref<?x?xvector<3x4xi4>, #[[strided2D]]>, memref<?x?x?xf32, #[[strided3D]]>
 
 func @reshape_static(%arg0: memref<3x4x5xf32>) {
   // Reshapes that collapse and expand back a contiguous tensor.
-  %0 = linalg.reshape %arg0 [(i, j, k) -> (i, j),
-                             (i, j, k) -> (k)] :
+  %0 = linalg.reshape %arg0 [affine_map<(i, j, k) -> (i, j)>,
+                             affine_map<(i, j, k) -> (k)>] :
     memref<3x4x5xf32> into memref<12x5xf32>
-  %r0 = linalg.reshape %0 [(i, j, k) -> (i, j),
-                           (i, j, k) -> (k)] :
+  %r0 = linalg.reshape %0 [affine_map<(i, j, k) -> (i, j)>,
+                           affine_map<(i, j, k) -> (k)>] :
     memref<12x5xf32> into memref<3x4x5xf32>
-  %1 = linalg.reshape %arg0 [(i, j, k) -> (i),
-                             (i, j, k) -> (j, k)] :
+  %1 = linalg.reshape %arg0 [affine_map<(i, j, k) -> (i)>,
+                             affine_map<(i, j, k) -> (j, k)>] :
     memref<3x4x5xf32> into memref<3x20xf32>
-  %r1 = linalg.reshape %1 [(i, j, k) -> (i),
-                           (i, j, k) -> (j, k)] :
+  %r1 = linalg.reshape %1 [affine_map<(i, j, k) -> (i)>,
+                           affine_map<(i, j, k) -> (j, k)>] :
     memref<3x20xf32> into memref<3x4x5xf32>
-  %2 = linalg.reshape %arg0 [(i, j, k) -> (i, j, k)] :
+  %2 = linalg.reshape %arg0 [affine_map<(i, j, k) -> (i, j, k)>] :
     memref<3x4x5xf32> into memref<60xf32>
-  %r2 = linalg.reshape %2 [(i, j, k) -> (i, j, k)] :
+  %r2 = linalg.reshape %2 [affine_map<(i, j, k) -> (i, j, k)>] :
     memref<60xf32> into memref<3x4x5xf32>
   // Reshapes that expand and collapse back a contiguous tensor with some 1's.
-  %3 = linalg.reshape %arg0 [(i, j, k, l, m) -> (i, j),
-                             (i, j, k, l, m) -> (k),
-                             (i, j, k, l, m) -> (l, m)] :
+  %3 = linalg.reshape %arg0 [affine_map<(i, j, k, l, m) -> (i, j)>,
+                             affine_map<(i, j, k, l, m) -> (k)>,
+                             affine_map<(i, j, k, l, m) -> (l, m)>] :
     memref<3x4x5xf32> into memref<1x3x4x1x5xf32>
-  %r3 = linalg.reshape %3 [(i, j, k, l, m) -> (i, j),
-                           (i, j, k, l, m) -> (k),
-                           (i, j, k, l, m) -> (l, m)] :
+  %r3 = linalg.reshape %3 [affine_map<(i, j, k, l, m) -> (i, j)>,
+                           affine_map<(i, j, k, l, m) -> (k)>,
+                           affine_map<(i, j, k, l, m) -> (l, m)>] :
     memref<1x3x4x1x5xf32> into memref<3x4x5xf32>
   return
 }
 // CHECK-LABEL: func @reshape_static
 //       CHECK:   linalg.reshape {{.*}} [#[[reshapeD01]], #[[reshapeD2]]]
 //  CHECK-SAME:     memref<3x4x5xf32> into memref<12x5xf32>
 //       CHECK:   linalg.reshape {{.*}} [#[[reshapeD01]], #[[reshapeD2]]]
 //  CHECK-SAME:     memref<12x5xf32> into memref<3x4x5xf32>
 //       CHECK:   linalg.reshape {{.*}} [#[[reshapeD0]], #[[reshapeD12]]]
 //  CHECK-SAME:     memref<3x4x5xf32> into memref<3x20xf32>
 //       CHECK:   linalg.reshape {{.*}} [#[[reshapeD0]], #[[reshapeD12]]]
 //  CHECK-SAME:     memref<3x20xf32> into memref<3x4x5xf32>
 //       CHECK:   linalg.reshape {{.*}} [#[[reshapeD012]]]
 //  CHECK-SAME:     memref<3x4x5xf32> into memref<60xf32>
 //       CHECK:   linalg.reshape {{.*}} [#[[reshapeD012]]]
 //  CHECK-SAME:     memref<60xf32> into memref<3x4x5xf32>
 //       CHECK:   linalg.reshape {{.*}} [#[[reshape5D01]], #[[reshape5D2]], #[[reshape5D34]]]
 //  CHECK-SAME:     memref<3x4x5xf32> into memref<1x3x4x1x5xf32>
 //       CHECK:   linalg.reshape {{.*}} [#[[reshape5D01]], #[[reshape5D2]], #[[reshape5D34]]]
 //  CHECK-SAME:     memref<1x3x4x1x5xf32> into memref<3x4x5xf32>
 
 func @reshape_dynamic(%arg0: memref<?x?x?xf32>,
                       %arg1: memref<?x?x?xf32, offset : 0, strides : [?, ?, 1]>,
                       %arg2: memref<?x?x?xf32, offset : ?, strides : [?, ?, 1]>) {
-  %0 = linalg.reshape %arg0 [(i, j, k) -> (i, j),
-                             (i, j, k) -> (k)] :
+  %0 = linalg.reshape %arg0 [affine_map<(i, j, k) -> (i, j)>,
+                             affine_map<(i, j, k) -> (k)>] :
     memref<?x?x?xf32> into memref<?x?xf32>
-  %r0 = linalg.reshape %0 [(i, j, k) -> (i, j),
-                           (i, j, k) -> (k)] :
+  %r0 = linalg.reshape %0 [affine_map<(i, j, k) -> (i, j)>,
+                           affine_map<(i, j, k) -> (k)>] :
     memref<?x?xf32> into memref<?x?x?xf32>
-  %1 = linalg.reshape %arg1 [(i, j, k) -> (i, j),
-                             (i, j, k) -> (k)] :
+  %1 = linalg.reshape %arg1 [affine_map<(i, j, k) -> (i, j)>,
+                             affine_map<(i, j, k) -> (k)>] :
     memref<?x?x?xf32, offset : 0, strides : [?, ?, 1]> into
     memref<?x?xf32, offset : 0, strides : [?, 1]>
-  %r1 = linalg.reshape %1 [(i, j, k) -> (i, j),
-                           (i, j, k) -> (k)] :
+  %r1 = linalg.reshape %1 [affine_map<(i, j, k) -> (i, j)>,
+                           affine_map<(i, j, k) -> (k)>] :
     memref<?x?xf32, offset : 0, strides : [?, 1]> into
     memref<?x?x?xf32, offset : 0, strides : [?, ?, 1]>
-  %2 = linalg.reshape %arg2 [(i, j, k) -> (i, j),
-                             (i, j, k) -> (k)] :
+  %2 = linalg.reshape %arg2 [affine_map<(i, j, k) -> (i, j)>,
+                             affine_map<(i, j, k) -> (k)>] :
     memref<?x?x?xf32, offset : ?, strides : [?, ?, 1]> into
     memref<?x?xf32, offset : ?, strides : [?, 1]>
-  %r2 = linalg.reshape %2 [(i, j, k) -> (i, j),
-                           (i, j, k) -> (k)] :
+  %r2 = linalg.reshape %2 [affine_map<(i, j, k) -> (i, j)>,
+                           affine_map<(i, j, k) -> (k)>] :
     memref<?x?xf32, offset : ?, strides : [?, 1]> into
     memref<?x?x?xf32, offset : ?, strides : [?, ?, 1]>
   return
 }
 // CHECK-LABEL: func @reshape
 //       CHECK:   linalg.reshape {{.*}} [#[[reshapeD01]], #[[reshapeD2]]]
 //  CHECK-SAME:     memref<?x?x?xf32> into memref<?x?xf32>
 //       CHECK:   linalg.reshape {{.*}} [#[[reshapeD01]], #[[reshapeD2]]]

mlir/test/Dialect/Linalg/tile.mlir

 // RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=2 | FileCheck %s -check-prefix=TILE-2
 // RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=0,2 | FileCheck %s -check-prefix=TILE-02
 // RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=0,0,2 | FileCheck %s -check-prefix=TILE-002
 // RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=2,3,4 | FileCheck %s -check-prefix=TILE-234
 
-//   TILE-2-DAG: #[[strided1D:.*]] = (d0)[s0] -> (d0 + s0)
-//  TILE-02-DAG: #[[strided1D:.*]] = (d0)[s0] -> (d0 + s0)
-// TILE-002-DAG: #[[strided1D:.*]] = (d0)[s0] -> (d0 + s0)
-// TILE-234-DAG: #[[strided1D:.*]] = (d0)[s0] -> (d0 + s0)
-
-//   TILE-2-DAG: #[[strided2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
-//  TILE-02-DAG: #[[strided2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
-// TILE-002-DAG: #[[strided2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
-// TILE-234-DAG: #[[strided2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
-
-//   TILE-2-DAG: #[[strided1D_dynamic:.*]] = (d0)[s0, s1] -> (d0 * s1 + s0)
-//   TILE-02-DAG: #[[strided1D_dynamic:.*]] = (d0)[s0, s1] -> (d0 * s1 + s0)
-//   T_ILE-002-DAG: #[[strided1D_dynamic:.*]] = (d0)[s0, s1] -> (d0 * s1 + s0)
-//   TILE-234-DAG: #[[strided1D_dynamic:.*]] = (d0)[s0, s1] -> (d0 * s1 + s0)
-
-//   TILE-2-DAG: #[[strided2D_dynamic:.*]] = (d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)
-//   TILE-02-DAG: #[[strided2D_dynamic:.*]] = (d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)
-//   TILE-002-DAG: #[[strided2D_dynamic:.*]] = (d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)
-//   TILE-234-DAG: #[[strided2D_dynamic:.*]] = (d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)
-
-//   REACTIVATE_ME_TILE-2-DAG: #[[stride_99_1_layout_map:.*]] = (d0, d1)[s0] -> (d0 * 99 + s0 + d1)
-//  REACTIVATE_ME_TILE-02-DAG: #[[stride_99_1_layout_map:.*]] = (d0, d1)[s0] -> (d0 * 99 + s0 + d1)
-// REACTIVATE_ME_TILE-234-DAG: #[[stride_99_1_layout_map:.*]] = (d0, d1)[s0] -> (d0 * 99 + s0 + d1)
+//   TILE-2-DAG: #[[strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
+//  TILE-02-DAG: #[[strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
+// TILE-002-DAG: #[[strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
+// TILE-234-DAG: #[[strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
+
+//   TILE-2-DAG: #[[strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+//  TILE-02-DAG: #[[strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+// TILE-002-DAG: #[[strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+// TILE-234-DAG: #[[strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+
+//   TILE-2-DAG: #[[strided1D_dynamic:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
+//   TILE-02-DAG: #[[strided1D_dynamic:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
+//   T_ILE-002-DAG: #[[strided1D_dynamic:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
+//   TILE-234-DAG: #[[strided1D_dynamic:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
+
+//   TILE-2-DAG: #[[strided2D_dynamic:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
+//   TILE-02-DAG: #[[strided2D_dynamic:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
+//   TILE-002-DAG: #[[strided2D_dynamic:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
+//   TILE-234-DAG: #[[strided2D_dynamic:.*]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
+
+//   REACTIVATE_ME_TILE-2-DAG: #[[stride_99_1_layout_map:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 99 + s0 + d1)>
+//  REACTIVATE_ME_TILE-02-DAG: #[[stride_99_1_layout_map:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 99 + s0 + d1)>
+// REACTIVATE_ME_TILE-234-DAG: #[[stride_99_1_layout_map:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 99 + s0 + d1)>
 
 func @matmul(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>, %arg1: memref<?x?xf32, offset: ?, strides: [?, 1]>, %arg2: memref<?x?xf32, offset: ?, strides: [?, 1]>) {
   linalg.matmul(%arg0, %arg1, %arg2) : memref<?x?xf32, offset: ?, strides: [?, 1]>, memref<?x?xf32, offset: ?, strides: [?, 1]>, memref<?x?xf32, offset: ?, strides: [?, 1]>
   return
 }
 // TILE-2-LABEL: func @matmul(
 //       TILE-2-DAG: %[[C0:.*]] = constant 0 : index
 //       TILE-2-DAG: %[[C1:.*]] = constant 1 : index

 //       TILE-002:     fill{{.*}} f32
 
 // TILE-234-LABEL: func @fill
 //       TILE-234:   for
 //       TILE-234:     for
 //   TILE-234-NOT:   for
 //       TILE-234:       fill{{.*}} f32
 
-#id_2d = (i, j) -> (i, j)
+#id_2d = affine_map<(i, j) -> (i, j)>
 #pointwise_2d_trait = {
   args_in = 2,
   args_out = 1,
   indexing_maps = [#id_2d, #id_2d, #id_2d],
   iterator_types = ["parallel", "parallel"]
 }
 
 func @pointwise(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>, %arg1: memref<?x?xf32, offset: ?, strides: [?, 1]>,

mlir/test/Dialect/Linalg/tile_conv.mlir

 // RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=2,3,0,0,4 | FileCheck %s -check-prefix=TILE-23004
 
-// TILE-23004-DAG: #[[D0x30pS0x10:.*]] = (d0) -> (d0 * 30)
-// TILE-23004-DAG: #[[S0x10p90:.*]] = ()[s0] -> (s0 * 10 + 90)
-// TILE-23004-DAG: #[[strided4D:.*]] = (d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)
-// TILE-23004-DAG: #[[strided4D_dynamic:.*]] = (d0, d1, d2, d3)[s0, s1, s2, s3, s4] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4)
+// TILE-23004-DAG: #[[D0x30pS0x10:.*]] = affine_map<(d0) -> (d0 * 30)>
+// TILE-23004-DAG: #[[S0x10p90:.*]] = affine_map<()[s0] -> (s0 * 10 + 90)>
+// TILE-23004-DAG: #[[strided4D:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3)>
+// TILE-23004-DAG: #[[strided4D_dynamic:.*]] = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3, s4] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3 + d3 * s4)>
 
 func @conv(%arg0: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, %arg1: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, %arg2: memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>) {
   linalg.conv(%arg0, %arg1, %arg2) {dilations = [10, 20], strides = [30, 40]} : memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>, memref<?x?x?x?xf32, offset: ?, strides: [?, ?, ?, 1]>
   return
 }
 // TILE-23004-LABEL: func @conv(
 //       TILE-23004:   %{{.*}}: memref<?x?x?x?xf32, #[[strided4D]]>, %{{.*}}: memref<?x?x?x?xf32, #[[strided4D]]>, %{{.*}}: memref<?x?x?x?xf32, #[[strided4D]]>) {
 //       TILE-23004-DAG: %[[C0:.*]] = constant 0 : index

mlir/test/Dialect/Linalg/tile_indexed_generic.mlir

 // RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=10,25 | FileCheck %s -check-prefix=TILE-10n25
 // RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=25,0 | FileCheck %s -check-prefix=TILE-25n0
 // RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=0,25 | FileCheck %s -check-prefix=TILE-0n25
 
-#id_1d = (i) -> (i)
+#id_1d = affine_map<(i) -> (i)>
 #pointwise_1d_trait = {
   args_in = 1,
   args_out = 1,
   indexing_maps = [#id_1d, #id_1d],
   iterator_types = ["parallel"]
 }
 func @indexed_generic_vector(%operand: memref<50xf32>, %result: memref<50xf32>) {
   linalg.indexed_generic #pointwise_1d_trait %operand, %result {

 // TILE-0n25-LABEL: func @indexed_generic_vector
 // TILE-0n25-NOT: loop.for %[[J:.*]] = {{.*}} step %[[C25]]
 // TILE-0n25: linalg.indexed_generic
 
 #combined_indices_trait = {
   args_in = 1,
   args_out = 1,
   indexing_maps = [
-    (i, j) -> (j, i + j),
-    (i, j) -> (i, j)
+    affine_map<(i, j) -> (j, i + j)>,
+    affine_map<(i, j) -> (i, j)>
   ],
   iterator_types = ["parallel", "parallel"]
 }
 func @indexed_generic_matrix(%operand: memref<50x100xf32>, %result: memref<50x100xf32>) {
   linalg.indexed_generic #combined_indices_trait %operand, %result {
     ^bb0(%i: index, %j: index, %operand_in: f32, %result_in: f32):
       %i_int = index_cast %i: index to i32
       %i_float = sitofp %i_int : i32 to f32

mlir/test/Dialect/Linalg/transform-patterns.mlir

 // RUN: mlir-opt %s -test-linalg-transform-patterns | FileCheck %s
 
-// CHECK-DAG: #[[STRIDED_1D:.*]] = (d0)[s0] -> (d0 + s0)
-// CHECK-DAG: #[[STRIDED_2D:.*]] = (d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)
-// CHECK-DAG: #[[mk:.*]] = (d0, d1, d2) -> (d0, d2)
-// CHECK-DAG: #[[kn:.*]] = (d0, d1, d2) -> (d2, d1)
-// CHECK-DAG: #[[mn:.*]] = (d0, d1, d2) -> (d0, d1)
-// CHECK-DAG: #[[nm:.*]] = (d0, d1, d2) -> (d1, d0)
-// CHECK-DAG: #[[km:.*]] = (d0, d1, d2) -> (d2, d0)
+// CHECK-DAG: #[[STRIDED_1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
+// CHECK-DAG: #[[STRIDED_2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)>
+// CHECK-DAG: #[[mk:.*]] = affine_map<(d0, d1, d2) -> (d0, d2)>
+// CHECK-DAG: #[[kn:.*]] = affine_map<(d0, d1, d2) -> (d2, d1)>
+// CHECK-DAG: #[[mn:.*]] = affine_map<(d0, d1, d2) -> (d0, d1)>
+// CHECK-DAG: #[[nm:.*]] = affine_map<(d0, d1, d2) -> (d1, d0)>
+// CHECK-DAG: #[[km:.*]] = affine_map<(d0, d1, d2) -> (d2, d0)>
 
 func @dot(%x: memref<?xf32, offset: ?, strides: [1]>,
           %y: memref<?xf32, offset: ?, strides: [1]>,
           %v: memref<f32>) {
   linalg.dot(%x, %y, %v) : memref<?xf32, offset: ?, strides: [1]>,
                            memref<?xf32, offset: ?, strides: [1]>,
                            memref<f32>
   return

 // CHECK      :                       loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c3]] {
 // CHECK      :                         loop.for {{.*}} = %[[c0]] to {{.*}} step %[[c4]] {
 // CHECK      :                           linalg.matmul({{.*}}, {{.*}}, {{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
 
 #some_generic_trait = {
   args_in = 1,
   args_out = 1,
   indexing_maps = [
-    (i, j) -> (i, j),
-    (i, j) -> (i, j)
+    affine_map<(i, j) -> (i, j)>,
+    affine_map<(i, j) -> (i, j)>
   ],
   iterator_types = ["parallel", "parallel"]
 }
 func @fusion_test(%A: memref<?x?xf32, offset: ?, strides: [?, 1]>,
                   %B: memref<?x?xf32, offset: ?, strides: [?, 1]>,
                   %C: memref<?x?xf32, offset: ?, strides: [?, 1]>,
                   %D: memref<?x?xf32, offset: ?, strides: [?, 1]>,
                   %E: memref<?x?xf32, offset: ?, strides: [?, 1]>) {

 // CHECK      :         loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c3]] {
 // CHECK      :           loop.for %{{.*}} = %[[c0]] to %{{.*}} step %[[c4]] {
 // CHECK      :             linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>, memref<?x?xf32, #[[STRIDED_2D]]>
 
 #matmul_trait = {
   args_in = 2,
   args_out = 1,
   indexing_maps = [
-    (m, n, k) -> (m, k),
-    (m, n, k) -> (k, n),
-    (m, n, k) -> (m, n)
+    affine_map<(m, n, k) -> (m, k)>,
+    affine_map<(m, n, k) -> (k, n)>,
+    affine_map<(m, n, k) -> (m, n)>
   ],
   iterator_types = ["parallel", "parallel", "reduction"],
   __internal_linalg_transform__ = "_marked_matmul_"
 }
 func @vectorization_test(%A: memref<8x16xf32>, %B: memref<16x32xf32>,
                          %C: memref<8x32xf32>) {
   linalg.generic #matmul_trait %A, %B, %C {
     ^bb(%a: f32, %b: f32, %c: f32) :

 //       CHECK: vector.contract {indexing_maps = [#[[mk]], #[[kn]], #[[mn]]], iterator_types = ["parallel", "parallel", "reduction"]} %{{.*}}, %{{.*}}, %{{.*}} : vector<8x16xf32>, vector<16x32xf32> into vector<8x32xf32>
 //       CHECK: store %{{.*}}, %{{.*}}[] : memref<vector<8x32xf32>>
 func @fma(%a: f32, %b: f32, %c: f32) -> f32 {
           %d = mulf %a, %b: f32
           %e = addf %c, %d: f32
           return %e: f32
         }
 #matmul_accesses = [
-          (m, n, k) -> (m, k),
-          (m, n, k) -> (k, n),
-          (m, n, k) -> (m, n)
+          affine_map<(m, n, k) -> (m, k)>,
+          affine_map<(m, n, k) -> (k, n)>,
+          affine_map<(m, n, k) -> (m, n)>
 ]
 #generic_matmul_trait = {
           args_in = 2,
           args_out = 1,
           fun = @fma,
           indexing_maps = #matmul_accesses,
           library_call = "linalg_matmul",
           iterator_types = ["parallel", "parallel", "reduction"]

mlir/test/Dialect/SPIRV/composite-ops.mlir

func @composite_extract_invalid_index_type_2(%arg0 : !spv.array<4x!spv.array<4xf32>>) -> () {
   // expected-error @+1 {{op attribute 'indices' failed to satisfy constraint: 32-bit integer array attribute}}
   %0 = spv.CompositeExtract %arg0[1] : !spv.array<4x!spv.array<4xf32>>
   return
 }
 
 // -----
 
 func @composite_extract_invalid_index_identifier(%arg0 : !spv.array<4x!spv.array<4xf32>>) -> () {
-  // expected-error @+1 {{expected bare identifier}}
-  %0 = spv.CompositeExtract %arg0(1 : i32) : !spv.array<4x!spv.array<4xf32>>
+  // expected-error @+1 {{expected non-function type}}
+  %0 = spv.CompositeExtract %arg0 ]1 : i32) : !spv.array<4x!spv.array<4xf32>>
   return
 }
 
 // -----
 
 func @composite_extract_2D_array_out_of_bounds_access_1(%arg0: !spv.array<4x!spv.array<4xf32>>) -> () {
   // expected-error @+1 {{index 4 out of bounds for '!spv.array<4 x !spv.array<4 x f32>>'}}
   %0 = spv.CompositeExtract %arg0[4 : i32, 1 : i32] : !spv.array<4x!spv.array<4xf32>>

mlir/test/Dialect/VectorOps/invalid.mlir

 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant 3.0 : f32
   // expected-error@+1 {{two types required}}
-  %0 = vector.transfer_read %arg0[%c3, %c3], %cst { permutation_map = ()->(0) } : memref<?x?xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %cst { permutation_map = affine_map<()->(0)> } : memref<?x?xf32>
 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant 3.0 : f32
   // expected-error@+1 {{requires 2 indices}}
-  %0 = vector.transfer_read %arg0[%c3, %c3, %c3], %cst { permutation_map = ()->(0) } : memref<?x?xf32>, vector<128xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3, %c3], %cst { permutation_map = affine_map<()->(0)> } : memref<?x?xf32>, vector<128xf32>
 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant 3.0 : f32
   // expected-error@+1 {{requires attribute 'permutation_map'}}
-  %0 = vector.transfer_read %arg0[%c3, %c3], %cst {perm = (d0)->(d0)} : memref<?x?xf32>, vector<128xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %cst {perm = affine_map<(d0)->(d0)>} : memref<?x?xf32>, vector<128xf32>
 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant 3.0 : f32
   // expected-error@+1 {{requires a permutation_map with input dims of the same rank as the memref type}}
-  %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = (d0)->(d0)} : memref<?x?xf32>, vector<128xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0)->(d0)>} : memref<?x?xf32>, vector<128xf32>
 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant 3.0 : f32
   // expected-error@+1 {{requires a permutation_map with result dims of the same rank as the vector type}}
-  %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = (d0, d1)->(d0, d1)} : memref<?x?xf32>, vector<128xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : memref<?x?xf32>, vector<128xf32>
 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant 3.0 : f32
   // expected-error@+1 {{requires a projected permutation_map (at most one dim or the zero constant can appear in each result)}}
-  %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = (d0, d1)->(d0 + d1)} : memref<?x?xf32>, vector<128xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d0 + d1)>} : memref<?x?xf32>, vector<128xf32>
 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant 3.0 : f32
   // expected-error@+1 {{requires a projected permutation_map (at most one dim or the zero constant can appear in each result)}}
-  %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = (d0, d1)->(d0 + 1)} : memref<?x?xf32>, vector<128xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d0 + 1)>} : memref<?x?xf32>, vector<128xf32>
 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant 3.0 : f32
   // expected-error@+1 {{requires a permutation_map that is a permutation (found one dim used more than once)}}
-  %0 = vector.transfer_read %arg0[%c3, %c3, %c3], %cst {permutation_map = (d0, d1, d2)->(d0, d0)} : memref<?x?x?xf32>, vector<3x7xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3, %c3], %cst {permutation_map = affine_map<(d0, d1, d2)->(d0, d0)>} : memref<?x?x?xf32>, vector<3x7xf32>
 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?xvector<4x3xf32>>) {
   %c3 = constant 3 : index
   %f0 = constant 0.0 : f32
   %vf0 = splat %f0 : vector<4x3xf32>
   // expected-error@+1 {{requires memref and vector types of the same elemental type}}
-  %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 {permutation_map = (d0, d1)->(d0, d1)} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xi32>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xi32>
 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?xvector<4x3xf32>>) {
   %c3 = constant 3 : index
   %f0 = constant 0.0 : f32
   %vf0 = splat %f0 : vector<4x3xf32>
   // expected-error@+1 {{requires memref vector element and vector result ranks to match}}
-  %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 {permutation_map = (d0, d1)->(d0, d1)} : memref<?x?xvector<4x3xf32>>, vector<3xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : memref<?x?xvector<4x3xf32>>, vector<3xf32>
 }
 
 // -----
 
 func @test_vector.transfer_read(%arg0: memref<?x?xvector<4x3xf32>>) {
   %c3 = constant 3 : index
   %f0 = constant 0.0 : f32
   %vf0 = splat %f0 : vector<4x3xf32>
   // expected-error@+1 {{ requires memref vector element shape to match suffix of vector result shape}}
-  %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 {permutation_map = (d0, d1)->(d0, d1)} : memref<?x?xvector<4x3xf32>>, vector<1x1x2x3xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %vf0 {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : memref<?x?xvector<4x3xf32>>, vector<1x1x2x3xf32>
 }
 
 // -----
 
 func @test_vector.transfer_write(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant dense<3.0> : vector<128 x f32>
   // expected-error@+1 {{expected 5 operand types but had 4}}
-  %0 = "vector.transfer_write"(%cst, %arg0, %c3, %c3, %c3) {permutation_map = ()->(0)} : (vector<128xf32>, memref<?x?xf32>, index, index) -> ()
+  %0 = "vector.transfer_write"(%cst, %arg0, %c3, %c3, %c3) {permutation_map = affine_map<()->(0)>} : (vector<128xf32>, memref<?x?xf32>, index, index) -> ()
 }
 
 // -----
 
 func @test_vector.transfer_write(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant dense<3.0> : vector<128 x f32>
   // expected-error@+1 {{requires 2 indices}}
-  vector.transfer_write %cst, %arg0[%c3, %c3, %c3] {permutation_map = ()->(0)} : vector<128xf32>, memref<?x?xf32>
+  vector.transfer_write %cst, %arg0[%c3, %c3, %c3] {permutation_map = affine_map<()->(0)>} : vector<128xf32>, memref<?x?xf32>
 }
 
 // -----
 
 func @test_vector.transfer_write(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant dense<3.0> : vector<128 x f32>
   // expected-error@+1 {{requires attribute 'permutation_map'}}
-  vector.transfer_write %cst, %arg0[%c3, %c3] {perm = (d0)->(d0)} : vector<128xf32>, memref<?x?xf32>
+  vector.transfer_write %cst, %arg0[%c3, %c3] {perm = affine_map<(d0)->(d0)>} : vector<128xf32>, memref<?x?xf32>
 }
 
 // -----
 
 func @test_vector.transfer_write(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant dense<3.0> : vector<128 x f32>
   // expected-error@+1 {{requires a permutation_map with input dims of the same rank as the memref type}}
-  vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = (d0)->(d0)} : vector<128xf32>, memref<?x?xf32>
+  vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = affine_map<(d0)->(d0)>} : vector<128xf32>, memref<?x?xf32>
 }
 
 // -----
 
 func @test_vector.transfer_write(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant dense<3.0> : vector<128 x f32>
   // expected-error@+1 {{requires a permutation_map with result dims of the same rank as the vector type}}
-  vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = (d0, d1)->(d0, d1)} : vector<128xf32>, memref<?x?xf32>
+  vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : vector<128xf32>, memref<?x?xf32>
 }
 
 // -----
 
 func @test_vector.transfer_write(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant dense<3.0> : vector<128 x f32>
   // expected-error@+1 {{requires a projected permutation_map (at most one dim or the zero constant can appear in each result)}}
-  vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = (d0, d1)->(d0 + d1)} : vector<128xf32>, memref<?x?xf32>
+  vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0 + d1)>} : vector<128xf32>, memref<?x?xf32>
 }
 
 // -----
 
 func @test_vector.transfer_write(%arg0: memref<?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant dense<3.0> : vector<128 x f32>
   // expected-error@+1 {{requires a projected permutation_map (at most one dim or the zero constant can appear in each result)}}
-  vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = (d0, d1)->(d0 + 1)} : vector<128xf32>, memref<?x?xf32>
+  vector.transfer_write %cst, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0 + 1)>} : vector<128xf32>, memref<?x?xf32>
 }
 
 // -----
 
 func @test_vector.transfer_write(%arg0: memref<?x?x?xf32>) {
   %c3 = constant 3 : index
   %cst = constant dense<3.0> : vector<3 x 7 x f32>
   // expected-error@+1 {{requires a permutation_map that is a permutation (found one dim used more than once)}}
-  vector.transfer_write %cst, %arg0[%c3, %c3, %c3] {permutation_map = (d0, d1, d2)->(d0, d0)} : vector<3x7xf32>, memref<?x?x?xf32>
+  vector.transfer_write %cst, %arg0[%c3, %c3, %c3] {permutation_map = affine_map<(d0, d1, d2)->(d0, d0)>} : vector<3x7xf32>, memref<?x?x?xf32>
 }
 
 // -----
 
 func @insert_strided_slice(%a: vector<4x4xf32>, %b: vector<4x8x16xf32>) {
   // expected-error@+1 {{expected offsets of same size as destination vector rank}}
   %1 = vector.insert_strided_slice %a, %b {offsets = [100], strides = [1, 1]} : vector<4x4xf32> into vector<4x8x16xf32>
 }

 func @strided_slice(%arg0: vector<4x8x16xf32>) {
   // expected-error@+1 {{op expected result type to be 'vector<2x8x16xf32>'}}
   %1 = vector.strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4x8x16xf32> to vector<3x1xf32>
 }
 
 // -----
 
 #contraction_accesses = [
-  (b0, f0, f1, c0, c1) -> (c0, b0, c1, f0),
-  (b0, f0, f1, c0, c1) -> (b0, c1, c0, f1),
-  (b0, f0, f1, c0, c1) -> (b0, f0, f1),
-  (b0, f0, f1, c0, c1) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>
 ]
 #contraction_trait = {
   indexing_maps = #contraction_accesses,
   iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]
 }
 func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>,
                   %arg2: vector<8x15x5xf32>, %arg3 :  vector<8x15x8x5xf32>,
                   %arg4 : index) {
   // expected-error@+1 {{expected an indexing map for each vector operand}}
   %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2
       : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32>
 }
 
 // -----
 
 #contraction_accesses = [
-  (b0, f0, f1, c0, c1) -> (c0, c0, c1, f0),
-  (b0, f0, f1, c0, c1) -> (b0, c1, c0, f1),
-  (b0, f0, f1, c0, c1) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, c0, c1) -> (c0, c0, c1, f0)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>
 ]
 #contraction_trait = {
   indexing_maps = #contraction_accesses,
   iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]
 }
 func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>,
                   %arg2: vector<8x15x5xf32>, %arg3 :  vector<8x15x8x5xf32>,
                   %arg4 : index) {
   // expected-error@+1 {{expected indexing map 0 to be a projected permutation of its inputs}}
   %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2
       : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32>
 }
 
 // -----
 
 #contraction_accesses = [
-  (b0, f0, f1, c0, c1) -> (c0, b0, c1, f0),
-  (b0, f0, f1, c0, c1)[s0] -> (b0, s0, c0, f1),
-  (b0, f0, f1, c0, c1) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>,
+  affine_map<(b0, f0, f1, c0, c1)[s0] -> (b0, s0, c0, f1)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>
 ]
 #contraction_trait = {
   indexing_maps = #contraction_accesses,
   iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]
 }
 func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>,
                   %arg2: vector<8x15x5xf32>, %arg3 :  vector<8x15x8x5xf32>,
                   %arg4 : index) {
   // expected-error@+1 {{op expected indexing map 1 to have no symbols}}
   %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2
       : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32>
 }
 
 // -----
 
 #contraction_accesses = [
-  (b0, f0, f1, c0, c1) -> (c0, b0, c1, f0),
-  (b0, f0, f1, c0, c1) -> (b0, c1, c0, f1),
-  (b0, f0, f1, c1) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>,
+  affine_map<(b0, f0, f1, c1) -> (b0, f0, f1)>
 ]
 #contraction_trait = {
   indexing_maps = #contraction_accesses,
   iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]
 }
 func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>,
                   %arg2: vector<8x15x5xf32>, %arg3 :  vector<8x15x8x5xf32>,
                   %arg4 : index) {
   // expected-error@+1 {{expected indexing map 2 to have 5 number of inputs}}
   %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2
       : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32>
 }
 
 // -----
 
 #contraction_accesses = [
-  (b0, f0, f1, c0, c1) -> (c0, b0, c1, f0),
-  (b0, f0, f1, c0, c1) -> (b0, c1, f1),
-  (b0, f0, f1, c0, c1) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, f1)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>
 ]
 #contraction_trait = {
   indexing_maps = #contraction_accesses,
   iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]
 }
 func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>,
                   %arg2: vector<8x15x5xf32>, %arg3 :  vector<8x15x8x5xf32>,
                   %arg4 : index) {
   // expected-error@+1 {{expected indexing map 1 to have 4 number of outputs}}
   %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2
       : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32>
 }
 
 // -----
 
 #contraction_accesses = [
-  (b0, f0, f1, b1, b2) -> (b1, b0, b2, f0),
-  (b0, f0, f1, b1, b2) -> (b0, b2, b1, f1),
-  (b0, f0, f1, b1, b2) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, b1, b2) -> (b1, b0, b2, f0)>,
+  affine_map<(b0, f0, f1, b1, b2) -> (b0, b2, b1, f1)>,
+  affine_map<(b0, f0, f1, b1, b2) -> (b0, f0, f1)>
 ]
 #contraction_trait = {
   indexing_maps = #contraction_accesses,
   iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]
 }
 func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>,
                   %arg2: vector<8x15x5xf32>, %arg3 :  vector<8x15x8x5xf32>,
                   %arg4 : index) {
   // expected-error@+1 {{op expected at least one contracting dimension pair}}
   %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2
       : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32>
 }
 
 // -----
 
 #contraction_accesses = [
-  (b0, f0, f1, c0, c1) -> (c1, b0, c0, f0),
-  (b0, f0, f1, c0, c1) -> (b0, c1, c0, f1),
-  (b0, f0, f1, c0, c1) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, c0, c1) -> (c1, b0, c0, f0)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>
 ]
 #contraction_trait = {
   indexing_maps = #contraction_accesses,
   iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]
 }
 func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>,
                   %arg2: vector<8x15x5xf32>, %arg3 :  vector<8x15x8x5xf32>,
                   %arg4 : index) {
   // expected-error@+1 {{invalid contracting dimension map}}
   %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2
       : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32>
 }
 
 // -----
 
 #contraction_accesses = [
-  (b0, f0, f1, c0, c1) -> (c0, b0, c1, f0),
-  (b0, f0, f1, c0, c1) -> (f1, c1, c0, b0),
-  (b0, f0, f1, c0, c1) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (f1, c1, c0, b0)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>
 ]
 #contraction_trait = {
   indexing_maps = #contraction_accesses,
   iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]
 }
 func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>,
                   %arg2: vector<8x15x5xf32>, %arg3 :  vector<8x15x8x5xf32>,
                   %arg4 : index) {
   // expected-error@+1 {{invalid batch dimension map}}
   %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2
       : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<8x15x5xf32>
 }
 
 // -----
 
 #contraction_accesses = [
-  (b0, f0, f1, c0, c1) -> (c0, b0, c1, f0),
-  (b0, f0, f1, c0, c1) -> (b0, c1, c0, f1),
-  (b0, f0, f1, c0, c1) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>
 ]
 #contraction_trait = {
   indexing_maps = #contraction_accesses,
   iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]
 }
 func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>,
                   %arg2: vector<88x15x5xf32>, %arg3 :  vector<8x15x8x5xf32>,
                   %arg4 : index) {
   // expected-error@+1 {{invalid accumulator/result vector shape}}
   %0 = vector.contract #contraction_trait %arg0, %arg1, %arg2
       : vector<7x8x16x15xf32>, vector<8x16x7x5xf32> into vector<88x15x5xf32>
 }
 
 // -----
 
 #contraction_accesses = [
-  (b0, f0, f1, c0, c1) -> (c0, b0, c1, f0),
-  (b0, f0, f1, c0, c1) -> (b0, c1, c0, f1),
-  (b0, f0, f1, c0, c1) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>
 ]
 #contraction_trait = {
   indexing_maps = #contraction_accesses,
   iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]
 }
 func @contraction(%arg0: vector<7x8x16x15xf32>, %arg1: vector<8x16x7x5xf32>,
                   %arg2: vector<8x15x5xf32>, %arg3 :  vector<8x15x8x5xf32>,
                   %arg4 : index) {

mlir/test/Dialect/VectorOps/ops.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
-// CHECK-DAG: #[[MAP0:map[0-9]+]] = (d0, d1) -> (d0, d1)
+// CHECK-DAG: #[[MAP0:map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
 
 // CHECK-LABEL: func @vector_transfer_ops(
 func @vector_transfer_ops(%arg0: memref<?x?xf32>,
                           %arg1 : memref<?x?xvector<4x3xf32>>) {
   // CHECK: %[[C3:.*]] = constant 3 : index
   %c3 = constant 3 : index
   %cst = constant 3.0 : f32
   %f0 = constant 0.0 : f32
   %vf0 = splat %f0 : vector<4x3xf32>
 
   //
   // CHECK: vector.transfer_read
-  %0 = vector.transfer_read %arg0[%c3, %c3], %f0 {permutation_map = (d0, d1)->(d0)} : memref<?x?xf32>, vector<128xf32>
+  %0 = vector.transfer_read %arg0[%c3, %c3], %f0 {permutation_map = affine_map<(d0, d1)->(d0)>} : memref<?x?xf32>, vector<128xf32>
   // CHECK: vector.transfer_read
-  %1 = vector.transfer_read %arg0[%c3, %c3], %f0 {permutation_map = (d0, d1)->(d1, d0)} : memref<?x?xf32>, vector<3x7xf32>
+  %1 = vector.transfer_read %arg0[%c3, %c3], %f0 {permutation_map = affine_map<(d0, d1)->(d1, d0)>} : memref<?x?xf32>, vector<3x7xf32>
   // CHECK: vector.transfer_read
-  %2 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = (d0, d1)->(d0)} : memref<?x?xf32>,  vector<128xf32>
+  %2 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = affine_map<(d0, d1)->(d0)>} : memref<?x?xf32>,  vector<128xf32>
   // CHECK: vector.transfer_read
-  %3 = vector.transfer_read %arg0[%c3, %c3], %cst {permutation_map = (d0, d1)->(d1)} : 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>
   // CHECK: vector.transfer_read %{{.*}}[%[[C3]], %[[C3]]], %{{.*}} {permutation_map = #[[MAP0]]} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>
-  %4 = vector.transfer_read %arg1[%c3, %c3], %vf0 {permutation_map = (d0, d1)->(d0, d1)} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>
+  %4 = vector.transfer_read %arg1[%c3, %c3], %vf0 {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : memref<?x?xvector<4x3xf32>>, vector<1x1x4x3xf32>
 
   // CHECK: vector.transfer_write
-  vector.transfer_write %0, %arg0[%c3, %c3] {permutation_map = (d0, d1)->(d0)} : vector<128xf32>, memref<?x?xf32>
+  vector.transfer_write %0, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0)>} : vector<128xf32>, memref<?x?xf32>
   // CHECK: vector.transfer_write
-  vector.transfer_write %1, %arg0[%c3, %c3] {permutation_map = (d0, d1)->(d1, d0)} : vector<3x7xf32>, memref<?x?xf32>
+  vector.transfer_write %1, %arg0[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d1, d0)>} : vector<3x7xf32>, memref<?x?xf32>
   // CHECK: vector.transfer_write %{{.*}}, %{{.*}}[%[[C3]], %[[C3]]] {permutation_map = #[[MAP0]]} : vector<1x1x4x3xf32>, memref<?x?xvector<4x3xf32>>
-  vector.transfer_write %4, %arg1[%c3, %c3] {permutation_map = (d0, d1)->(d0, d1)} : vector<1x1x4x3xf32>, memref<?x?xvector<4x3xf32>>
+  vector.transfer_write %4, %arg1[%c3, %c3] {permutation_map = affine_map<(d0, d1)->(d0, d1)>} : vector<1x1x4x3xf32>, memref<?x?xvector<4x3xf32>>
 
   return
 }
 
 // CHECK-LABEL: @vector_broadcast
 func @vector_broadcast(%a: f32, %b: vector<16xf32>, %c: vector<1x16xf32>, %d: vector<8x1xf32>) -> vector<8x16xf32> {
   // CHECK: vector.broadcast %{{.*}} : f32 to vector<16xf32>
   %0 = vector.broadcast %a : f32 to vector<16xf32>

 // CHECK-LABEL: @strided_slice
 func @strided_slice(%arg0: vector<4x8x16xf32>) -> vector<2x2x16xf32> {
   // CHECK: vector.strided_slice %{{.*}} {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8x16xf32>
   %1 = vector.strided_slice %arg0 {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8x16xf32> to vector<2x2x16xf32>
   return %1: vector<2x2x16xf32>
 }
 
 #contraction_accesses0 = [
-  (b0, f0, f1, c0, c1) -> (c0, b0, c1, f0),
-  (b0, f0, f1, c0, c1) -> (b0, c1, c0, f1),
-  (b0, f0, f1, c0, c1) -> (b0, f0, f1)
+  affine_map<(b0, f0, f1, c0, c1) -> (c0, b0, c1, f0)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, c1, c0, f1)>,
+  affine_map<(b0, f0, f1, c0, c1) -> (b0, f0, f1)>
 ]
 #contraction_trait0 = {
   indexing_maps = #contraction_accesses0,
   iterator_types = ["parallel", "parallel", "parallel", "reduction", "reduction"]
 }
 #contraction_accesses1 = [
-  (f0, f1, f2, f3, c0, c1) -> (c0, f0, c1, f2),
-  (f0, f1, f2, f3, c0, c1) -> (f1, c1, c0, f3),
-  (f0, f1, f2, f3, c0, c1) -> (f0, f1, f2, f3)
+  affine_map<(f0, f1, f2, f3, c0, c1) -> (c0, f0, c1, f2)>,
+  affine_map<(f0, f1, f2, f3, c0, c1) -> (f1, c1, c0, f3)>,
+  affine_map<(f0, f1, f2, f3, c0, c1) -> (f0, f1, f2, f3)>
 ]
 #contraction_trait1 = {
   indexing_maps = #contraction_accesses1,
   iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction",
                     "reduction"]
 }
 // CHECK-LABEL: contraction
 func @contraction(%arg0 : vector<7x8x16x15xf32>, %arg1 : vector<8x16x7x5xf32>,

mlir/test/Dialect/VectorOps/vector-transforms.mlir

 // RUN: mlir-opt %s -test-vector-to-vector-conversion | FileCheck %s
 
-// CHECK-DAG: #[[MAP0:map[0-9]+]] = (d0, d1) -> (d0, d1)
+// CHECK-DAG: #[[MAP0:map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
 
 // CHECK-LABEL: func @add4x2
 //      CHECK: %[[ES1:.*]] = vector.extract_slices %{{.*}}, [2, 2], [1, 1] : vector<4x2xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>>
 // CHECK-NEXT: %[[ES2:.*]] = vector.extract_slices %{{.*}}, [2, 2], [1, 1] : vector<4x2xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>>
 // CHECK-NEXT: %[[TG1:.*]] = vector.tuple_get %[[ES1]], 0 : tuple<vector<2x2xf32>, vector<2x2xf32>>
 // CHECK-NEXT: %[[TG2:.*]] = vector.tuple_get %[[ES2]], 0 : tuple<vector<2x2xf32>, vector<2x2xf32>>
 // CHECK-NEXT: %[[A1:.*]] = addf %[[TG1]], %[[TG2]] : vector<2x2xf32>
 // CHECK-NEXT: %[[TG3:.*]] = vector.tuple_get %[[ES1]], 1 : tuple<vector<2x2xf32>, vector<2x2xf32>>

 
 func @add4x4(%0: vector<4x4xf32>, %1: vector<4x4xf32>) -> vector<4x4xf32> {
   %2 = addf %0, %1: vector<4x4xf32>
   %3 = addf %1, %2: vector<4x4xf32>
   return %3: vector<4x4xf32>
 }
 
 #contraction_accesses0 = [
-  (i, j, k) -> (i, k),
-  (i, j, k) -> (k, j),
-  (i, j, k) -> (i, j)
+  affine_map<(i, j, k) -> (i, k)>,
+  affine_map<(i, j, k) -> (k, j)>,
+  affine_map<(i, j, k) -> (i, j)>
 ]
 #contraction_trait0 = {
   indexing_maps = #contraction_accesses0,
   iterator_types = ["parallel", "parallel", "reduction"]
 }
 
 // CHECK-LABEL: func @contraction4x4_ijk
 
func @contraction4x4_ijk(%arg0 : vector<4x6xf32>, %arg1 : vector<6x4xf32>,
   %rhsm = vector.constant_mask [6, 4] : vector<6x4xi1>
   %0 = vector.contract #contraction_trait0 %arg0, %arg1, %arg2, %lhsm, %rhsm
       : vector<4x6xf32>, vector<6x4xf32> into vector<4x4xf32>
 
   return %0 : vector<4x4xf32>
 }
 
 #contraction_accesses1 = [
-  (i, k, j) -> (i, k),
-  (i, k, j) -> (k, j),
-  (i, k, j) -> (i, j)
+  affine_map<(i, k, j) -> (i, k)>,
+  affine_map<(i, k, j) -> (k, j)>,
+  affine_map<(i, k, j) -> (i, j)>
 ]
 #contraction_trait1 = {
   indexing_maps = #contraction_accesses1,
   iterator_types = ["parallel", "reduction", "parallel"]
 }
 
 // CHECK-LABEL: func @contraction4x4_ikj
 

 
 func @contraction4x4_ikj_xfer_read(%arg0 : memref<4x2xf32>,
                                    %arg1 : memref<2x4xf32>,
                                    %arg2 : memref<4x4xf32>) {
   %c0 = constant 0 : index
   %cf0 = constant 0.0 : f32
 
   %0 = vector.transfer_read %arg0[%c0, %c0], %cf0
-    { permutation_map = (d0, d1) -> (d0, d1) }
+    { permutation_map = affine_map<(d0, d1) -> (d0, d1)> }
       : memref<4x2xf32>, vector<4x2xf32>
 
   %1 = vector.transfer_read %arg1[%c0, %c0], %cf0
-    { permutation_map = (d0, d1) -> (d0, d1) }
+    { permutation_map = affine_map<(d0, d1) -> (d0, d1)> }
     : memref<2x4xf32>, vector<2x4xf32>
 
   %2 = vector.transfer_read %arg2[%c0, %c0], %cf0
-    { permutation_map = (d0, d1) -> (d0, d1) }
+    { permutation_map = affine_map<(d0, d1) -> (d0, d1)> }
       : memref<4x4xf32>, vector<4x4xf32>
 
   %3 = vector.contract #contraction_trait1 %0, %1, %2
       : vector<4x2xf32>, vector<2x4xf32> into vector<4x4xf32>
 
   vector.transfer_write %3, %arg2[%c0, %c0]
-    {permutation_map = (d0, d1) -> (d0, d1)}
+    {permutation_map = affine_map<(d0, d1) -> (d0, d1)>}
       : vector<4x4xf32>, memref<4x4xf32>
   return
 }
 
 // TODO(andydavis) Update test with VTR split transform.
 // CHECK-LABEL: func @vector_transfers
 // CHECK-COUNT-8: vector.transfer_read
 // CHECK-COUNT-4: addf
 // CHECK-COUNT-4: vector.transfer_write
 
 func @vector_transfers(%arg0: index, %arg1: index) {
   %cst = constant 0.000000e+00 : f32
   %0 = alloc(%arg0, %arg1) : memref<?x?xf32>
   %1 = alloc(%arg0, %arg1) : memref<?x?xf32>
   %2 = alloc(%arg0, %arg1) : memref<?x?xf32>
   %cst_0 = constant 1.000000e+00 : f32
   %cst_1 = constant 2.000000e+00 : f32
   affine.for %arg2 = 0 to %arg0 step 4 {
     affine.for %arg3 = 0 to %arg1 step 4 {
-      %4 = vector.transfer_read %0[%arg2, %arg3], %cst  {permutation_map = (d0, d1) -> (d0, d1)} : memref<?x?xf32>, vector<4x4xf32>
-      %5 = vector.transfer_read %1[%arg2, %arg3], %cst  {permutation_map = (d0, d1) -> (d0, d1)} : memref<?x?xf32>, vector<4x4xf32>
+      %4 = vector.transfer_read %0[%arg2, %arg3], %cst  {permutation_map = affine_map<(d0, d1) -> (d0, d1)>} : memref<?x?xf32>, vector<4x4xf32>
+      %5 = vector.transfer_read %1[%arg2, %arg3], %cst  {permutation_map = affine_map<(d0, d1) -> (d0, d1)>} : memref<?x?xf32>, vector<4x4xf32>
       %6 = addf %4, %5 : vector<4x4xf32>
-      vector.transfer_write %6, %2[%arg2, %arg3] {permutation_map = (d0, d1) -> (d0, d1)} : vector<4x4xf32>, memref<?x?xf32>
+      vector.transfer_write %6, %2[%arg2, %arg3] {permutation_map = affine_map<(d0, d1) -> (d0, d1)>} : vector<4x4xf32>, memref<?x?xf32>
     }
   }
   return
 }

mlir/test/EDSC/builder-api-test.cpp

AffineLoopNestBuilder(&j, lb, ub, 2)([&] {
               index_t(32));
       ((f7 + f13) / f7) % f13 - f7 *f13;
       ((i7 + i13) / i7) % i13 - i7 *i13;
     });
   });
 
   // clang-format off
   // CHECK-LABEL: func @builder_dynamic_for_func_args(%{{.*}}: index, %{{.*}}: index) {
-  //     CHECK:  affine.for %{{.*}} = (d0) -> (d0)(%{{.*}}) to (d0) -> (d0)(%{{.*}}) step 3 {
-  //     CHECK:  {{.*}} = affine.apply ()[s0] -> (s0 * 3)()[%{{.*}}]
-  //     CHECK:  {{.*}} = affine.apply ()[s0, s1] -> (s1 + s0 * 3)()[%{{.*}}, %{{.*}}]
-  //     CHECK:  {{.*}} = affine.apply ()[s0] -> (s0 + 3)()[%{{.*}}]
-  //     CHECK:  affine.for %{{.*}} = (d0) -> (d0)(%{{.*}}) to (d0) -> (d0)(%{{.*}}) step 2 {
-  //     CHECK:    {{.*}} = affine.apply (d0, d1) -> ((d0 + d1 * 3) floordiv 32)(%{{.*}}, %{{.*}})
-  //     CHECK:    {{.*}} = affine.apply (d0, d1) -> (((d0 + d1 * 3) floordiv 32) * 31)(%{{.*}}, %{{.*}})
-  //     CHECK:    {{.*}} = affine.apply (d0, d1) -> ((((d0 + d1 * 3) floordiv 32) * 31) ceildiv 32)(%{{.*}}, %{{.*}})
+  //     CHECK:  affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%{{.*}}) to affine_map<(d0) -> (d0)>(%{{.*}}) step 3 {
+  //     CHECK:  {{.*}} = affine.apply affine_map<()[s0] -> (s0 * 3)>()[%{{.*}}]
+  //     CHECK:  {{.*}} = affine.apply affine_map<()[s0, s1] -> (s1 + s0 * 3)>()[%{{.*}}, %{{.*}}]
+  //     CHECK:  {{.*}} = affine.apply affine_map<()[s0] -> (s0 + 3)>()[%{{.*}}]
+  //     CHECK:  affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%{{.*}}) to affine_map<(d0) -> (d0)>(%{{.*}}) step 2 {
+  //     CHECK:    {{.*}} = affine.apply affine_map<(d0, d1) -> ((d0 + d1 * 3) floordiv 32)>(%{{.*}}, %{{.*}})
+  //     CHECK:    {{.*}} = affine.apply affine_map<(d0, d1) -> (((d0 + d1 * 3) floordiv 32) * 31)>(%{{.*}}, %{{.*}})
+  //     CHECK:    {{.*}} = affine.apply affine_map<(d0, d1) -> ((((d0 + d1 * 3) floordiv 32) * 31) ceildiv 32)>(%{{.*}}, %{{.*}})
   // CHECK-DAG:    [[rf1:%[0-9]+]] = addf {{.*}}, {{.*}} : f32
   // CHECK-DAG:    [[rf2:%[0-9]+]] = divf [[rf1]], {{.*}} : f32
   // CHECK-DAG:    [[rf3:%[0-9]+]] = remf [[rf2]], {{.*}} : f32
   // CHECK-DAG:    [[rf4:%[0-9]+]] = mulf {{.*}}, {{.*}} : f32
   //     CHECK:    {{.*}} = subf [[rf3]], [[rf4]] : f32
   // CHECK-DAG:    [[ri1:%[0-9]+]] = addi {{.*}}, {{.*}} : i32
   // CHECK-DAG:    [[ri2:%[0-9]+]] = divi_signed [[ri1]], {{.*}} : i32
   // CHECK-DAG:    [[ri3:%[0-9]+]] = remi_signed [[ri2]], {{.*}} : i32
TEST_FUNC(builder_dynamic_for) {
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   ValueHandle i(indexType), a(f.getArgument(0)), b(f.getArgument(1)),
       c(f.getArgument(2)), d(f.getArgument(3));
   AffineLoopNestBuilder(&i, a - b, c + d, 2)();
 
   // clang-format off
   // CHECK-LABEL: func @builder_dynamic_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
-  // CHECK-DAG:    [[r0:%[0-9]+]] = affine.apply ()[s0, s1] -> (s0 - s1)()[%{{.*}}, %{{.*}}]
-  // CHECK-DAG:    [[r1:%[0-9]+]] = affine.apply ()[s0, s1] -> (s0 + s1)()[%{{.*}}, %{{.*}}]
-  // CHECK-NEXT:   affine.for %{{.*}} = (d0) -> (d0)([[r0]]) to (d0) -> (d0)([[r1]]) step 2 {
+  // CHECK-DAG:    [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}]
+  // CHECK-DAG:    [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}]
+  // CHECK-NEXT:   affine.for %{{.*}} = affine_map<(d0) -> (d0)>([[r0]]) to affine_map<(d0) -> (d0)>([[r1]]) step 2 {
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_loop_for) {
   using namespace edsc;
   using namespace edsc::op;
   using namespace edsc::intrinsics;
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("builder_loop_for", {},
                         {indexType, indexType, indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   ValueHandle i(indexType), a(f.getArgument(0)), b(f.getArgument(1)),
       c(f.getArgument(2)), d(f.getArgument(3));
   LoopNestBuilder(&i, a - b, c + d, a)();
 
   // clang-format off
   // CHECK-LABEL: func @builder_loop_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
-  // CHECK-DAG:    [[r0:%[0-9]+]] = affine.apply ()[s0, s1] -> (s0 - s1)()[%{{.*}}, %{{.*}}]
-  // CHECK-DAG:    [[r1:%[0-9]+]] = affine.apply ()[s0, s1] -> (s0 + s1)()[%{{.*}}, %{{.*}}]
+  // CHECK-DAG:    [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}]
+  // CHECK-DAG:    [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-NEXT:   loop.for %{{.*}} = [[r0]] to [[r1]] step {{.*}} {
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_max_min_for) {
   using namespace edsc;
   using namespace edsc::op;
   using namespace edsc::intrinsics;
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("builder_max_min_for", {},
                         {indexType, indexType, indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   ValueHandle i(indexType), lb1(f.getArgument(0)), lb2(f.getArgument(1)),
       ub1(f.getArgument(2)), ub2(f.getArgument(3));
   AffineLoopNestBuilder(&i, {lb1, lb2}, {ub1, ub2}, 1)();
   ret();
 
   // clang-format off
   // CHECK-LABEL: func @builder_max_min_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
-  // CHECK:  affine.for %{{.*}} = max (d0, d1) -> (d0, d1)(%{{.*}}, %{{.*}}) to min (d0, d1) -> (d0, d1)(%{{.*}}, %{{.*}}) {
+  // CHECK:  affine.for %{{.*}} = max affine_map<(d0, d1) -> (d0, d1)>(%{{.*}}, %{{.*}}) to min affine_map<(d0, d1) -> (d0, d1)>(%{{.*}}, %{{.*}}) {
   // CHECK:  return
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 TEST_FUNC(builder_blocks) {
   using namespace edsc;
AffineLoopNestBuilder(&k1, lb2, ub2, step2)([&]{
       C(i, j, k1) = f7 + A(i, j, k1) + B(i, j, k1);
     });
     AffineLoopNestBuilder(&k2, lb2, ub2, step2)([&]{
       C(i, j, k2) += A(i, j, k2) + B(i, j, k2);
     });
   });
 
   // CHECK-LABEL: @builder_helpers
-  //      CHECK:   affine.for %{{.*}} = (d0) -> (d0)({{.*}}) to (d0) -> (d0)({{.*}}) {
-  // CHECK-NEXT:     affine.for %{{.*}} = (d0) -> (d0)({{.*}}) to (d0) -> (d0)({{.*}}) {
-  // CHECK-NEXT:       affine.for %{{.*}} = (d0) -> (d0)({{.*}}) to (d0) -> (d0)({{.*}}) {
+  //      CHECK:   affine.for %{{.*}} = affine_map<(d0) -> (d0)>({{.*}}) to affine_map<(d0) -> (d0)>({{.*}}) {
+  // CHECK-NEXT:     affine.for %{{.*}} = affine_map<(d0) -> (d0)>({{.*}}) to affine_map<(d0) -> (d0)>({{.*}}) {
+  // CHECK-NEXT:       affine.for %{{.*}} = affine_map<(d0) -> (d0)>({{.*}}) to affine_map<(d0) -> (d0)>({{.*}}) {
   //  CHECK-DAG:         [[a:%.*]] = affine.load %arg0[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-DAG:         [[b:%.*]] = addf {{.*}}, [[a]] : f32
   //  CHECK-DAG:         [[c:%.*]] = affine.load %arg1[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-DAG:         [[d:%.*]] = addf [[b]], [[c]] : f32
   // CHECK-NEXT:         affine.store [[d]], %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   // CHECK-NEXT:       }
-  // CHECK-NEXT:       affine.for %{{.*}} = (d0) -> (d0)(%{{.*}}) to (d0) -> (d0)(%{{.*}}) {
+  // CHECK-NEXT:       affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%{{.*}}) to affine_map<(d0) -> (d0)>(%{{.*}}) {
   //  CHECK-DAG:         [[a:%.*]] = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-DAG:         [[b:%.*]] = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-DAG:         [[c:%.*]] = addf [[b]], [[a]] : f32
   //  CHECK-DAG:         [[d:%.*]] = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-DAG:         [[e:%.*]] = addf [[d]], [[c]] : f32
   // CHECK-NEXT:         affine.store [[e]], %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   // clang-format on
   f.print(llvm::outs());
TEST_FUNC(tile_2d) {
   mlir::tile({ljj1, lii1}, {32, 16}, ljj1);
 
   // clang-format off
   // CHECK-LABEL: func @tile_2d
   //       CHECK: %[[ZERO:.*]] = constant 0 : index
   //       CHECK: %[[M:[0-9]+]] = dim %arg2, 0 : memref<?x?x?xf32>
   //  CHECK-NEXT: %[[N:[0-9]+]] = dim %arg2, 1 : memref<?x?x?xf32>
   //  CHECK-NEXT: %[[P:[0-9]+]] = dim %arg2, 2 : memref<?x?x?xf32>
-  //       CHECK:   affine.for %{{.*}} = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[M]]) step 512 {
-  //  CHECK-NEXT:     affine.for %{{.*}} = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[N]]) step 1024 {
-  //  CHECK-NEXT:       affine.for %{{.*}} = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[P]]) {
-  //  CHECK-NEXT:         affine.for %{{.*}} = max (d0) -> (0, d0)(%{{.*}}) to min (d0)[s0] -> (s0, d0 + 512)(%{{.*}})[%[[M]]] step 16 {
-  //  CHECK-NEXT:           affine.for %{{.*}} = max (d0) -> (0, d0)(%{{.*}}) to min (d0)[s0] -> (s0, d0 + 1024)(%{{.*}})[%[[N]]] step 32 {
-  //  CHECK-NEXT:             affine.for %{{.*}} = max (d0, d1) -> (0, d0, d1)(%{{.*}}, %{{.*}}) to min (d0, d1)[s0] -> (s0, d0 + 1024, d1 + 32)(%{{.*}}, %{{.*}})[%[[N]]] {
-  //  CHECK-NEXT:               affine.for %{{.*}} = max (d0, d1) -> (0, d0, d1)(%{{.*}}, %{{.*}}) to min (d0, d1)[s0] -> (s0, d0 + 512, d1 + 16)(%{{.*}}, %{{.*}})[%[[M]]] {
+  //       CHECK:   affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%[[ZERO]]) to affine_map<(d0) -> (d0)>(%[[M]]) step 512 {
+  //  CHECK-NEXT:     affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%[[ZERO]]) to affine_map<(d0) -> (d0)>(%[[N]]) step 1024 {
+  //  CHECK-NEXT:       affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%[[ZERO]]) to affine_map<(d0) -> (d0)>(%[[P]]) {
+  //  CHECK-NEXT:         affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0)[s0] -> (s0, d0 + 512)>(%{{.*}})[%[[M]]] step 16 {
+  //  CHECK-NEXT:           affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0)[s0] -> (s0, d0 + 1024)>(%{{.*}})[%[[N]]] step 32 {
+  //  CHECK-NEXT:             affine.for %{{.*}} = max affine_map<(d0, d1) -> (0, d0, d1)>(%{{.*}}, %{{.*}}) to min affine_map<(d0, d1)[s0] -> (s0, d0 + 1024, d1 + 32)>(%{{.*}}, %{{.*}})[%[[N]]] {
+  //  CHECK-NEXT:               affine.for %{{.*}} = max affine_map<(d0, d1) -> (0, d0, d1)>(%{{.*}}, %{{.*}}) to min affine_map<(d0, d1)[s0] -> (s0, d0 + 512, d1 + 16)>(%{{.*}}, %{{.*}})[%[[M]]] {
   //  CHECK-NEXT:                 {{.*}} = affine.load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-NEXT:                 {{.*}} = affine.load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-NEXT:                 {{.*}} = addf {{.*}}, {{.*}} : f32
   //  CHECK-NEXT:                 affine.store {{.*}}, {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //       CHECK:               }
   //  CHECK-NEXT:             }
   //  CHECK-NEXT:           }
   //  CHECK-NEXT:         }
   //  CHECK-NEXT:       }
-  //  CHECK-NEXT:       affine.for %{{.*}} = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[P]]) {
-  //  CHECK-NEXT:         affine.for %{{.*}} = max (d0) -> (0, d0)(%{{.*}}) to min (d0)[s0] -> (s0, d0 + 512)(%{{.*}})[%[[M]]] {
-  //  CHECK-NEXT:           affine.for %{{.*}} = max (d0) -> (0, d0)(%{{.*}}) to min (d0)[s0] -> (s0, d0 + 1024)(%{{.*}})[%[[N]]] {
+  //  CHECK-NEXT:       affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%[[ZERO]]) to affine_map<(d0) -> (d0)>(%[[P]]) {
+  //  CHECK-NEXT:         affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0)[s0] -> (s0, d0 + 512)>(%{{.*}})[%[[M]]] {
+  //  CHECK-NEXT:           affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0)[s0] -> (s0, d0 + 1024)>(%{{.*}})[%[[N]]] {
   //  CHECK-NEXT:             {{.*}} = affine.load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-NEXT:             {{.*}} = affine.load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-NEXT:             {{.*}}= addf {{.*}}, {{.*}} : f32
   //  CHECK-NEXT:             affine.store {{.*}}, {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
1})([&]{ C(i, j, k) = A(i, j, k) + B(i, j, k);
   // xCHECK-LABEL: func @vectorize_2d
   //  xCHECK-NEXT: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?x?xf32>
   //  xCHECK-NEXT: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?x?xf32>
   //  xCHECK-NEXT: %[[P:.*]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
   //  xCHECK-NEXT: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[M]]) {
   //  xCHECK-NEXT:   affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[N]]) step 4 {
   //  xCHECK-NEXT:     affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[P]]) step 4 {
   //  xCHECK-NEXT:       %[[vA:.*]] = "vector.transfer_read"(%{{.*}}, %{{.*}},
-%{{.*}}, %i2) {permutation_map = (d0, d1, d2) -> (d1, d2)} : (memref<?x?x?xf32>,
-index, index, index) -> vector<4x4xf32>
+%{{.*}}, %i2) {permutation_map = affine_map<(d0, d1, d2) -> (d1, d2)>} :
+(memref<?x?x?xf32>, index, index, index) -> vector<4x4xf32>
   //  xCHECK-NEXT:       %[[vB:.*]] =  "vector.transfer_read"(%{{.*}}, %{{.*}},
-%{{.*}}, %i2) {permutation_map = (d0, d1,  d2) -> (d1, d2)} :
+%{{.*}}, %i2) {permutation_map = affine_map<(d0, d1,  d2) -> (d1, d2)>} :
 (memref<?x?x?xf32>, index, index, index) -> vector<4x4xf32>
   //  xCHECK-NEXT:       %[[vRES:.*]] = addf %[[vB]], %[[vA]] : vector<4x4xf32>
   //  xCHECK-NEXT:       "vector.transfer_write"(%[[vRES:.*]], %{{.*}}, %{{.*}},
-%{{.*}}, %i2) {permutation_map = (d0, d1, d2) -> (d1, d2)} : (vector<4x4xf32>,
-memref<?x?x?xf32>, index, index, index) -> ()
+%{{.*}}, %i2) {permutation_map = affine_map<(d0, d1, d2) -> (d1, d2)>} :
+(vector<4x4xf32>, memref<?x?x?xf32>, index, index, index) -> ()
   // clang-format on
 
   mlir::PassManager pm;
   pm.addPass(mlir::createCanonicalizerPass());
   SmallVector<int64_t, 2> vectorSizes{4, 4};
   pm.addPass(mlir::createVectorizePass(vectorSizes));
   auto result = pm.run(f.getModule());
   if (succeeded(result))
TEST_FUNC(empty_map_load_store) {
   // CHECK:  [[A:%.*]] = affine.load %{{.*}}[]
   // CHECK:  affine.store [[A]], %{{.*}}[]
   // clang-format on
   f.print(llvm::outs());
   f.erase();
 }
 
 // CHECK-LABEL: func @affine_if_op
-// CHECK:       affine.if ([[d0:.*]], [[d1:.*]]){{\[}}[[s0:.*]], [[s1:.*]]{{\]}}
+// CHECK:       affine.if affine_set<([[d0:.*]], [[d1:.*]]){{\[}}[[s0:.*]], [[s1:.*]]{{\]}}
 // CHECK-NOT:   else
-// CHECK:       affine.if ([[d0:.*]], [[d1:.*]]){{\[}}[[s0:.*]], [[s1:.*]]{{\]}}
-// CHECK-NEXT:  } else {
+// CHECK:       affine.if affine_set<([[d0:.*]], [[d1:.*]]){{\[}}[[s0:.*]], [[s1:.*]]{{\]}}
+// CHECK-NEXT: } else {
 TEST_FUNC(affine_if_op) {
   using namespace edsc;
   using namespace edsc::intrinsics;
   using namespace edsc::op;
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType = MemRefType::get({-1, -1}, f32Type, {}, 0);
   auto f = makeFunction("affine_if_op", {}, {memrefType});
 
TEST_FUNC(affine_if_op) {
 
   f.print(llvm::outs());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_pointwise
 //       CHECK:   linalg.generic {args_in = 2 : i64, args_out = 1 : i64,
-// CHECK-SAME: indexing_maps = [(d0, d1) -> (d0, d1), (d0, d1) -> (d0, d1), (d0, d1) -> (d0, d1)],
+// CHECK-SAME: indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>],
 // CHECK-SAME: iterator_types = ["parallel", "parallel"]}
 //       CHECK:       addf
 //       CHECK:     }: memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>
 //       CHECK:   linalg.generic {args_in = 2 : i64, args_out = 1 : i64,
-// CHECK-SAME: indexing_maps = [(d0, d1) -> (d0, d1), (d0, d1) -> (d0, d1), (d0, d1) -> (d0, d1)],
+// CHECK-SAME: indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>],
 // CHECK-SAME: iterator_types = ["parallel", "parallel"]}
 //       CHECK:       cmpf "ogt"
 //       CHECK:       select
 //       CHECK:   }: memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>
 //       CHECK:   linalg.generic {args_in = 1 : i64, args_out = 1 : i64,
-// CHECK-SAME:      indexing_maps = [(d0, d1) -> (d0, d1), (d0, d1) -> (d0, d1)],
+// CHECK-SAME:      indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>],
 // CHECK-SAME:      iterator_types = ["parallel", "parallel"]}
 //       CHECK:     tanh
 //       CHECK:   }: memref<?x?xf32>, memref<?x?xf32>
 // clang-format on
 TEST_FUNC(linalg_pointwise_test) {
   using namespace edsc;
   using namespace edsc::ops;
 
TEST_FUNC(linalg_pointwise_test) {
 
   f.print(llvm::outs());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_matmul
 //       CHECK:   linalg.generic {args_in = 2 : i64, args_out = 1 : i64,
-// CHECK-SAME: indexing_maps = [(d0, d1, d2) -> (d0, d2), (d0, d1, d2) -> (d2, d1), (d0, d1, d2) -> (d0, d1)],
+// CHECK-SAME: indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d2)>, affine_map<(d0, d1, d2) -> (d2, d1)>, affine_map<(d0, d1, d2) -> (d0, d1)>],
 // CHECK-SAME: iterator_types = ["parallel", "parallel", "reduction"]}
 ///      CHECK:   ^bb1(%[[a0:.*]]: f32, %[[a1:.*]]: f32, %[[a2:.*]]: f32):
 //       CHECK:     %[[a3:.*]] = mulf %[[a0]], %[[a1]] : f32
 //       CHECK:     %[[a4:.*]] = addf %[[a2]], %[[a3]] : f32
 //       CHECK:     linalg.yield %[[a4]] : f32
 //       CHECK:   }: memref<?x?xf32>, memref<?x?xf32>, memref<?x?xf32>
 // clang-format on
 TEST_FUNC(linalg_matmul_test) {
TEST_FUNC(linalg_matmul_test) {
 
   f.print(llvm::outs());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_conv_nhwc
 //       CHECK:   linalg.generic {args_in = 2 : i64, args_out = 1 : i64,
-// CHECK-SAME: indexing_maps = [(d0, d1, d2, d3, d4, d5, d6) -> (d0, d2 * 3 + d4 * 5, d3 * 4 + d5 * 6, d6),
-// CHECK-SAME: (d0, d1, d2, d3, d4, d5, d6) -> (d4, d5, d6, d1),
-// CHECK-SAME: (d0, d1, d2, d3, d4, d5, d6) -> (d0, d2, d3, d1)],
+// CHECK-SAME: indexing_maps = [affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d2 * 3 + d4 * 5, d3 * 4 + d5 * 6, d6)>,
+// CHECK-SAME: affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4, d5, d6, d1)>,
+// CHECK-SAME: affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d2, d3, d1)>],
 // CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "parallel", "reduction", "reduction", "reduction"]}
 ///      CHECK:   ^bb1(%[[a0:.*]]: f32, %[[a1:.*]]: f32, %[[a2:.*]]: f32):
 //       CHECK:     %[[a3:.*]] = mulf %[[a0]], %[[a1]] : f32
 //       CHECK:     %[[a4:.*]] = addf %[[a2]], %[[a3]] : f32
 //       CHECK:     linalg.yield %[[a4]] : f32
 //       CHECK:   }: memref<?x?x?x?xf32>, memref<?x?x?x?xf32>, memref<?x?x?x?xf32>
 // clang-format on
 TEST_FUNC(linalg_conv_nhwc) {
TEST_FUNC(linalg_conv_nhwc) {
 
   f.print(llvm::outs());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_dilated_conv_nhwc
 //       CHECK:   linalg.generic {args_in = 2 : i64, args_out = 1 : i64,
-// CHECK-SAME: indexing_maps = [(d0, d1, d2, d3, d4, d5, d6) -> (d0, d3 * 3 + d5 * 5, d4 * 4 + d6 * 6, d2),
-// CHECK-SAME: (d0, d1, d2, d3, d4, d5, d6) -> (d5, d6, d2, d1),
-// CHECK-SAME: (d0, d1, d2, d3, d4, d5, d6) -> (d0, d3, d4, d1 + d2 * 7)],
+// CHECK-SAME: indexing_maps = [affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d3 * 3 + d5 * 5, d4 * 4 + d6 * 6, d2)>,
+// CHECK-SAME: affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5, d6, d2, d1)>,
+// CHECK-SAME: affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d3, d4, d1 + d2 * 7)>],
 // CHECK-SAME: iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel", "reduction", "reduction"]}
-///      CHECK:   ^bb1(%[[a0:.*]]: f32, %[[a1:.*]]: f32, %[[a2:.*]]: f32):
+//       CHECK:   ^bb1(%[[a0:.*]]: f32, %[[a1:.*]]: f32, %[[a2:.*]]: f32):
 //       CHECK:     %[[a3:.*]] = mulf %[[a0]], %[[a1]] : f32
 //       CHECK:     %[[a4:.*]] = addf %[[a2]], %[[a3]] : f32
 //       CHECK:     linalg.yield %[[a4]] : f32
 //       CHECK:   }: memref<?x?x?x?xf32>, memref<?x?x?x?xf32>, memref<?x?x?x?xf32>
 // clang-format on
 TEST_FUNC(linalg_dilated_conv_nhwc) {
   using namespace edsc;
   using namespace edsc::ops;
linalg_dilated_conv_nhwc(
       /*strides=*/{3, 4}, /*dilations=*/{5, 6});
 
   f.print(llvm::outs());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_metadata_ops
-//       CHECK: linalg.reshape {{.*}} [(d0, d1, d2) -> (d0, d1), (d0, d1, d2) -> (d2)] : memref<4x8x16xf32> into memref<32x16xf32>
-//       CHECK: linalg.reshape {{.*}} [(d0, d1, d2) -> (d0, d1), (d0, d1, d2) -> (d2)] : memref<32x16xf32> into memref<4x8x16xf32>
+//       CHECK: linalg.reshape {{.*}} [affine_map<(d0, d1, d2) -> (d0, d1)>, affine_map<(d0, d1, d2) -> (d2)>] : memref<4x8x16xf32> into memref<32x16xf32>
+//       CHECK: linalg.reshape {{.*}} [affine_map<(d0, d1, d2) -> (d0, d1)>, affine_map<(d0, d1, d2) -> (d2)>] : memref<32x16xf32> into memref<4x8x16xf32>
 // clang-format on
 TEST_FUNC(linalg_metadata_ops) {
   using namespace edsc;
   using namespace edsc::intrinsics;
 
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType = MemRefType::get({4, 8, 16}, f32Type, {}, 0);
   auto f = makeFunction("linalg_metadata_ops", {}, {memrefType});

mlir/test/IR/affine-map.mlir

 // RUN: mlir-opt %s | FileCheck %s
 
 // Identity maps used in trivial compositions in MemRefs are optimized away.
-// CHECK-NOT: #map{{[0-9]+}} = (d0, d1) -> (d0, d1)
-#map0 = (i, j) -> (i, j)
+// CHECK-NOT: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0, d1)>
+#map0 = affine_map<(i, j) -> (i, j)>
 
-// CHECK-NOT: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0, d1)
-#map1 = (i, j)[s0] -> (i, j)
+// CHECK-NOT: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0, d1)>
+#map1 = affine_map<(i, j)[s0] -> (i, j)>
 
-// CHECK: #map{{[0-9]+}} = () -> (0)
+// CHECK: #map{{[0-9]+}} = affine_map<() -> (0)>
 // A map may have 0 inputs.
 // However, an affine.apply always takes at least one input.
-#map2 = () -> (0)
+#map2 = affine_map<() -> (0)>
 
 // All the maps in the following block are equivalent and are unique'd as one
 // map. Therefore there should be only one output and we explicitly CHECK-NOT
 // for the others.
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0 + 1, d1 * 4 + 2)
-#map3  = (i, j) -> (i+1, 4*j + 2)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 + 1, d1 * 4 + 2)>
+#map3  = affine_map<(i, j) -> (i+1, 4*j + 2)>
 // CHECK-NOT: #map3{{[a-z]}}
-#map3a = (i, j) -> (1+i, 4*j + 2)
-#map3b = (i, j) -> (2 + 3 - 2*2 + i, 4*j + 2)
-#map3c = (i, j) -> (i +1 + 0, 4*j + 2)
-#map3d = (i, j) -> (i + 3 + 2 - 4, 4*j + 2)
-#map3e = (i, j) -> (1*i+3*2-2*2-1, 4*j + 2)
-#map3f = (i, j) -> (i + 1, 4*j*1 + 2)
-#map3g = (i, j) -> (i + 1, 2*2*j + 2)
-#map3h = (i, j) -> (i + 1, 2*j*2 + 2)
-#map3i = (i, j) -> (i + 1, j*2*2 + 2)
-#map3j = (i, j) -> (i + 1, j*1*4 + 2)
-#map3k = (i, j) -> (i + 1, j*4*1 + 2)
+#map3a = affine_map<(i, j) -> (1+i, 4*j + 2)>
+#map3b = affine_map<(i, j) -> (2 + 3 - 2*2 + i, 4*j + 2)>
+#map3c = affine_map<(i, j) -> (i +1 + 0, 4*j + 2)>
+#map3d = affine_map<(i, j) -> (i + 3 + 2 - 4, 4*j + 2)>
+#map3e = affine_map<(i, j) -> (1*i+3*2-2*2-1, 4*j + 2)>
+#map3f = affine_map<(i, j) -> (i + 1, 4*j*1 + 2)>
+#map3g = affine_map<(i, j) -> (i + 1, 2*2*j + 2)>
+#map3h = affine_map<(i, j) -> (i + 1, 2*j*2 + 2)>
+#map3i = affine_map<(i, j) -> (i + 1, j*2*2 + 2)>
+#map3j = affine_map<(i, j) -> (i + 1, j*1*4 + 2)>
+#map3k = affine_map<(i, j) -> (i + 1, j*4*1 + 2)>
 
 // The following reduction should be unique'd out too but such expression
 // simplification is not performed for IR parsing, but only through analyses
 // and transforms.
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d1 - d0 + (d0 - d1 + 1) * 2 + d1 - 1, d1 + d1 + d1 + d1 + 2)
-#map3l = (i, j) -> ((j - i) + 2*(i - j + 1) + j - 1 + 0, j + j + 1 + j + j + 1)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d1 - d0 + (d0 - d1 + 1) * 2 + d1 - 1, d1 + d1 + d1 + d1 + 2)>
+#map3l = affine_map<(i, j) -> ((j - i) + 2*(i - j + 1) + j - 1 + 0, j + j + 1 + j + j + 1)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0 + 2, d1)
-#map4  = (i, j) -> (3+3-2*2+i, j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 + 2, d1)>
+#map4  = affine_map<(i, j) -> (3+3-2*2+i, j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + s0, d1)
-#map5 = (i, j)[s0] -> (i + s0, j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>
+#map5 = affine_map<(i, j)[s0] -> (i + s0, j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + s0, d1 + 5)
-#map6 = (i, j)[s0] -> (i + s0, j + 5)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + s0, d1 + 5)>
+#map6 = affine_map<(i, j)[s0] -> (i + s0, j + 5)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + s0, d1)
-#map7 = (i, j)[s0] -> (i + j + s0, j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + s0, d1)>
+#map7 = affine_map<(i, j)[s0] -> (i + j + s0, j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + s0 + 5, d1)
-#map8 = (i, j)[s0] -> (5 + i + j + s0, j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + s0 + 5, d1)>
+#map8 = affine_map<(i, j)[s0] -> (5 + i + j + s0, j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + 5, d1)
-#map9 = (i, j)[s0] -> ((i + j) + 5, j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + 5, d1)>
+#map9 = affine_map<(i, j)[s0] -> ((i + j) + 5, j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + 5, d1)
-#map10 = (i, j)[s0] -> (i + (j + 5), j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + 5, d1)>
+#map10 = affine_map<(i, j)[s0] -> (i + (j + 5), j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 * 2, d1 * 3)
-#map11 = (i, j)[s0] -> (2*i, 3*j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 * 2, d1 * 3)>
+#map11 = affine_map<(i, j)[s0] -> (2*i, 3*j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + (d1 + s0 * 3) * 5 + 12, d1)
-#map12 = (i, j)[s0] -> (i + 2*6 + 5*(j+s0*3), j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + (d1 + s0 * 3) * 5 + 12, d1)>
+#map12 = affine_map<(i, j)[s0] -> (i + 2*6 + 5*(j+s0*3), j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 * 5 + d1, d1)
-#map13 = (i, j)[s0] -> (5*i + j, j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 * 5 + d1, d1)>
+#map13 = affine_map<(i, j)[s0] -> (5*i + j, j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1, d1)
-#map14 = (i, j)[s0] -> ((i + j), (j))
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1, d1)>
+#map14 = affine_map<(i, j)[s0] -> ((i + j), (j))>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + 7, d1 + 3)
-#map15 = (i, j)[s0] -> ((i + j + 2) + 5, (j)+3)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + 7, d1 + 3)>
+#map15 = affine_map<(i, j)[s0] -> ((i + j + 2) + 5, (j)+3)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0, 0)
-#map16 = (i, j)[s1] -> (i, 0)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0, 0)>
+#map16 = affine_map<(i, j)[s1] -> (i, 0)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0, d1 * s0)
-#map17 = (i, j)[s0] -> (i, s0*j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0, d1 * s0)>
+#map17 = affine_map<(i, j)[s0] -> (i, s0*j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0, d0 * 3 + d1)
-#map19 = (i, j) -> (i, 3*i + j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0, d0 * 3 + d1)>
+#map19 = affine_map<(i, j) -> (i, 3*i + j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0, d0 + d1 * 3)
-#map20 = (i, j)  -> (i, i + 3*j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0, d0 + d1 * 3)>
+#map20 = affine_map<(i, j)  -> (i, i + 3*j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0, d0 * ((s0 * s0) * 9) + 3)
-#map18 = (i, j)[N] -> (i, 2 + N*N*9*i + 1)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0, d0 * ((s0 * s0) * 9) + 3)>
+#map18 = affine_map<(i, j)[N] -> (i, 2 + N*N*9*i + 1)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (1, d0 + d1 * 3 + 5)
-#map21 = (i, j)  -> (1, i + 3*j + 5)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (1, d0 + d1 * 3 + 5)>
+#map21 = affine_map<(i, j)  -> (1, i + 3*j + 5)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (s0 * 5, d0 + d1 * 3 + d0 * 5)
-#map22 = (i, j)[s0] -> (5*s0, i + 3*j + 5*i)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (s0 * 5, d0 + d1 * 3 + d0 * 5)>
+#map22 = affine_map<(i, j)[s0] -> (5*s0, i + 3*j + 5*i)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0 * (s0 * s1), d1)
-#map23 = (i, j)[s0, s1] -> (i*(s0*s1), j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0 * (s0 * s1), d1)>
+#map23 = affine_map<(i, j)[s0, s1] -> (i*(s0*s1), j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d1 mod 5)
-#map24 = (i, j)[s0, s1] -> (i, j mod 5)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d1 mod 5)>
+#map24 = affine_map<(i, j)[s0, s1] -> (i, j mod 5)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d1 floordiv 5)
-#map25 = (i, j)[s0, s1] -> (i, j floordiv 5)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d1 floordiv 5)>
+#map25 = affine_map<(i, j)[s0, s1] -> (i, j floordiv 5)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d1 ceildiv 5)
-#map26 = (i, j)[s0, s1] -> (i, j ceildiv 5)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d1 ceildiv 5)>
+#map26 = affine_map<(i, j)[s0, s1] -> (i, j ceildiv 5)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d0 - d1 - 5)
-#map29 = (i, j)[s0, s1] -> (i, i - j - 5)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d0 - d1 - 5)>
+#map29 = affine_map<(i, j)[s0, s1] -> (i, i - j - 5)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d0 - d1 * s1 + 2)
-#map30 = (i, j)[M, N] -> (i, i - N*j + 2)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d0 - d1 * s1 + 2)>
+#map30 = affine_map<(i, j)[M, N] -> (i, i - N*j + 2)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0 * -5, d1 * -3, -2, -(d0 + d1), -s0)
-#map32 = (i, j)[s0, s1] -> (-5*i, -3*j, -2, -1*(i+j), -1*s0)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0 * -5, d1 * -3, -2, -(d0 + d1), -s0)>
+#map32 = affine_map<(i, j)[s0, s1] -> (-5*i, -3*j, -2, -1*(i+j), -1*s0)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (-4, -d0)
-#map33 = (i, j) -> (-2+-5-(-3), -1*i)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (-4, -d0)>
+#map33 = affine_map<(i, j) -> (-2+-5-(-3), -1*i)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0, d1 floordiv s0, d1 mod s0)
-#map34 = (i, j)[s0, s1] -> (i, j floordiv s0, j mod s0)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0, d1 floordiv s0, d1 mod s0)>
+#map34 = affine_map<(i, j)[s0, s1] -> (i, j floordiv s0, j mod s0)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1, d2)[s0, s1, s2] -> ((d0 * s1) * s2 + d1 * s1 + d2)
-#map35 = (i, j, k)[s0, s1, s2] -> (i*s1*s2 + j*s1 + k)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1, d2)[s0, s1, s2] -> ((d0 * s1) * s2 + d1 * s1 + d2)>
+#map35 = affine_map<(i, j, k)[s0, s1, s2] -> (i*s1*s2 + j*s1 + k)>
 
 // Constant folding.
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (8, 4, 1, 3, 2, 4)
-#map36 = (i, j) -> (5+3, 2*2, 8-7, 100 floordiv 32, 5 mod 3, 10 ceildiv 3)
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (4, 11, 512, 15)
-#map37 = (i, j) -> (5 mod 3 + 2, 5*3 - 4, 128 * (500 ceildiv 128), 40 floordiv 7 * 3)
-
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0 * 2 + 1, d1 + 2)
-#map38 = (i, j) -> (1 + i*2, 2 + j)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (8, 4, 1, 3, 2, 4)>
+#map36 = affine_map<(i, j) -> (5+3, 2*2, 8-7, 100 floordiv 32, 5 mod 3, 10 ceildiv 3)>
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (4, 11, 512, 15)>
+#map37 = affine_map<(i, j) -> (5 mod 3 + 2, 5*3 - 4, 128 * (500 ceildiv 128), 40 floordiv 7 * 3)>
+
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 * 2 + 1, d1 + 2)>
+#map38 = affine_map<(i, j) -> (1 + i*2, 2 + j)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0, s1] -> (d0 * s0, d0 + s0, d0 + 2, d1 * 2, s1 * 2, s0 + 2)
-#map39 = (i, j)[M, N] -> (i*M, M + i, 2+i, j*2, N*2, 2 + M)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0, s1] -> (d0 * s0, d0 + s0, d0 + 2, d1 * 2, s1 * 2, s0 + 2)>
+#map39 = affine_map<(i, j)[M, N] -> (i*M, M + i, 2+i, j*2, N*2, 2 + M)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> ((d0 * 5) floordiv 4, (d1 ceildiv 7) mod s0)
-#map43 = (i, j) [s0] -> ( i * 5 floordiv 4, j ceildiv 7 mod s0)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> ((d0 * 5) floordiv 4, (d1 ceildiv 7) mod s0)>
+#map43 = affine_map<(i, j) [s0] -> ( i * 5 floordiv 4, j ceildiv 7 mod s0)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0 - d1 * 2, (d1 * 6) floordiv 4)
-#map44 = (i, j) -> (i - 2*j, j * 6 floordiv 4)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 - d1 * 2, (d1 * 6) floordiv 4)>
+#map44 = affine_map<(i, j) -> (i - 2*j, j * 6 floordiv 4)>
 
 // Simplifications
-// CHECK: #map{{[0-9]+}} = (d0, d1, d2)[s0] -> (d0 + d1 + d2 + 1, d2 + d1, (d0 * s0) * 8)
-#map45 = (i, j, k) [N] -> (1 + i + 3 + j - 3 + k, k + 5 + j - 5, 2*i*4*N)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1, d2)[s0] -> (d0 + d1 + d2 + 1, d2 + d1, (d0 * s0) * 8)>
+#map45 = affine_map<(i, j, k) [N] -> (1 + i + 3 + j - 3 + k, k + 5 + j - 5, 2*i*4*N)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1, d2) -> (0, d1, d0 * 2, 0)
-#map46 = (i, j, k) -> (i*0, 1*j, i * 128 floordiv 64, j * 0 floordiv 64)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1, d2) -> (0, d1, d0 * 2, 0)>
+#map46 = affine_map<(i, j, k) -> (i*0, 1*j, i * 128 floordiv 64, j * 0 floordiv 64)>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1, d2) -> (d0, d0 * 4, 0, 0, 0)
-#map47 = (i, j, k) -> (i * 64 ceildiv 64, i * 512 ceildiv 128, 4 * j mod 4, 4*j*4 mod 8, k mod 1)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1, d2) -> (d0, d0 * 4, 0, 0, 0)>
+#map47 = affine_map<(i, j, k) -> (i * 64 ceildiv 64, i * 512 ceildiv 128, 4 * j mod 4, 4*j*4 mod 8, k mod 1)>
 
 // floordiv should resolve similarly to ceildiv and be unique'd out.
 // CHECK-NOT: #map48{{[a-z]}}
-#map48 = (i, j, k) -> (i * 64 floordiv 64, i * 512 floordiv 128, 4 * j mod 4, 4*j*4 mod 8)
+#map48 = affine_map<(i, j, k) -> (i * 64 floordiv 64, i * 512 floordiv 128, 4 * j mod 4, 4*j*4 mod 8)>
 
 // Simplifications for mod using known GCD's of the LHS expr.
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (0, 0, 0, 1)
-#map49 = (i, j)[s0] -> ( (i * 4 + 8) mod 4, 32 * j * s0 * 8 mod 256, (4*i + (j * (s0 * 2))) mod 2, (4*i + 3) mod 2)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (0, 0, 0, 1)>
+#map49 = affine_map<(i, j)[s0] -> ( (i * 4 + 8) mod 4, 32 * j * s0 * 8 mod 256, (4*i + (j * (s0 * 2))) mod 2, (4*i + 3) mod 2)>
 
 // Floordiv, ceildiv divide by one.
-// CHECK: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 * 2 + 1, d1 + s0)
-#map50 = (i, j)[s0] -> ( (i * 2 + 1) ceildiv 1, (j + s0) floordiv 1)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 * 2 + 1, d1 + s0)>
+#map50 = affine_map<(i, j)[s0] -> ( (i * 2 + 1) ceildiv 1, (j + s0) floordiv 1)>
 
 // floordiv, ceildiv, and mod where LHS is negative.
-// CHECK: #map{{[0-9]+}} = (d0) -> (-2, 1, -1)
-#map51 = (i) -> (-5 floordiv 3, -5 mod 3, -5 ceildiv 3)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0) -> (-2, 1, -1)>
+#map51 = affine_map<(i) -> (-5 floordiv 3, -5 mod 3, -5 ceildiv 3)>
 
 // Parenthesis elision.
-// CHECK: #map{{[0-9]+}} = (d0) -> (d0 * 16 - (d0 + 1) + 15)
-#map52 = (d0) -> (16*d0 + ((d0 + 1) * -1) + 15)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0) -> (d0 * 16 - (d0 + 1) + 15)>
+#map52 = affine_map<(d0) -> (16*d0 + ((d0 + 1) * -1) + 15)>
 
-// CHECK: #map{{[0-9]+}} = (d0) -> (d0 - (d0 + 1))
-#map53 = (d0) -> (d0 - (d0 + 1))
+// CHECK: #map{{[0-9]+}} = affine_map<(d0) -> (d0 - (d0 + 1))>
+#map53 = affine_map<(d0) -> (d0 - (d0 + 1))>
 
-// CHECK: #map{{[0-9]+}} = (d0)[s0] -> ((-s0) floordiv 4, d0 floordiv -1)
-#map54 = (d0)[s0] -> (-s0 floordiv 4, d0 floordiv -1)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0)[s0] -> ((-s0) floordiv 4, d0 floordiv -1)>
+#map54 = affine_map<(d0)[s0] -> (-s0 floordiv 4, d0 floordiv -1)>
 
-// CHECK: #map{{[0-9]+}} = () -> ()
-#map55 = () -> ()
+// CHECK: #map{{[0-9]+}} = affine_map<() -> ()>
+#map55 = affine_map<() -> ()>
 
-// CHECK: #map{{[0-9]+}} = (d0, d1) -> (d0, d0 * 2 + d1 * 4 + 2, 1, 2, (d0 * 4) mod 8)
-#map56 = (d0, d1) -> ((4*d0 + 2) floordiv 4, (4*d0 + 8*d1 + 5) floordiv 2, (2*d0 + 4*d1 + 3) mod 2, (3*d0 - 4) mod 3, (4*d0 + 8*d1) mod 8)
+// CHECK: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0, d0 * 2 + d1 * 4 + 2, 1, 2, (d0 * 4) mod 8)>
+#map56 = affine_map<(d0, d1) -> ((4*d0 + 2) floordiv 4, (4*d0 + 8*d1 + 5) floordiv 2, (2*d0 + 4*d1 + 3) mod 2, (3*d0 - 4) mod 3, (4*d0 + 8*d1) mod 8)>
 
 // Single identity maps are removed.
 // CHECK: func @f0(memref<2x4xi8, 1>)
 func @f0(memref<2x4xi8, #map0, 1>)
 
 // Single identity maps are removed.
 // CHECK: func @f1(memref<2x4xi8, 1>)
 func @f1(memref<2x4xi8, #map1, 1>)

mlir/test/IR/core-ops.mlir

 // RUN: mlir-opt %s | FileCheck %s
 // Verify the printed output can be parsed.
 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 // Verify the generic form can be parsed.
 // RUN: mlir-opt -mlir-print-op-generic %s | mlir-opt | FileCheck %s
 
-// CHECK: #map0 = (d0) -> (d0 + 1)
+// CHECK: #map0 = affine_map<(d0) -> (d0 + 1)>
 
-// CHECK: #map1 = ()[s0] -> (s0 + 1)
+// CHECK: #map1 = affine_map<()[s0] -> (s0 + 1)>
 
-// CHECK-DAG: #[[VIEW_MAP1:map[0-9]+]] = (d0, d1) -> (d0 * 4 + d1)
-// CHECK-DAG: #[[VIEW_MAP2:map[0-9]+]] = (d0, d1)[s0, s1] -> (d0 * s1 + d1 + s0)
-// CHECK-DAG: #[[VIEW_MAP3:map[0-9]+]] = (d0, d1)[s0] -> (d0 * s0 + d1)
-
-// CHECK-DAG: #[[BASE_MAP0:map[0-9]+]] = (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)
-// CHECK-DAG: #[[BASE_MAP3:map[0-9]+]] = (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)
-// CHECK-DAG: #[[SUBVIEW_MAP0:map[0-9]+]] = (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)
-
-// CHECK-DAG: #[[BASE_MAP1:map[0-9]+]] = (d0)[s0] -> (d0 + s0)
-// CHECK-DAG: #[[SUBVIEW_MAP1:map[0-9]+]] = (d0)[s0, s1] -> (d0 * s1 + s0)
-
-// CHECK-DAG: #[[BASE_MAP2:map[0-9]+]] = (d0, d1) -> (d0 * 22 + d1)
-// CHECK-DAG: #[[SUBVIEW_MAP2:map[0-9]+]] = (d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)
-// CHECK-DAG: #[[SUBVIEW_MAP3:map[0-9]+]] = (d0, d1, d2) -> (d0 * 16 + d1 * 4 + d2 + 8)
-// CHECK-DAG: #[[SUBVIEW_MAP4:map[0-9]+]] = (d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)
-// CHECK-DAG: #[[SUBVIEW_MAP5:map[0-9]+]] = (d0, d1)[s0] -> (d0 * 8 + s0 + d1 * 2)
+// CHECK-DAG: #[[VIEW_MAP1:map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1)>
+// CHECK-DAG: #[[VIEW_MAP2:map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + d1 + s0)>
+// CHECK-DAG: #[[VIEW_MAP3:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 * s0 + d1)>
+
+// CHECK-DAG: #[[BASE_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>
+// CHECK-DAG: #[[BASE_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)>
+// CHECK-DAG: #[[SUBVIEW_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+
+// CHECK-DAG: #[[BASE_MAP1:map[0-9]+]] = affine_map<(d0)[s0] -> (d0 + s0)>
+// CHECK-DAG: #[[SUBVIEW_MAP1:map[0-9]+]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
+
+// CHECK-DAG: #[[BASE_MAP2:map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 22 + d1)>
+// CHECK-DAG: #[[SUBVIEW_MAP2:map[0-9]+]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>
+// CHECK-DAG: #[[SUBVIEW_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 16 + d1 * 4 + d2 + 8)>
+// CHECK-DAG: #[[SUBVIEW_MAP4:map[0-9]+]] = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2)>
+// CHECK-DAG: #[[SUBVIEW_MAP5:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 * 8 + s0 + d1 * 2)>
 
 // CHECK-LABEL: func @func_with_ops(%arg0: f32) {
 func @func_with_ops(f32) {
 ^bb0(%a : f32):
   // CHECK: %0 = "getTensor"() : () -> tensor<4x4x?xf32>
   %t = "getTensor"() : () -> tensor<4x4x?xf32>
 
   // CHECK: %1 = dim %0, 2 : tensor<4x4x?xf32>

 }
 
 // CHECK-LABEL: func @affine_apply() {
 func @affine_apply() {
   %i = "std.constant"() {value = 0: index} : () -> index
   %j = "std.constant"() {value = 1: index} : () -> index
 
   // CHECK: affine.apply #map0(%c0)
-  %a = "affine.apply" (%i) { map = (d0) -> (d0 + 1) } :
+  %a = "affine.apply" (%i) { map = affine_map<(d0) -> (d0 + 1)> } :
     (index) -> (index)
 
   // CHECK: affine.apply #map1()[%c0]
-  %b = affine.apply ()[x] -> (x+1)()[%i]
+  %b = affine.apply affine_map<()[x] -> (x+1)>()[%i]
 
   return
 }
 
 // CHECK-LABEL: func @load_store_prefetch
 func @load_store_prefetch(memref<4x4xi32>, index) {
 ^bb0(%0: memref<4x4xi32>, %1: index):
   // CHECK: %0 = load %arg0[%arg1, %arg1] : memref<4x4xi32>

 }
 
 // CHECK-LABEL: func @memref_view(%arg0
 func @memref_view(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<2048xi8>
   // Test two dynamic sizes and dynamic offset.
   // CHECK: %{{.*}} = std.view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32, #[[VIEW_MAP2]]>
   %1 = view %0[%arg2][%arg0, %arg1]
-    : memref<2048xi8> to memref<?x?xf32, (d0, d1)[s0, s1] -> (d0 * s1 + d1 + s0)>
+    : memref<2048xi8> to memref<?x?xf32, affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + d1 + s0)>>
 
   // Test two dynamic sizes and static offset.
   // CHECK: %{{.*}} = std.view %0[][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32, #[[VIEW_MAP3]]>
   %2 = view %0[][%arg0, %arg1]
-    : memref<2048xi8> to memref<?x?xf32, (d0, d1)[s0] -> (d0 * s0 + d1)>
+    : memref<2048xi8> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * s0 + d1)>>
 
   // Test one dynamic size and dynamic offset.
   // CHECK: %{{.*}} = std.view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32, #[[VIEW_MAP2]]>
   %3 = view %0[%arg2][%arg1]
-    : memref<2048xi8> to memref<4x?xf32, (d0, d1)[s0, s1] -> (d0 * s1 + d1 + s0)>
+    : memref<2048xi8> to memref<4x?xf32, affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + d1 + s0)>>
 
   // Test one dynamic size and static offset.
   // CHECK: %{{.*}} = std.view %0[][%arg0] : memref<2048xi8> to memref<?x4xf32, #[[VIEW_MAP1]]>
   %4 = view %0[][%arg0]
-    : memref<2048xi8> to memref<?x4xf32, (d0, d1) -> (d0 * 4 + d1)>
+    : memref<2048xi8> to memref<?x4xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>>
 
   // Test static sizes and static offset.
   // CHECK: %{{.*}} = std.view %0[][] : memref<2048xi8> to memref<64x4xf32, #[[VIEW_MAP1]]>
   %5 = view %0[][]
-    : memref<2048xi8> to memref<64x4xf32, (d0, d1) -> (d0 * 4 + d1)>
+    : memref<2048xi8> to memref<64x4xf32, affine_map<(d0, d1) -> (d0 * 4 + d1)>>
   return
 }
 
 // CHECK-LABEL: func @memref_subview(%arg0
 func @memref_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
 
-  %0 = alloc() : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>
+  %0 = alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>>
   // CHECK: std.subview %0[%c0, %c0, %c0][%arg0, %arg1, %arg2][%c1, %c1, %c1] : memref<8x16x4xf32, #[[BASE_MAP0]]> to memref<?x?x?xf32, #[[SUBVIEW_MAP0]]>
   %1 = subview %0[%c0, %c0, %c0][%arg0, %arg1, %arg2][%c1, %c1, %c1]
-    : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)> to
+    : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>> to
       memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
 
-  %2 = alloc()[%arg2] : memref<64xf32, (d0)[s0] -> (d0 + s0)>
+  %2 = alloc()[%arg2] : memref<64xf32, affine_map<(d0)[s0] -> (d0 + s0)>>
  // CHECK: std.subview %2[%c1][%arg0][%c1] : memref<64xf32, #[[BASE_MAP1]]> to memref<?xf32, #[[SUBVIEW_MAP1]]>
   %3 = subview %2[%c1][%arg0][%c1]
-    : memref<64xf32, (d0)[s0] -> (d0 + s0)> to
-      memref<?xf32, (d0)[s0, s1] -> (d0 * s1 + s0)>
+    : memref<64xf32, affine_map<(d0)[s0] -> (d0 + s0)>> to
+      memref<?xf32, affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>>
 
-  %4 = alloc() : memref<64x22xf32, (d0, d1) -> (d0 * 22 + d1)>
+  %4 = alloc() : memref<64x22xf32, affine_map<(d0, d1) -> (d0 * 22 + d1)>>
   // CHECK: std.subview %4[%c0, %c1][%arg0, %arg1][%c1, %c0] : memref<64x22xf32, #[[BASE_MAP2]]> to memref<?x?xf32, #[[SUBVIEW_MAP2]]>
   %5 = subview %4[%c0, %c1][%arg0, %arg1][%c1, %c0]
-    : memref<64x22xf32, (d0, d1) -> (d0 * 22 + d1)> to
-      memref<?x?xf32, (d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>
+    : memref<64x22xf32, affine_map<(d0, d1) -> (d0 * 22 + d1)>> to
+      memref<?x?xf32, affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>>
 
   // CHECK: std.subview %0[][][] : memref<8x16x4xf32, #[[BASE_MAP0]]> to memref<4x4x4xf32, #[[SUBVIEW_MAP3]]>
   %6 = subview %0[][][]
-    : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)> to
-      memref<4x4x4xf32, (d0, d1, d2) -> (d0 * 16 + d1 * 4 + d2 + 8)>
+    : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>> to
+      memref<4x4x4xf32, affine_map<(d0, d1, d2) -> (d0 * 16 + d1 * 4 + d2 + 8)>>
 
   %7 = alloc(%arg1, %arg2) : memref<?x?xf32>
   // CHECK: std.subview {{%.*}}[][][] : memref<?x?xf32> to memref<4x4xf32, #[[SUBVIEW_MAP4]]>
   %8 = subview %7[][][]
     : memref<?x?xf32> to memref<4x4xf32, offset: ?, strides:[?, ?]>
 
   %9 = alloc() : memref<16x4xf32>
   // CHECK: std.subview {{%.*}}[{{%.*}}, {{%.*}}][][{{%.*}}, {{%.*}}] : memref<16x4xf32> to memref<4x4xf32, #[[SUBVIEW_MAP4]]
   %10 = subview %9[%arg1, %arg1][][%arg2, %arg2]
     : memref<16x4xf32> to memref<4x4xf32, offset: ?, strides:[?, ?]>
   // CHECK: std.subview {{%.*}}[{{%.*}}, {{%.*}}][][] : memref<16x4xf32> to memref<4x4xf32, #[[SUBVIEW_MAP5]]
   %11 = subview %9[%arg1, %arg2][][]
     : memref<16x4xf32> to memref<4x4xf32, offset: ?, strides:[8, 2]>
   return
 }
 
 // CHECK-LABEL: func @test_dimop(%arg0
 func @test_dimop(%arg0: tensor<4x4x?xf32>) {
   // CHECK: %0 = dim %arg0, 2 : tensor<4x4x?xf32>
   %0 = dim %arg0, 2 : tensor<4x4x?xf32>
   // use dim as an index to ensure type correctness
-  %1 = affine.apply (d0) -> (d0)(%0)
+  %1 = affine.apply affine_map<(d0) -> (d0)>(%0)
   return
 }
 
 // CHECK-LABEL: func @test_splat_op
 // CHECK-SAME: [[S:%arg[0-9]+]]: f32
 func @test_splat_op(%s : f32) {
   %v = splat %s : vector<8xf32>
   // CHECK: splat [[S]] : vector<8xf32>

mlir/test/IR/invalid-affinemap.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // Check different error cases.
 // -----
-#hello_world = (i, j) -> ((), j) // expected-error {{no expression inside parentheses}}
+#hello_world = affine_map<(i, j) -> ((), j)> // expected-error {{no expression inside parentheses}}
 
 // -----
-#hello_world = (i, j) -> (->, j) // expected-error {{expected affine expression}}
+#hello_world = affine_map<(i, j) -> (->, j) // expected-error {{expected affine expression}}
 
 // -----
-#hello_world = (i, j) -> (:) // expected-error {{expected affine expression}}
+#hello_world = affine_map<(i, j) -> (:) // expected-error {{expected affine expression}}
 
 // -----
-#hello_world = (i, j) -> (, j) // expected-error {{expected affine expression}}
+#hello_world = affine_map<(i, j) -> (, j)> // expected-error {{expected affine expression}}
 
 // -----
-#hello_world (i, j) [s0] -> (i, j) // expected-error {{expected '=' in attribute alias definition}}
+#hello_world affine_map<(i, j) [s0] -> (i, j)> // expected-error {{expected '=' in attribute alias definition}}
 
 // -----
-#hello_world = (i, j) [s0] -> (2*i*, 3*j*i*2 + 5) // expected-error {{missing right operand of binary op}}
+#hello_world = affine_map<(i, j) [s0] -> (2*i*, 3*j*i*2 + 5)> // expected-error {{missing right operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0] -> (i+, i+j+2 + 5) // expected-error {{missing right operand of binary op}}
+#hello_world = affine_map<(i, j) [s0] -> (i+, i+j+2 + 5)> // expected-error {{missing right operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0] -> ((s0 + i, j) // expected-error {{expected ')'}}
+#hello_world = affine_map<(i, j) [s0] -> ((s0 + i, j)> // expected-error {{expected ')'}}
 
 // -----
-#hello_world = (i, j) [s0] -> (((s0 + (i + j) + 5), j) // expected-error {{expected ')'}}
+#hello_world = affine_map<(i, j) [s0] -> (((s0 + (i + j) + 5), j)> // expected-error {{expected ')'}}
 
 // -----
-#hello_world = (i, j) [s0] -> i + s0, j) // expected-error {{expected '(' at start of affine map range}}
+#hello_world = affine_map<(i, j) [s0] -> i + s0, j)> // expected-error {{expected '(' at start of affine map range}}
 
 // -----
-#hello_world = (i, j) [s0] -> (x) // expected-error {{use of undeclared identifier}}
+#hello_world = affine_map<(i, j) [s0] -> (x)> // expected-error {{use of undeclared identifier}}
 
 // -----
-#hello_world = (i, j, i) [s0] -> (i) // expected-error {{redefinition of identifier 'i'}}
+#hello_world = affine_map<(i, j, i) [s0] -> (i)> // expected-error {{redefinition of identifier 'i'}}
 
 // -----
-#hello_world = (i, j) [s0, s1, s0] -> (i) // expected-error {{redefinition of identifier 's0'}}
+#hello_world = affine_map<(i, j) [s0, s1, s0] -> (i)> // expected-error {{redefinition of identifier 's0'}}
 
 // -----
-#hello_world = (i, j) [i, s0] -> (j) // expected-error {{redefinition of identifier 'i'}}
+#hello_world = affine_map<(i, j) [i, s0] -> (j)> // expected-error {{redefinition of identifier 'i'}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (+i, j) // expected-error {{missing left operand of binary op}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (+i, j)> // expected-error {{missing left operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (i, *j) // expected-error {{missing left operand of binary op}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (i, *j)> // expected-error {{missing left operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (floordiv i 2, j) // expected-error {{missing left operand of binary op}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (floordiv i 2, j)> // expected-error {{missing left operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (ceildiv i 2, j) // expected-error {{missing left operand of binary op}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (ceildiv i 2, j)> // expected-error {{missing left operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (mod i 2, j) // expected-error {{missing left operand of binary op}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (mod i 2, j)> // expected-error {{missing left operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (-(), j)
+#hello_world = affine_map<(i, j) [s0, s1] -> (-(), j)>
 // expected-error@-1 {{no expression inside parentheses}}
 // expected-error@-2 {{missing operand of negation}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (i, *j+5) // expected-error {{missing left operand of binary op}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (i, *j+5)> // expected-error {{missing left operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (i, floordiv j+5) // expected-error {{missing left operand of binary op}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (i, floordiv j+5)> // expected-error {{missing left operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (i, ceildiv j+5) // expected-error {{missing left operand of binary op}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (i, ceildiv j+5)> // expected-error {{missing left operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (i, mod j+5) // expected-error {{missing left operand of binary op}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (i, mod j+5)> // expected-error {{missing left operand of binary op}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (i*j, j) // expected-error {{non-affine expression: at least one of the multiply operands has to be either a constant or symbolic}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (i*j, j)> // expected-error {{non-affine expression: at least one of the multiply operands has to be either a constant or symbolic}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (i, j + j ceildiv 128 mod 16 * i - 4) // expected-error {{non-affine expression: at least one of the multiply operands has to be either a constant or symbolic}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (i, j + j ceildiv 128 mod 16 * i - 4)> // expected-error {{non-affine expression: at least one of the multiply operands has to be either a constant or symbolic}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (i, j floordiv i) // expected-error {{non-affine expression: right operand of floordiv has to be either a constant or symbolic}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (i, j floordiv i)> // expected-error {{non-affine expression: right operand of floordiv has to be either a constant or symbolic}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (i, i*2 ceildiv j*5) // expected-error {{non-affine expression: right operand of ceildiv has to be either a constant or symbolic}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (i, i*2 ceildiv j*5)> // expected-error {{non-affine expression: right operand of ceildiv has to be either a constant or symbolic}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (i, i mod (2+i)) // expected-error {{non-affine expression: right operand of mod has to be either a constant or symbolic}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (i, i mod (2+i))> // expected-error {{non-affine expression: right operand of mod has to be either a constant or symbolic}}
 
 // -----
-#hello_world = (i, j) [s0, s1] -> (-1*i j, j) // expected-error {{expected ',' or ')'}}
+#hello_world = affine_map<(i, j) [s0, s1] -> (-1*i j, j)> // expected-error {{expected ',' or ')'}}
 
 // -----
-#hello_world = (i, j) -> (i, 3*d0 + ) // expected-error {{use of undeclared identifier}}
+#hello_world = affine_map<(i, j) -> (i, 3*d0 + )> // expected-error {{use of undeclared identifier}}
 
 // TODO(bondhugula): Add more tests; coverage of error messages emitted not complete
 
 // -----
-#ABC = (i,j) -> (i+j)
-#ABC = (i,j) -> (i+j)  // expected-error {{redefinition of attribute alias id 'ABC'}}
+#ABC = affine_map<(i,j) -> (i+j)>
+#ABC = affine_map<(i,j) -> (i+j)>  // expected-error {{redefinition of attribute alias id 'ABC'}}

mlir/test/IR/invalid-ops.mlir

^bb0:
   return
 }
 
 // -----
 
 func @affine_apply_wrong_operand_count() {
 ^bb0:
   %i = constant 0 : index
-  %x = "affine.apply" (%i) {map = (d0, d1) -> ((d0 + 1), (d1 + 2))} : (index) -> (index) //  expected-error {{'affine.apply' op operand count and affine map dimension and symbol count must match}}
+  %x = "affine.apply" (%i) {map = affine_map<(d0, d1) -> ((d0 + 1), (d1 + 2))>} : (index) -> (index) //  expected-error {{'affine.apply' op operand count and affine map dimension and symbol count must match}}
   return
 }
 
 // -----
 
 func @affine_apply_wrong_result_count() {
 ^bb0:
   %i = constant 0 : index
   %j = constant 1 : index
-  %x = "affine.apply" (%i, %j) {map = (d0, d1) -> ((d0 + 1), (d1 + 2))} : (index,index) -> (index) //  expected-error {{'affine.apply' op mapping must produce one value}}
+  %x = "affine.apply" (%i, %j) {map = affine_map<(d0, d1) -> ((d0 + 1), (d1 + 2))>} : (index,index) -> (index) //  expected-error {{'affine.apply' op mapping must produce one value}}
   return
 }
 
 // -----
 
 func @unknown_custom_op() {
 ^bb0:
   %i = crazyThing() {value = 0} : () -> index  // expected-error {{custom op 'crazyThing' is unknown}}

 }
 
 // -----
 
 func @bad_alloc_wrong_dynamic_dim_count() {
 ^bb0:
   %0 = constant 7 : index
   // Test alloc with wrong number of dynamic dimensions.
-  %1 = alloc(%0)[%1] : memref<2x4xf32, (d0, d1)[s0] -> ((d0 + s0), d1), 1> // expected-error {{op 'std.alloc' dimension operand count does not equal memref dynamic dimension count}}
+  %1 = alloc(%0)[%1] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1> // expected-error {{op 'std.alloc' dimension operand count does not equal memref dynamic dimension count}}
   return
 }
 
 // -----
 
 func @bad_alloc_wrong_symbol_count() {
 ^bb0:
   %0 = constant 7 : index
   // Test alloc with wrong number of symbols
-  %1 = alloc(%0) : memref<2x?xf32, (d0, d1)[s0] -> ((d0 + s0), d1), 1> // expected-error {{operand count does not equal dimension plus symbol operand count}}
+  %1 = alloc(%0) : memref<2x?xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1> // expected-error {{operand count does not equal dimension plus symbol operand count}}
   return
 }
 
 // -----
 
 func @test_store_zero_results() {
 ^bb0:
-  %0 = alloc() : memref<1024x64xf32, (d0, d1) -> (d0, d1), 1>
+  %0 = alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
   %1 = constant 0 : index
   %2 = constant 1 : index
-  %3 = load %0[%1, %2] : memref<1024x64xf32, (d0, d1) -> (d0, d1), 1>
+  %3 = load %0[%1, %2] : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
   // Test that store returns zero results.
-  %4 = store %3, %0[%1, %2] : memref<1024x64xf32, (d0, d1) -> (d0, d1), 1> // expected-error {{cannot name an operation with no results}}
+  %4 = store %3, %0[%1, %2] : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1> // expected-error {{cannot name an operation with no results}}
   return
 }
 
 // -----
 
 func @test_store_zero_results2(%x: i32, %p: memref<i32>) {
   "std.store"(%x,%p) : (i32, memref<i32>) -> i32  // expected-error {{'std.store' op requires zero results}}
   return
 }
 
 // -----
 
 func @test_alloc_memref_map_rank_mismatch() {
 ^bb0:
-  %0 = alloc() : memref<1024x64xf32, (d0) -> (d0), 1> // expected-error {{memref affine map dimension mismatch}}
+  %0 = alloc() : memref<1024x64xf32, affine_map<(d0) -> (d0)>, 1> // expected-error {{memref affine map dimension mismatch}}
   return
 }
 
 // -----
 
 func @intlimit2() {
 ^bb:
   %0 = "std.constant"() {value = 0} : () -> i4096

 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<2048xi8>
   // expected-error@+1 {{incorrect number of operands for type}}
   %1 = view %0[][%arg0, %arg1]
-    : memref<2048xi8> to memref<?x?xf32, (d0, d1)[s0] -> (d0 * 4 + d1 + s0)>
+    : memref<2048xi8> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * 4 + d1 + s0)>>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<2048xi8>
   // expected-error@+1 {{is not strided}}
   %1 = view %0[][%arg0, %arg1]
-    : memref<2048xi8> to memref<?x?xf32, (d0, d1)[s0] -> (d0, d1, s0)>
+    : memref<2048xi8> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0, d1, s0)>>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<2048xf32>
   // expected-error@+1 {{must be 1D memref of 8-bit integer values}}
   %1 = view %0[][%arg0, %arg1]
-    : memref<2048xf32> to memref<?x?xf32, (d0, d1)[s0] -> (d0 * 4 + d1 + s0)>
+    : memref<2048xf32> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * 4 + d1 + s0)>>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<2048xi8, (d0) -> (d0 floordiv 8, d0 mod 8)>
+  %0 = alloc() : memref<2048xi8, affine_map<(d0) -> (d0 floordiv 8, d0 mod 8)>>
   // expected-error@+1 {{unsupported map for base memref}}
   %1 = view %0[][%arg0, %arg1]
-    : memref<2048xi8, (d0) -> (d0 floordiv 8, d0 mod 8)> to
-      memref<?x?xf32, (d0, d1)[s0] -> (d0 * 4 + d1 + s0)>
+    : memref<2048xi8, affine_map<(d0) -> (d0 floordiv 8, d0 mod 8)>> to
+      memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * 4 + d1 + s0)>>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<2048xi8, 2>
   // expected-error@+1 {{different memory spaces}}
   %1 = view %0[][%arg0, %arg1]
     : memref<2048xi8, 2> to
-      memref<?x?xf32, (d0, d1)[s0] -> (d0 * 4 + d1 + s0), 1>
+      memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * 4 + d1 + s0)>, 1>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<2048xi8>
   // expected-error@+1 {{incorrect dynamic strides}}
   %1 = view %0[][%arg0, %arg1]
     : memref<2048xi8> to
-      memref<?x?x4xf32, (d0, d1, d2) -> (d0 * 777 + d1 * 4 + d2)>
+      memref<?x?x4xf32, affine_map<(d0, d1, d2) -> (d0 * 777 + d1 * 4 + d2)>>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<2048xi8>
   // expected-error@+1 {{incorrect dynamic strides}}
   %1 = view %0[%arg0][]
     : memref<2048xi8> to
-      memref<16x4x?xf32, (d0, d1, d2) -> (d0 * 777 + d1 * 4 + d2)>
+      memref<16x4x?xf32, affine_map<(d0, d1, d2) -> (d0 * 777 + d1 * 4 + d2)>>
   return
 }
 
 // -----
 
 func @multiple_offsets(%arg0: index) {
   %0 = alloc() : memref<2048xi8>
   // expected-error@+1 {{expects 0 or 1 offset operand}}
   %1 = view %0[%arg0, %arg0][%arg0]
     : memref<2048xi8> to
-      memref<?x?x4xf32, (d0, d1, d2) -> (d0 * 777 + d1 * 4 + d2)>
+      memref<?x?x4xf32, affine_map<(d0, d1, d2) -> (d0 * 777 + d1 * 4 + d2)>>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2), 2>
+  %0 = alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>, 2>
   // expected-error@+1 {{different memory spaces}}
   %1 = subview %0[][%arg2][]
-    : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2), 2> to
-      memref<8x?x4xf32, (d0, d1, d2)[s0] -> (d0 * s0 + d1 * 4 + d2)>
+    : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>, 2> to
+      memref<8x?x4xf32, affine_map<(d0, d1, d2)[s0] -> (d0 * s0 + d1 * 4 + d2)>>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>
+  %0 = alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>>
   // expected-error@+1 {{is not strided}}
   %1 = subview %0[][%arg2][]
-    : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)> to
-      memref<8x?x4xf32, (d0, d1, d2)[s0] -> (d0 + s0, d1, d2)>
+    : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>> to
+      memref<8x?x4xf32, affine_map<(d0, d1, d2)[s0] -> (d0 + s0, d1, d2)>>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
-  %0 = alloc() : memref<8x16x4xf32, (d0, d1, d2) -> (d0 + d1, d1 + d2, d2)>
+  %0 = alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 + d1, d1 + d2, d2)>>
   // expected-error@+1 {{is not strided}}
   %1 = subview %0[][%arg2][]
-    : memref<8x16x4xf32, (d0, d1, d2) -> (d0 + d1, d1 + d2, d2)> to
-      memref<8x?x4xf32, (d0, d1, d2)[s0] -> (d0 * s0 + d1 * 4 + d2)>
+    : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 + d1, d1 + d2, d2)>> to
+      memref<8x?x4xf32, affine_map<(d0, d1, d2)[s0] -> (d0 * s0 + d1 * 4 + d2)>>
   return
 }
 
 // -----
 
 func @invalid_subview(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<8x16x4xf32>
   // expected-error@+1 {{expected number of dynamic offsets specified to match the rank of the result type}}
func @invalid_subview(%arg0 : index, %arg1 : memref<?x8x?xf32>) {
   // expected-error@+1 {{expected shape of result type to be fully dynamic when sizes are specified}}
   %0 = subview %arg1[%c0, %c0, %c0][%c1, %arg0, %c1][%c1, %c1, %c1] : memref<?x8x?xf32> to memref<?x8x?xf32, offset:?, strides:[?, ?, ?]>
   return
 }
 
 // -----
 
 func @invalid_memref_cast(%arg0 : memref<12x4x16xf32, offset:0, strides:[64, 16, 1]>) {
-  // expected-error@+1{{operand type 'memref<12x4x16xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 16 + d2)>' and result type 'memref<12x4x16xf32, (d0, d1, d2) -> (d0 * 128 + d1 * 32 + d2 * 2)>' are cast incompatible}}
+  // expected-error@+1{{operand type 'memref<12x4x16xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 16 + d2)>>' and result type 'memref<12x4x16xf32, affine_map<(d0, d1, d2) -> (d0 * 128 + d1 * 32 + d2 * 2)>>' are cast incompatible}}
   %0 = memref_cast %arg0 : memref<12x4x16xf32, offset:0, strides:[64, 16, 1]> to memref<12x4x16xf32, offset:0, strides:[128, 32, 2]>
   return
 }
 
 // -----
 
 func @invalid_memref_cast(%arg0 : memref<12x4x16xf32, offset:0, strides:[64, 16, 1]>) {
-  // expected-error@+1{{operand type 'memref<12x4x16xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 16 + d2)>' and result type 'memref<12x4x16xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 16 + d2 + 16)>' are cast incompatible}}
+  // expected-error@+1{{operand type 'memref<12x4x16xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 16 + d2)>>' and result type 'memref<12x4x16xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 16 + d2 + 16)>>' are cast incompatible}}
   %0 = memref_cast %arg0 : memref<12x4x16xf32, offset:0, strides:[64, 16, 1]> to memref<12x4x16xf32, offset:16, strides:[64, 16, 1]>
   return
 }
 
 // -----
 
 // incompatible element types
 func @invalid_memref_cast() {

mlir/test/IR/invalid.mlir

 func @memrefs(memref<2x4xi8, #map7>) // expected-error {{undefined symbol alias id 'map7'}}
 
 // -----
 // Test non affine map in memref type.
 func @memrefs(memref<2x4xi8, i8>) // expected-error {{expected affine map in memref type}}
 
 // -----
 // Test non-existent map in map composition of memref type.
-#map0 = (d0, d1) -> (d0, d1)
+#map0 = affine_map<(d0, d1) -> (d0, d1)>
 
 func @memrefs(memref<2x4xi8, #map0, #map8>) // expected-error {{undefined symbol alias id 'map8'}}
 
 // -----
 // Test multiple memory space error.
-#map0 = (d0, d1) -> (d0, d1)
+#map0 = affine_map<(d0, d1) -> (d0, d1)>
 func @memrefs(memref<2x4xi8, #map0, 1, 2>) // expected-error {{multiple memory spaces specified in memref type}}
 
 // -----
 // Test affine map after memory space.
-#map0 = (d0, d1) -> (d0, d1)
-#map1 = (d0, d1) -> (d0, d1)
+#map0 = affine_map<(d0, d1) -> (d0, d1)>
+#map1 = affine_map<(d0, d1) -> (d0, d1)>
 
 func @memrefs(memref<2x4xi8, #map0, 1, #map1>) // expected-error {{expected memory space to be last in memref type}}
 
 // -----
 // Test dimension mismatch between memref and layout map.
 // The error must be emitted even for the trivial identity layout maps that are
 // dropped in type creation.
-#map0 = (d0, d1) -> (d0, d1)
+#map0 = affine_map<(d0, d1) -> (d0, d1)>
 func @memrefs(memref<42xi8, #map0>) // expected-error {{memref affine map dimension mismatch}}
 
 // -----
 
-#map0 = (d0, d1) -> (d0, d1)
-#map1 = (d0) -> (d0)
+#map0 = affine_map<(d0, d1) -> (d0, d1)>
+#map1 = affine_map<(d0) -> (d0)>
 func @memrefs(memref<42x42xi8, #map0, #map1>) // expected-error {{memref affine map dimension mismatch}}
 
 // -----
 
 func @memref_space_after_strides(memref<42x42xi8, 0, offset: ?, strides: [?, ?]>) // expected-error {{expected memory space to be last in memref type}}
 
 // -----
 

 // -----
 
 func @incomplete_for() {
   affine.for %i = 1 to 10 step 2
 }        // expected-error {{expected '{' to begin a region}}
 
 // -----
 
-#map0 = (d0) -> (d0 floordiv 4)
+#map0 = affine_map<(d0) -> (d0 floordiv 4)>
 
 func @reference_to_iv_in_bound() {
   // expected-error@+2 {{region entry argument '%i0' is already in use}}
   // expected-note@+1 {{previously referenced here}}
   affine.for %i0 = #map0(%i0) to 10 {
   }
 }
 

 func @non_operation() {
   asd   // expected-error {{custom op 'asd' is unknown}}
 }
 
 // -----
 
 func @invalid_if_conditional2() {
   affine.for %i = 1 to 10 {
-    affine.if (i)[N] : (i >= )  // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
+    affine.if affine_set<(i)[N] : (i >= )>  // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
   }
 }
 
 // -----
 
 func @invalid_if_conditional3() {
   affine.for %i = 1 to 10 {
-    affine.if (i)[N] : (i == 1) // expected-error {{expected '0' after '=='}}
+    affine.if affine_set<(i)[N] : (i == 1)> // expected-error {{expected '0' after '=='}}
   }
 }
 
 // -----
 
 func @invalid_if_conditional4() {
   affine.for %i = 1 to 10 {
-    affine.if (i)[N] : (i >= 2) // expected-error {{expected '0' after '>='}}
+    affine.if affine_set<(i)[N] : (i >= 2)> // expected-error {{expected '0' after '>='}}
   }
 }
 
 // -----
 
 func @invalid_if_conditional5() {
   affine.for %i = 1 to 10 {
-    affine.if (i)[N] : (i <= 0 ) // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
+    affine.if affine_set<(i)[N] : (i <= 0)> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
   }
 }
 
 // -----
 
 func @invalid_if_conditional6() {
   affine.for %i = 1 to 10 {
-    affine.if (i) : (i) // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
+    affine.if affine_set<(i) : (i)> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
   }
 }
 
 // -----
 // TODO (support affine.if (1)?
 func @invalid_if_conditional7() {
   affine.for %i = 1 to 10 {
-    affine.if (i) : (1) // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
+    affine.if affine_set<(i) : (1)> // expected-error {{expected '== 0' or '>= 0' at end of affine constraint}}
   }
 }
 
 // -----
 
-#map = (d0) -> (%  // expected-error {{invalid SSA name}}
+#map = affine_map<(d0) -> (%  // expected-error {{invalid SSA name}}
 
 // -----
 
 func @test() {
 ^bb40:
   %1 = "foo"() : (i32)->i64 // expected-error {{expected 0 operand types but had 1}}
   return
 }

 func @undefined_function() {
 ^bb0:
   %x = constant @bar : (i32) -> ()  // expected-error {{reference to undefined function 'bar'}}
   return
 }
 
 // -----
 
-#map1 = (i)[j] -> (i+j)
+#map1 = affine_map<(i)[j] -> (i+j)>
 
 func @bound_symbol_mismatch(%N : index) {
   affine.for %i = #map1(%N) to 100 {
   // expected-error@-1 {{symbol operand count and integer set symbol count must match}}
   }
   return
 }
 
 // -----
 
-#map1 = (i)[j] -> (i+j)
+#map1 = affine_map<(i)[j] -> (i+j)>
 
 func @bound_dim_mismatch(%N : index) {
   affine.for %i = #map1(%N, %N)[%N] to 100 {
   // expected-error@-1 {{dim operand count and integer set dim count must match}}
   }
   return
 }
 
 // -----
 
 func @large_bound() {
   affine.for %i = 1 to 9223372036854775810 {
   // expected-error@-1 {{integer constant out of range for attribute}}
   }
   return
 }
 
 // -----
 
 func @max_in_upper_bound(%N : index) {
-  affine.for %i = 1 to max (i)->(N, 100) { //expected-error {{expected non-function type}}
+  affine.for %i = 1 to max affine_map<(i)->(N, 100)> { //expected-error {{expected non-function type}}
   }
   return
 }
 
 // -----
 
 func @step_typo() {
   affine.for %i = 1 to 100 step -- 1 { //expected-error {{expected constant integer}}
   }
   return
 }
 
 // -----
 
 func @invalid_bound_map(%N : i32) {
-  affine.for %i = 1 to (i)->(j)(%N) { //expected-error {{use of undeclared identifier}}
+  affine.for %i = 1 to affine_map<(i)->(j)>(%N) { //expected-error {{use of undeclared identifier}}
   }
   return
 }
 
 // -----
 
-#set0 = (i)[N, M] : )i >= 0) // expected-error {{expected '(' at start of integer set constraint list}}
+#set0 = affine_set<(i)[N, M] : )i >= 0)> // expected-error {{expected '(' at start of integer set constraint list}}
 
 // -----
-#set0 = (i)[N] : (i >= 0, N - i >= 0)
+#set0 = affine_set<(i)[N] : (i >= 0, N - i >= 0)>
 
 func @invalid_if_operands1(%N : index) {
   affine.for %i = 1 to 10 {
     affine.if #set0(%i) {
     // expected-error@-1 {{symbol operand count and integer set symbol count must match}}
 
 // -----
-#set0 = (i)[N] : (i >= 0, N - i >= 0)
+#set0 = affine_set<(i)[N] : (i >= 0, N - i >= 0)>
 
 func @invalid_if_operands2(%N : index) {
   affine.for %i = 1 to 10 {
     affine.if #set0()[%N] {
     // expected-error@-1 {{dim operand count and integer set dim count must match}}
 
 // -----
-#set0 = (i)[N] : (i >= 0, N - i >= 0)
+#set0 = affine_set<(i)[N] : (i >= 0, N - i >= 0)>
 
 func @invalid_if_operands3(%N : index) {
   affine.for %i = 1 to 10 {
     affine.if #set0(%i)[%i] {
     // expected-error@-1 {{operand cannot be used as a symbol}}
     }
   }
   return

 func @invalid_tensor_literal() {
   // expected-error @+1 {{expected element literal of primitive type}}
   "fooi16"(){bar = sparse<[[1, 1, 0], [0, 1, 0], [0,, [[0, 0, 0]], [-2.0]> : tensor<2x2x2xi16>} : () -> ()
 
 // -----
 
 func @invalid_affine_structure() {
   %c0 = constant 0 : index
-  %idx = affine.apply (d0, d1) (%c0, %c0) // expected-error {{expected '->' or ':'}}
+  %idx = affine.apply affine_map<(d0, d1)> (%c0, %c0) // expected-error {{expected '->' or ':'}}
   return
 }
 
 // -----
 
 func @missing_for_max(%arg0: index, %arg1: index, %arg2: memref<100xf32>) {
   // expected-error @+1 {{lower loop bound affine map with multiple results requires 'max' prefix}}
-  affine.for %i0 = ()[s]->(0,s-1)()[%arg0] to %arg1 {
+  affine.for %i0 = affine_map<()[s]->(0,s-1)>()[%arg0] to %arg1 {
   }
   return
 }
 
 // -----
 
 func @missing_for_min(%arg0: index, %arg1: index, %arg2: memref<100xf32>) {
   // expected-error @+1 {{upper loop bound affine map with multiple results requires 'min' prefix}}
-  affine.for %i0 = %arg0 to ()[s]->(100,s+1)()[%arg1] {
+  affine.for %i0 = %arg0 to affine_map<()[s]->(100,s+1)>()[%arg1] {
   }
   return
 }
 
 // -----
 
 // expected-error @+1 {{vector types must have positive constant sizes}}
 func @zero_vector_type() -> vector<0xi32>

mlir/test/IR/locations.mlir

 // RUN: mlir-opt %s -mlir-print-debuginfo | FileCheck %s
 // This test verifies that debug locations are round-trippable.
 
-#set0 = (d0) : (1 == 0)
+#set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK-LABEL: func @inline_notation
 func @inline_notation() -> i32 {
   // CHECK: -> i32 loc("foo")
   %1 = "foo"() : () -> i32 loc("foo")
 
   // CHECK: constant 4 : index loc(callsite("foo" at "mysource.cc":10:8))
   %2 = constant 4 : index loc(callsite("foo" at "mysource.cc":10:8))

mlir/test/IR/memory-ops.mlir

 // RUN: mlir-opt %s | FileCheck %s
 
-// CHECK: #map0 = (d0, d1)[s0] -> (d0 + s0, d1)
+// CHECK: #map0 = affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>
 
 // CHECK-LABEL: func @alloc() {
 func @alloc() {
 ^bb0:
   // Test simple alloc.
   // CHECK: %0 = alloc() : memref<1024x64xf32, 1>
-  %0 = alloc() : memref<1024x64xf32, (d0, d1) -> (d0, d1), 1>
+  %0 = alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   %c0 = "std.constant"() {value = 0: index} : () -> index
   %c1 = "std.constant"() {value = 1: index} : () -> index
 
   // Test alloc with dynamic dimensions.
   // CHECK: %1 = alloc(%c0, %c1) : memref<?x?xf32, 1>
-  %1 = alloc(%c0, %c1) : memref<?x?xf32, (d0, d1) -> (d0, d1), 1>
+  %1 = alloc(%c0, %c1) : memref<?x?xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   // Test alloc with no dynamic dimensions and one symbol.
   // CHECK: %2 = alloc()[%c0] : memref<2x4xf32, #map0, 1>
-  %2 = alloc()[%c0] : memref<2x4xf32, (d0, d1)[s0] -> ((d0 + s0), d1), 1>
+  %2 = alloc()[%c0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
 
   // Test alloc with dynamic dimensions and one symbol.
   // CHECK: %3 = alloc(%c1)[%c0] : memref<2x?xf32, #map0, 1>
-  %3 = alloc(%c1)[%c0] : memref<2x?xf32, (d0, d1)[s0] -> (d0 + s0, d1), 1>
+  %3 = alloc(%c1)[%c0] : memref<2x?xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>, 1>
 
   // Alloc with no mappings.
   // b/116054838 Parser crash while parsing ill-formed AllocOp
   // CHECK: %4 = alloc() : memref<2xi32>
   %4 = alloc() : memref<2 x i32>
 
   // CHECK:   return
   return
 }
 
 // CHECK-LABEL: func @dealloc() {
 func @dealloc() {
 ^bb0:
   // CHECK: %0 = alloc() : memref<1024x64xf32>
-  %0 = alloc() : memref<1024x64xf32, (d0, d1) -> (d0, d1), 0>
+  %0 = alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 0>
 
   // CHECK: dealloc %0 : memref<1024x64xf32>
-  dealloc %0 : memref<1024x64xf32, (d0, d1) -> (d0, d1), 0>
+  dealloc %0 : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 0>
   return
 }
 
 // CHECK-LABEL: func @load_store
 func @load_store() {
 ^bb0:
   // CHECK: %0 = alloc() : memref<1024x64xf32, 1>
-  %0 = alloc() : memref<1024x64xf32, (d0, d1) -> (d0, d1), 1>
+  %0 = alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   %1 = constant 0 : index
   %2 = constant 1 : index
 
   // CHECK: %1 = load %0[%c0, %c1] : memref<1024x64xf32, 1>
-  %3 = load %0[%1, %2] : memref<1024x64xf32, (d0, d1) -> (d0, d1), 1>
+  %3 = load %0[%1, %2] : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   // CHECK: store %1, %0[%c0, %c1] : memref<1024x64xf32, 1>
-  store %3, %0[%1, %2] : memref<1024x64xf32, (d0, d1) -> (d0, d1), 1>
+  store %3, %0[%1, %2] : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   return
 }
 
 // CHECK-LABEL: func @dma_ops()
 func @dma_ops() {
   %c0 = constant 0 : index
   %stride = constant 32 : index
   %elt_per_stride = constant 16 : index
 
-  %A = alloc() : memref<256 x f32, (d0) -> (d0), 0>
-  %Ah = alloc() : memref<256 x f32, (d0) -> (d0), 1>
+  %A = alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
+  %Ah = alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 1>
   %tag = alloc() : memref<1 x f32>
 
   %num_elements = constant 256 : index
 
   dma_start %A[%c0], %Ah[%c0], %num_elements, %tag[%c0] : memref<256 x f32>, memref<256 x f32, 1>, memref<1 x f32>
   dma_wait %tag[%c0], %num_elements : memref<1 x f32>
   // CHECK: dma_start %0[%c0], %1[%c0], %c256, %2[%c0] : memref<256xf32>, memref<256xf32, 1>, memref<1xf32>
   // CHECK-NEXT:  dma_wait %2[%c0], %c256 : memref<1xf32>

mlir/test/IR/opaque_locations.mlir

 // RUN: mlir-opt %s -test-opaque-loc -mlir-print-debuginfo | FileCheck %s
 // This test verifies that debug opaque locations can be printed.
 
-#set0 = (d0) : (1 == 0)
+#set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK: MyLocation: 0: 'foo' op
 // CHECK: nullptr: 'foo' op
 // CHECK: MyLocation: 0: 'foo' op
 // CHECK: MyLocation: 1: 'std.constant' op
 // CHECK: nullptr: 'std.constant' op
 // CHECK: MyLocation: 1: 'std.constant' op
 

mlir/test/IR/parser.mlir

 // RUN: mlir-opt %s | FileCheck %s
 
-// CHECK-DAG: #map{{[0-9]+}} = (d0, d1, d2, d3, d4)[s0] -> (d0, d1, d2, d4, d3)
-#map0 = (d0, d1, d2, d3, d4)[s0] -> (d0, d1, d2, d4, d3)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1, d2, d3, d4)[s0] -> (d0, d1, d2, d4, d3)>
+#map0 = affine_map<(d0, d1, d2, d3, d4)[s0] -> (d0, d1, d2, d4, d3)>
 
-// CHECK-DAG: #map{{[0-9]+}} = (d0) -> (d0)
-#map1 = (d0) -> (d0)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0) -> (d0)>
+#map1 = affine_map<(d0) -> (d0)>
 
-// CHECK-DAG: #map{{[0-9]+}} = (d0, d1, d2) -> (d0, d1, d2)
-#map2 = (d0, d1, d2) -> (d0, d1, d2)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
+#map2 = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
 
-// CHECK-DAG: #map{{[0-9]+}} = (d0, d1, d2) -> (d1, d0, d2)
-#map3 = (d0, d1, d2) -> (d1, d0, d2)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1, d2) -> (d1, d0, d2)>
+#map3 = affine_map<(d0, d1, d2) -> (d1, d0, d2)>
 
-// CHECK-DAG: #map{{[0-9]+}} = (d0, d1, d2) -> (d2, d1, d0)
-#map4 = (d0, d1, d2) -> (d2, d1, d0)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1, d2) -> (d2, d1, d0)>
+#map4 = affine_map<(d0, d1, d2) -> (d2, d1, d0)>
 
-// CHECK-DAG: #map{{[0-9]+}} = ()[s0] -> (0, s0 - 1)
-#inline_map_minmax_loop1 = ()[s0] -> (0, s0 - 1)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<()[s0] -> (0, s0 - 1)>
+#inline_map_minmax_loop1 = affine_map<()[s0] -> (0, s0 - 1)>
 
-// CHECK-DAG: #map{{[0-9]+}} = ()[s0] -> (100, s0 + 1)
-#inline_map_minmax_loop2 = ()[s0] -> (100, s0 + 1)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<()[s0] -> (100, s0 + 1)>
+#inline_map_minmax_loop2 = affine_map<()[s0] -> (100, s0 + 1)>
 
-// CHECK-DAG: #map{{[0-9]+}} = (d0, d1)[s0] -> (d0 + d1 + s0)
-#bound_map1 = (i, j)[s] -> (i + j + s)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1)[s0] -> (d0 + d1 + s0)>
+#bound_map1 = affine_map<(i, j)[s] -> (i + j + s)>
 
-// CHECK-DAG: #map{{[0-9]+}} = (d0, d1) -> (d0 + d1)
-#inline_map_loop_bounds2 = (d0, d1) -> (d0 + d1)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0, d1) -> (d0 + d1)>
+#inline_map_loop_bounds2 = affine_map<(d0, d1) -> (d0 + d1)>
 
-// CHECK-DAG: #map{{[0-9]+}} = (d0)[s0] -> (d0 + s0, d0 - s0)
-#bound_map2 = (i)[s] -> (i + s, i - s)
+// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0)[s0] -> (d0 + s0, d0 - s0)>
+#bound_map2 = affine_map<(i)[s] -> (i + s, i - s)>
 
 // All maps appear in arbitrary order before all sets, in arbitrary order.
 // CHECK-NOT: Placeholder
 
-// CHECK-DAG: #set{{[0-9]+}} = (d0)[s0, s1] : (d0 >= 0, -d0 + s0 >= 0, s0 - 5 == 0, -d0 + s1 + 1 >= 0)
-#set0 = (i)[N, M] : (i >= 0, -i + N >= 0, N - 5 == 0, -i + M + 1 >= 0)
+// CHECK-DAG: #set{{[0-9]+}} = affine_set<(d0)[s0, s1] : (d0 >= 0, -d0 + s0 >= 0, s0 - 5 == 0, -d0 + s1 + 1 >= 0)>
+#set0 = affine_set<(i)[N, M] : (i >= 0, -i + N >= 0, N - 5 == 0, -i + M + 1 >= 0)>
 
-// CHECK-DAG: #set{{[0-9]+}} = (d0, d1)[s0] : (d0 >= 0, d1 >= 0)
-#set1 = (d0, d1)[s0] : (d0 >= 0, d1 >= 0)
+// CHECK-DAG: #set{{[0-9]+}} = affine_set<(d0, d1)[s0] : (d0 >= 0, d1 >= 0)>
+#set1 = affine_set<(d0, d1)[s0] : (d0 >= 0, d1 >= 0)>
 
-// CHECK-DAG: #set{{[0-9]+}} = (d0) : (d0 - 1 == 0)
-#set2 = (d0) : (d0 - 1 == 0)
+// CHECK-DAG: #set{{[0-9]+}} = affine_set<(d0) : (d0 - 1 == 0)>
+#set2 = affine_set<(d0) : (d0 - 1 == 0)>
 
-// CHECK-DAG: [[SET_TRUE:#set[0-9]+]] = () : (0 == 0)
+// CHECK-DAG: [[SET_TRUE:#set[0-9]+]] = affine_set<() : (0 == 0)>
 
-// CHECK-DAG: #set{{[0-9]+}} = (d0)[s0] : (d0 - 2 >= 0, -d0 + 4 >= 0)
+// CHECK-DAG: #set{{[0-9]+}} = affine_set<(d0)[s0] : (d0 - 2 >= 0, -d0 + 4 >= 0)>
 
 // CHECK: func @foo(i32, i64) -> f32
 func @foo(i32, i64) -> f32
 
 // CHECK: func @bar()
 func @bar() -> ()
 
 // CHECK: func @baz() -> (i1, index, f32)

 func @memrefs23(memref<2x4x8xi8, #map2, #map3, 0>)
 
 // CHECK: func @memrefs234(memref<2x4x8xi8, #map{{[0-9]+}}, #map{{[0-9]+}}, 3>)
 func @memrefs234(memref<2x4x8xi8, #map2, #map3, #map4, 3>)
 
 // Test memref inline affine map compositions, minding that identity maps are removed.
 
 // CHECK: func @memrefs3(memref<2x4x8xi8>)
-func @memrefs3(memref<2x4x8xi8, (d0, d1, d2) -> (d0, d1, d2)>)
+func @memrefs3(memref<2x4x8xi8, affine_map<(d0, d1, d2) -> (d0, d1, d2)>>)
 
 // CHECK: func @memrefs33(memref<2x4x8xi8, #map{{[0-9]+}}, 1>)
-func @memrefs33(memref<2x4x8xi8, (d0, d1, d2) -> (d0, d1, d2), (d0, d1, d2) -> (d1, d0, d2), 1>)
+func @memrefs33(memref<2x4x8xi8, affine_map<(d0, d1, d2) -> (d0, d1, d2)>, affine_map<(d0, d1, d2) -> (d1, d0, d2)>, 1>)
 
 // CHECK: func @memrefs_drop_triv_id_inline(memref<2xi8>)
-func @memrefs_drop_triv_id_inline(memref<2xi8, (d0) -> (d0)>)
+func @memrefs_drop_triv_id_inline(memref<2xi8, affine_map<(d0) -> (d0)>>)
 
 // CHECK: func @memrefs_drop_triv_id_inline0(memref<2xi8>)
-func @memrefs_drop_triv_id_inline0(memref<2xi8, (d0) -> (d0), 0>)
+func @memrefs_drop_triv_id_inline0(memref<2xi8, affine_map<(d0) -> (d0)>, 0>)
 
 // CHECK: func @memrefs_drop_triv_id_inline1(memref<2xi8, 1>)
-func @memrefs_drop_triv_id_inline1(memref<2xi8, (d0) -> (d0), 1>)
+func @memrefs_drop_triv_id_inline1(memref<2xi8, affine_map<(d0) -> (d0)>, 1>)
 
 // Identity maps should be dropped from the composition, but not the pair of
 // "interchange" maps that, if composed, would be also an identity.
 // CHECK: func @memrefs_drop_triv_id_composition(memref<2x2xi8, #map{{[0-9]+}}, #map{{[0-9]+}}>)
 func @memrefs_drop_triv_id_composition(memref<2x2xi8,
-                                                (d0, d1) -> (d1, d0),
-                                                (d0, d1) -> (d0, d1),
-                                                (d0, d1) -> (d1, d0),
-                                                (d0, d1) -> (d0, d1),
-                                                (d0, d1) -> (d0, d1)>)
+                                                affine_map<(d0, d1) -> (d1, d0)>,
+                                                affine_map<(d0, d1) -> (d0, d1)>,
+                                                affine_map<(d0, d1) -> (d1, d0)>,
+                                                affine_map<(d0, d1) -> (d0, d1)>,
+                                                affine_map<(d0, d1) -> (d0, d1)>>)
 
 // CHECK: func @memrefs_drop_triv_id_trailing(memref<2x2xi8, #map{{[0-9]+}}>)
-func @memrefs_drop_triv_id_trailing(memref<2x2xi8, (d0, d1) -> (d1, d0),
-                                              (d0, d1) -> (d0, d1)>)
+func @memrefs_drop_triv_id_trailing(memref<2x2xi8, affine_map<(d0, d1) -> (d1, d0)>,
+                                                   affine_map<(d0, d1) -> (d0, d1)>>)
 
 // CHECK: func @memrefs_drop_triv_id_middle(memref<2x2xi8, #map{{[0-9]+}}, #map{{[0-9]+}}>)
 func @memrefs_drop_triv_id_middle(memref<2x2xi8,
-                                         (d0, d1) -> (d0, d1 + 1),
-                                         (d0, d1) -> (d0, d1),
-                                         (d0, d1) -> (d0 + 1, d1)>)
+                                         affine_map<(d0, d1) -> (d0, d1 + 1)>,
+                                         affine_map<(d0, d1) -> (d0, d1)>,
+                                         affine_map<(d0, d1) -> (d0 + 1, d1)>>)
 
 // CHECK: func @memrefs_drop_triv_id_multiple(memref<2xi8>)
-func @memrefs_drop_triv_id_multiple(memref<2xi8, (d0) -> (d0), (d0) -> (d0)>)
+func @memrefs_drop_triv_id_multiple(memref<2xi8, affine_map<(d0) -> (d0)>, affine_map<(d0) -> (d0)>>)
 
 // These maps appeared before, so they must be uniqued and hoisted to the beginning.
 // Identity map should be removed.
 // CHECK: func @memrefs_compose_with_id(memref<2x2xi8, #map{{[0-9]+}}>)
-func @memrefs_compose_with_id(memref<2x2xi8, (d0, d1) -> (d0, d1),
-                                        (d0, d1) -> (d1, d0)>)
+func @memrefs_compose_with_id(memref<2x2xi8, affine_map<(d0, d1) -> (d0, d1)>,
+                                             affine_map<(d0, d1) -> (d1, d0)>>)
 
 
 // CHECK: func @complex_types(complex<i1>) -> complex<f32>
 func @complex_types(complex<i1>) -> complex<f32>
 
 // CHECK: func @functions((memref<1x?x4x?x?xi32, #map0>, memref<8xi8>) -> (), () -> ())
 func @functions((memref<1x?x4x?x?xi32, #map0, 0>, memref<8xi8, #map1, 0>) -> (), ()->())
 
func @complex_loops() {
   }                         // CHECK:   }
   return                    // CHECK:   return
 }                           // CHECK: }
 
 // CHECK: func @triang_loop(%{{.*}}: index, %{{.*}}: memref<?x?xi32>) {
 func @triang_loop(%arg0: index, %arg1: memref<?x?xi32>) {
   %c = constant 0 : i32       // CHECK: %{{.*}} = constant 0 : i32
   affine.for %i0 = 1 to %arg0 {      // CHECK: affine.for %{{.*}} = 1 to %{{.*}} {
-    affine.for %i1 = (d0)[]->(d0)(%i0)[] to %arg0 {  // CHECK:   affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to %{{.*}} {
+    affine.for %i1 = affine_map<(d0)[]->(d0)>(%i0)[] to %arg0 {  // CHECK:   affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to %{{.*}} {
       store %c, %arg1[%i0, %i1] : memref<?x?xi32>  // CHECK: store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}]
     }          // CHECK:     }
   }            // CHECK:   }
   return       // CHECK:   return
 }              // CHECK: }
 
 // CHECK: func @minmax_loop(%{{.*}}: index, %{{.*}}: index, %{{.*}}: memref<100xf32>) {
 func @minmax_loop(%arg0: index, %arg1: index, %arg2: memref<100xf32>) {
   // CHECK: affine.for %{{.*}} = max #map{{.*}}()[%{{.*}}] to min #map{{.*}}()[%{{.*}}] {
-  affine.for %i0 = max()[s]->(0,s-1)()[%arg0] to min()[s]->(100,s+1)()[%arg1] {
+  affine.for %i0 = max affine_map<()[s]->(0,s-1)>()[%arg0] to min affine_map<()[s]->(100,s+1)>()[%arg1] {
     // CHECK: "foo"(%{{.*}}, %{{.*}}) : (memref<100xf32>, index) -> ()
     "foo"(%arg2, %i0) : (memref<100xf32>, index) -> ()
   }      // CHECK:   }
   return // CHECK:   return
 }        // CHECK: }
 
 // CHECK-LABEL: func @loop_bounds(%{{.*}}: index) {
 func @loop_bounds(%N : index) {
   // CHECK: %{{.*}} = "foo"(%{{.*}}) : (index) -> index
   %s = "foo"(%N) : (index) -> index
   // CHECK: affine.for %{{.*}} = %{{.*}} to %{{.*}}
   affine.for %i = %s to %N {
     // CHECK: affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to 0
-    affine.for %j = (d0)[]->(d0)(%i)[] to 0 step 1 {
+    affine.for %j = affine_map<(d0)[]->(d0)>(%i)[] to 0 step 1 {
        // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}]
-       %w1 = affine.apply(d0, d1)[s0] -> (d0+d1) (%i, %j) [%s]
+       %w1 = affine.apply affine_map<(d0, d1)[s0] -> (d0+d1)> (%i, %j) [%s]
        // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}]
-       %w2 = affine.apply(d0, d1)[s0] -> (s0+1) (%i, %j) [%s]
+       %w2 = affine.apply affine_map<(d0, d1)[s0] -> (s0+1)> (%i, %j) [%s]
        // CHECK: affine.for %{{.*}} = #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}] to #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}] {
-       affine.for %k = #bound_map1 (%w1, %i)[%N] to (i, j)[s] -> (i + j + s) (%w2, %j)[%s] {
+       affine.for %k = #bound_map1 (%w1, %i)[%N] to affine_map<(i, j)[s] -> (i + j + s)> (%w2, %j)[%s] {
           // CHECK: "foo"(%{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index) -> ()
           "foo"(%i, %j, %k) : (index, index, index)->()
           // CHECK: %{{.*}} = constant 30 : index
           %c = constant 30 : index
           // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})
-          %u = affine.apply (d0, d1)->(d0+d1) (%N, %c)
+          %u = affine.apply affine_map<(d0, d1)->(d0+d1)> (%N, %c)
           // CHECK: affine.for %{{.*}} = max #map{{.*}}(%{{.*}})[%{{.*}}] to min #map{{.*}}(%{{.*}})[%{{.*}}] {
           affine.for %l = max #bound_map2(%i)[%u] to min #bound_map2(%k)[%c] {
             // CHECK: "bar"(%{{.*}}) : (index) -> ()
             "bar"(%l) : (index) -> ()
           } // CHECK:           }
        }    // CHECK:         }
      }      // CHECK:       }
   }         // CHECK:     }
   return    // CHECK:   return
 }           // CHECK: }
 
 // CHECK-LABEL: func @ifinst(%{{.*}}: index) {
 func @ifinst(%N: index) {
   %c = constant 200 : index // CHECK   %{{.*}} = constant 200
   affine.for %i = 1 to 10 {           // CHECK   affine.for %{{.*}} = 1 to 10 {
     affine.if #set0(%i)[%N, %c] {     // CHECK     affine.if #set0(%{{.*}})[%{{.*}}, %{{.*}}] {
       %x = constant 1 : i32
        // CHECK: %{{.*}} = constant 1 : i32
       %y = "add"(%x, %i) : (i32, index) -> i32 // CHECK: %{{.*}} = "add"(%{{.*}}, %{{.*}}) : (i32, index) -> i32
       %z = "mul"(%y, %y) : (i32, i32) -> i32 // CHECK: %{{.*}} = "mul"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
     } else { // CHECK } else {
-      affine.if (i)[N] : (i - 2 >= 0, 4 - i >= 0)(%i)[%N]  {      // CHECK  affine.if (#set1(%{{.*}})[%{{.*}}]) {
+      affine.if affine_set<(i)[N] : (i - 2 >= 0, 4 - i >= 0)>(%i)[%N]  {      // CHECK  affine.if (#set1(%{{.*}})[%{{.*}}]) {
         // CHECK: %{{.*}} = constant 1 : index
         %u = constant 1 : index
         // CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}]
-        %w = affine.apply (d0,d1)[s0] -> (d0+d1+s0) (%i, %i) [%u]
+        %w = affine.apply affine_map<(d0,d1)[s0] -> (d0+d1+s0)> (%i, %i) [%u]
       } else {            // CHECK     } else {
         %v = constant 3 : i32 // %c3_i32 = constant 3 : i32
       }
     }       // CHECK     }
   }         // CHECK   }
   return    // CHECK   return
 }           // CHECK }
 
func @attributes() {
 
   // CHECK: "foo"() {a = 1 : i64, b = -423 : i64, c = [true, false], d = 1.600000e+01 : f64}  : () -> ()
   "foo"() {a = 1, b = -423, c = [true, false], d = 16.0 } : () -> ()
 
   // CHECK: "foo"() {map1 = #map{{[0-9]+}}}
   "foo"() {map1 = #map1} : () -> ()
 
   // CHECK: "foo"() {map2 = #map{{[0-9]+}}}
-  "foo"() {map2 = (d0, d1, d2) -> (d0, d1, d2)} : () -> ()
+  "foo"() {map2 = affine_map<(d0, d1, d2) -> (d0, d1, d2)>} : () -> ()
 
   // CHECK: "foo"() {map12 = [#map{{[0-9]+}}, #map{{[0-9]+}}]}
   "foo"() {map12 = [#map1, #map2]} : () -> ()
 
   // CHECK: "foo"() {set1 = #set{{[0-9]+}}}
   "foo"() {set1 = #set1} : () -> ()
 
   // CHECK: "foo"() {set2 = #set{{[0-9]+}}}
-  "foo"() {set2 = (d0, d1, d2) : (d0 >= 0, d1 >= 0, d2 - d1 == 0)} : () -> ()
+  "foo"() {set2 = affine_set<(d0, d1, d2) : (d0 >= 0, d1 >= 0, d2 - d1 == 0)>} : () -> ()
 
   // CHECK: "foo"() {set12 = [#set{{[0-9]+}}, #set{{[0-9]+}}]}
   "foo"() {set12 = [#set1, #set2]} : () -> ()
 
   // CHECK: "foo"() {dictionary = {bool = true, fn = @ifinst}}
   "foo"() {dictionary = {bool = true, fn = @ifinst}} : () -> ()
 
   // Check that the dictionary attribute elements are sorted.

 // CHECK-LABEL: func @funcattrwithblock
 func @funcattrwithblock() -> ()
   attributes {} {
 ^bb0:
   return
 }
 
 // CHECK-label func @funcsimplemap
-#map_simple0 = ()[] -> (10)
-#map_simple1 = ()[s0] -> (s0)
-#map_non_simple0 = (d0)[] -> (d0)
-#map_non_simple1 = (d0)[s0] -> (d0 + s0)
-#map_non_simple2 = ()[s0, s1] -> (s0 + s1)
-#map_non_simple3 = ()[s0] -> (s0 + 3)
+#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 @funcsimplemap(%arg0: index, %arg1: index) -> () {
   affine.for %i0 = 0 to #map_simple0()[] {
   // CHECK: affine.for %{{.*}} = 0 to 10 {
     affine.for %i1 = 0 to #map_simple1()[%arg1] {
     // CHECK: affine.for %{{.*}} = 0 to %{{.*}} {
       affine.for %i2 = 0 to #map_non_simple0(%i0)[] {
       // CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}(%{{.*}}) {
         affine.for %i3 = 0 to #map_non_simple1(%i0)[%arg1] {
func @type_alias() -> !i32_type_alias {
   // Return a non-aliased i32 type.
   %0 = "foo"() : () -> i32
   return %0 : i32
 }
 
 // CHECK-LABEL: func @no_integer_set_constraints(
 func @no_integer_set_constraints() {
   // CHECK: affine.if [[SET_TRUE]]() {
-  affine.if () : () () {
+  affine.if affine_set<() : ()> () {
   }
   return
 }
 
 // CHECK-LABEL: func @verbose_if(
 func @verbose_if(%N: index) {
   %c = constant 200 : index
 

mlir/test/IR/pretty-locations.mlir

 // RUN: mlir-opt %s -mlir-print-debuginfo -mlir-pretty-debuginfo | FileCheck %s
 
-#set0 = (d0) : (1 == 0)
+#set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK-LABEL: func @inline_notation
 func @inline_notation() -> i32 {
   // CHECK: -> i32 "foo"
   %1 = "foo"() : () -> i32 loc("foo")
 
   // CHECK: constant 4 : index "foo" at mysource.cc:10:8
   %2 = constant 4 : index loc(callsite("foo" at "mysource.cc":10:8))

mlir/test/IR/print-op-local-scope.mlir

 // RUN: mlir-opt %s -mlir-print-local-scope | FileCheck %s --dump-input-on-failure
 
-// CHECK: "foo.op"() : () -> memref<?xf32, (d0) -> (d0 * 2)>
-"foo.op"() : () -> (memref<?xf32, (d0) -> (2*d0)>)
+// CHECK: "foo.op"() : () -> memref<?xf32, affine_map<(d0) -> (d0 * 2)>>
+"foo.op"() : () -> (memref<?xf32, affine_map<(d0) -> (2*d0)>>)
 

mlir/test/Transforms/Vectorize/compose_maps.mlir

 // RUN: mlir-opt %s -affine-vectorizer-test -compose-maps 2>&1 |  FileCheck %s
 
 // For all these cases, the test traverses the `test_affine_map` ops and
 // composes them in order one-by-one.
 // For instance, the pseudo-sequence:
 //    "test_affine_map"() { affine_map = f } : () -> ()
 //    "test_affine_map"() { affine_map = g } : () -> ()
 //    "test_affine_map"() { affine_map = h } : () -> ()
 // will produce the sequence of compositions: f, g(f), h(g(f)) and print the
 // AffineMap h(g(f)), which is what FileCheck checks against.
 
 func @simple1() {
   // CHECK: Composed map: (d0) -> (d0)
-  "test_affine_map"() { affine_map = (d0) -> (d0 - 1) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 + 1) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 - 1)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 + 1)> } : () -> ()
   return
 }
 
 func @simple2() {
   // CHECK: Composed map: (d0)[s0, s1] -> (d0 - s0 + s1)
-  "test_affine_map"() { affine_map = (d0)[s0] -> (d0 + s0 - 1) } : () -> ()
-  "test_affine_map"() { affine_map = (d0)[s0] -> (d0 - s0 + 1) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0)[s0] -> (d0 + s0 - 1)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0)[s0] -> (d0 - s0 + 1)> } : () -> ()
   return
 }
 
 func @simple3a() {
   // CHECK: Composed map: (d0, d1)[s0, s1, s2, s3] -> ((d0 ceildiv s2) * s0, (d1 ceildiv s3) * s1)
-  "test_affine_map"() { affine_map = (d0, d1)[s0, s1] -> (d0 ceildiv s0, d1 ceildiv s1) } : () -> ()
-  "test_affine_map"() { affine_map = (d0, d1)[s0, s1] -> (d0 * s0, d1 * s1) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> (d0 ceildiv s0, d1 ceildiv s1)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> (d0 * s0, d1 * s1)> } : () -> ()
   return
 }
 
 func @simple3b() {
   // CHECK: Composed map: (d0, d1)[s0, s1] -> (d0 mod s0, d1 mod s1)
-  "test_affine_map"() { affine_map = (d0, d1)[s0, s1] -> (d0 mod s0, d1 mod s1) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> (d0 mod s0, d1 mod s1)> } : () -> ()
   return
 }
 
 func @simple3c() {
   // CHECK: Composed map: (d0, d1)[s0, s1, s2, s3, s4, s5] -> ((d0 ceildiv s4) * s4 + d0 mod s2, (d1 ceildiv s5) * s5 + d1 mod s3)
-  "test_affine_map"() { affine_map = (d0, d1)[s0, s1] -> ((d0 ceildiv s0) * s0, (d1 ceildiv s1) * s1, d0, d1) } : () -> ()
-  "test_affine_map"() { affine_map = (d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 + d2 mod s2, d1 + d3 mod s3) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> ((d0 ceildiv s0) * s0, (d1 ceildiv s1) * s1, d0, d1)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1, d2, d3)[s0, s1, s2, s3] -> (d0 + d2 mod s2, d1 + d3 mod s3)> } : () -> ()
   return
 }
 
 func @simple4() {
   // CHECK: Composed map: (d0, d1)[s0, s1] -> (d1 * s1, d0 ceildiv s0)
-  "test_affine_map"() { affine_map = (d0, d1) -> (d1, d0) } : () -> ()
-  "test_affine_map"() { affine_map = (d0, d1)[s0, s1] -> (d0 * s1, d1 ceildiv s0) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1) -> (d1, d0)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> (d0 * s1, d1 ceildiv s0)> } : () -> ()
   return
 }
 
 func @simple5a() {
   // CHECK: Composed map: (d0) -> (d0 * 3 + 18)
-  "test_affine_map"() { affine_map = (d0) -> (d0 - 1) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 + 7) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 * 24) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 ceildiv 8) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 - 1)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 + 7)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 * 24)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 ceildiv 8)> } : () -> ()
   return
 }
 
 func @simple5b() {
   // CHECK: Composed map: (d0) -> ((d0 + 6) ceildiv 2)
-  "test_affine_map"() { affine_map = (d0) -> (d0 - 1) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 + 7) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 * 4) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 ceildiv 8) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 - 1)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 + 7)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 * 4)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 ceildiv 8)> } : () -> ()
   return
 }
 
 func @simple5c() {
   // CHECK: Composed map: (d0) -> (d0 * 8 + 48)
-  "test_affine_map"() { affine_map = (d0) -> (d0 - 1) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 + 7) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 * 24) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 floordiv 3) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 - 1)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 + 7)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 * 24)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 floordiv 3)> } : () -> ()
   return
 }
 
 func @simple5d() {
   // CHECK: Composed map: (d0) -> ((d0 * 4) floordiv 3 + 8)
-  "test_affine_map"() { affine_map = (d0) -> (d0 - 1) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 + 7) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 * 4) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 floordiv 3) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 - 1)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 + 7)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 * 4)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 floordiv 3)> } : () -> ()
   return
 }
 
 func @simple5e() {
   // CHECK: Composed map: (d0) -> ((d0 + 6) ceildiv 8)
-  "test_affine_map"() { affine_map = (d0) -> (d0 - 1) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 + 7) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 ceildiv 8) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 - 1)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 + 7)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 ceildiv 8)> } : () -> ()
   return
 }
 
 func @simple5f() {
   // CHECK: Composed map: (d0) -> ((d0 * 4 - 4) floordiv 3)
-  "test_affine_map"() { affine_map = (d0) -> (d0 - 1) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 * 4) } : () -> ()
-  "test_affine_map"() { affine_map = (d0) -> (d0 floordiv 3) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 - 1)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 * 4)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0) -> (d0 floordiv 3)> } : () -> ()
   return
 }
 
 func @perm_and_proj() {
   // CHECK: Composed map: (d0, d1, d2, d3) -> (d1, d3, d0)
-  "test_affine_map"() { affine_map = (d0, d1, d2, d3) -> (d3, d1, d2, d0) } : () -> ()
-  "test_affine_map"() { affine_map = (d0, d1, d2, d3) -> (d1, d0, d3) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1, d2, d3) -> (d3, d1, d2, d0)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1, d2, d3) -> (d1, d0, d3)> } : () -> ()
   return
 }
 
 func @symbols1() {
   // CHECK: Composed map: (d0)[s0] -> (d0 + s0 + 1, d0 - s0 - 1)
-  "test_affine_map"() { affine_map = (d0)[s0] -> (d0 + s0, d0 - s0) } : () -> ()
-  "test_affine_map"() { affine_map = (d0, d1) -> (d0 + 1, d1 - 1) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0)[s0] -> (d0 + s0, d0 - s0)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1) -> (d0 + 1, d1 - 1)> } : () -> ()
   return
 }
 
 func @drop() {
   // CHECK: Composed map: (d0, d1, d2)[s0, s1] -> (d0 * 2 + d1 + d2 + s1)
-  "test_affine_map"() { affine_map = (d0, d1, d2)[s0, s1] -> (d0 + s1, d1 + s0, d0 + d1 + d2) } : () -> ()
-  "test_affine_map"() { affine_map = (d0, d1, d2) -> (d0 + d2) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1, d2)[s0, s1] -> (d0 + s1, d1 + s0, d0 + d1 + d2)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1, d2) -> (d0 + d2)> } : () -> ()
   return
 }
 
 func @multi_symbols() {
   // CHECK: Composed map: (d0)[s0, s1, s2] -> (d0 + s1 + s2 + 1, d0 - s0 - s2 - 1)
-  "test_affine_map"() { affine_map = (d0)[s0] -> (d0 + s0, d0 - s0) } : () -> ()
-  "test_affine_map"() { affine_map = (d0, d1)[s0, s1] -> (d0 + 1 + s1, d1 - 1 - s0) } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0)[s0] -> (d0 + s0, d0 - s0)> } : () -> ()
+  "test_affine_map"() { affine_map = affine_map<(d0, d1)[s0, s1] -> (d0 + 1 + s1, d1 - 1 - s0)> } : () -> ()
   return
 }

mlir/test/Transforms/Vectorize/normalize_maps.mlir

 // RUN: mlir-opt %s -affine-vectorizer-test -normalize-maps |  FileCheck %s
 
-// CHECK-DAG: #[[ZERO:[a-zA-Z0-9]+]] = () -> (0)
-// CHECK-DAG: #[[ID1:[a-zA-Z0-9]+]] = (d0) -> (d0)
-// CHECK-DAG: #[[D0TIMES2:[a-zA-Z0-9]+]] = (d0) -> (d0 * 2)
-// CHECK-DAG: #[[D0PLUSD1:[a-zA-Z0-9]+]] = (d0, d1) -> (d0 + d1)
-// CHECK-DAG: #[[MINSD0PLUSD1:[a-zA-Z0-9]+]] = (d0, d1) -> (-d0 + d1)
-// CHECK-DAG: #[[D0MINUSD1:[a-zA-Z0-9]+]] = (d0, d1) -> (d0 - d1)
+// CHECK-DAG: #[[ZERO:[a-zA-Z0-9]+]] = affine_map<() -> (0)>
+// CHECK-DAG: #[[ID1:[a-zA-Z0-9]+]] = affine_map<(d0) -> (d0)>
+// CHECK-DAG: #[[D0TIMES2:[a-zA-Z0-9]+]] = affine_map<(d0) -> (d0 * 2)>
+// CHECK-DAG: #[[D0PLUSD1:[a-zA-Z0-9]+]] = affine_map<(d0, d1) -> (d0 + d1)>
+// CHECK-DAG: #[[MINSD0PLUSD1:[a-zA-Z0-9]+]] = affine_map<(d0, d1) -> (-d0 + d1)>
+// CHECK-DAG: #[[D0MINUSD1:[a-zA-Z0-9]+]] = affine_map<(d0, d1) -> (d0 - d1)>
 
 // CHECK-LABEL: func @simple()
 func @simple() {
   affine.for %i0 = 0 to 7 {
-    %0 = affine.apply (d0) -> (d0) (%i0)
-    %1 = affine.apply (d0) -> (d0) (%0)
-    %2 = affine.apply (d0, d1) -> (d0 + d1) (%0, %0)
-    %3 = affine.apply (d0, d1) -> (d0 - d1) (%0, %0)
+    %0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
+    %1 = affine.apply affine_map<(d0) -> (d0)> (%0)
+    %2 = affine.apply affine_map<(d0, d1) -> (d0 + d1)> (%0, %0)
+    %3 = affine.apply affine_map<(d0, d1) -> (d0 - d1)> (%0, %0)
   }
   // CHECK-NEXT: affine.for %{{.*}} = 0 to 7
   // CHECK-NEXT:   {{.*}} affine.apply #[[ID1]](%{{.*}})
   // CHECK-NEXT:   {{.*}} affine.apply #[[D0TIMES2]](%{{.*}})
   // CHECK-NEXT:   {{.*}} affine.apply #[[ZERO]]()
 
   affine.for %i1 = 0 to 7 {
     affine.for %i2 = 0 to 42 {
-      %20 = affine.apply (d0, d1) -> (d1) (%i1, %i2)
-      %21 = affine.apply (d0, d1) -> (d0) (%i1, %i2)
-      %22 = affine.apply (d0, d1) -> (d0 + d1) (%20, %21)
-      %23 = affine.apply (d0, d1) -> (d0 - d1) (%20, %21)
-      %24 = affine.apply (d0, d1) -> (-d0 + d1) (%20, %21)
+      %20 = affine.apply affine_map<(d0, d1) -> (d1)> (%i1, %i2)
+      %21 = affine.apply affine_map<(d0, d1) -> (d0)> (%i1, %i2)
+      %22 = affine.apply affine_map<(d0, d1) -> (d0 + d1)> (%20, %21)
+      %23 = affine.apply affine_map<(d0, d1) -> (d0 - d1)> (%20, %21)
+      %24 = affine.apply affine_map<(d0, d1) -> (-d0 + d1)> (%20, %21)
     }
   }
   //      CHECK: affine.for %{{.*}} = 0 to 7
   // CHECK-NEXT:   affine.for %{{.*}} = 0 to 42
   // CHECK-NEXT:     {{.*}} affine.apply #[[D0PLUSD1]](%{{.*}}, %{{.*}})
   // CHECK-NEXT:     {{.*}} affine.apply #[[MINSD0PLUSD1]](%{{.*}}, %{{.*}})
   // CHECK-NEXT:     {{.*}} affine.apply #[[D0MINUSD1]](%{{.*}}, %{{.*}})
 
   affine.for %i3 = 0 to 16 {
     affine.for %i4 = 0 to 47 step 2 {
       affine.for %i5 = 0 to 78 step 16 {
-        %50 = affine.apply (d0) -> (d0) (%i3)
-        %51 = affine.apply (d0) -> (d0) (%i4)
-        %52 = affine.apply (d0) -> (d0) (%i5)
-        %53 = affine.apply (d0, d1, d2) -> (d0) (%50, %51, %52)
-        %54 = affine.apply (d0, d1, d2) -> (d1) (%50, %51, %52)
-        %55 = affine.apply (d0, d1, d2) -> (d2) (%50, %51, %52)
+        %50 = affine.apply affine_map<(d0) -> (d0)> (%i3)
+        %51 = affine.apply affine_map<(d0) -> (d0)> (%i4)
+        %52 = affine.apply affine_map<(d0) -> (d0)> (%i5)
+        %53 = affine.apply affine_map<(d0, d1, d2) -> (d0)> (%50, %51, %52)
+        %54 = affine.apply affine_map<(d0, d1, d2) -> (d1)> (%50, %51, %52)
+        %55 = affine.apply affine_map<(d0, d1, d2) -> (d2)> (%50, %51, %52)
       }
     }
   }
   // CHECK:      affine.for %{{.*}} = 0 to 16
   // CHECK-NEXT:   affine.for %{{.*}} = 0 to 47 step 2
   // CHECK-NEXT:     affine.for %{{.*}} = 0 to 78 step 16
   // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%{{.*}})
   // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%{{.*}})
   // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%{{.*}})
 
   return
 }

mlir/test/Transforms/Vectorize/vectorize_1d.mlir

 // RUN: mlir-opt %s -affine-vectorize -virtual-vector-size 128 --test-fastest-varying=0 | FileCheck %s
 
 // Permutation maps used in vectorization.
-// CHECK: #[[map_proj_d0d1_0:map[0-9]+]] = (d0, d1) -> (0)
-// CHECK: #[[map_proj_d0d1_d1:map[0-9]+]] = (d0, d1) -> (d1)
+// CHECK: #[[map_proj_d0d1_0:map[0-9]+]] = affine_map<(d0, d1) -> (0)>
+// CHECK: #[[map_proj_d0d1_d1:map[0-9]+]] = affine_map<(d0, d1) -> (d1)>
 
-#map0 = (d0) -> (d0)
-#mapadd1 = (d0) -> (d0 + 1)
-#mapadd2 = (d0) -> (d0 + 2)
-#mapadd3 = (d0) -> (d0 + 3)
-#set0 = (i) : (i >= 0)
+#map0 = affine_map<(d0) -> (d0)>
+#mapadd1 = affine_map<(d0) -> (d0 + 1)>
+#mapadd2 = affine_map<(d0) -> (d0 + 2)>
+#mapadd3 = affine_map<(d0) -> (d0 + 3)>
+#set0 = affine_set<(i) : (i >= 0)>
 
 // Maps introduced to vectorize fastest varying memory index.
 // CHECK-LABEL: func @vec1d_1
 func @vec1d_1(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: %{{.*}} = constant 0.0{{.*}}: f32
 // CHECK-DAG: %[[C0:[a-z0-9_]+]] = constant 0 : index
 // CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
 // CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>

mlir/test/Transforms/Vectorize/vectorize_2d.mlir

 // RUN: mlir-opt %s -affine-vectorize -virtual-vector-size 4 -virtual-vector-size 8 | FileCheck %s -check-prefix=VECT
 // RUN: mlir-opt %s -affine-vectorize -virtual-vector-size 32 -virtual-vector-size 256 --test-fastest-varying=1 --test-fastest-varying=0 | FileCheck %s
 
 // Permutation maps used in vectorization.
-// CHECK-DAG: #[[map_id1:map[0-9]+]] = (d0) -> (d0)
-// CHECK-DAG: #[[map_id2:map[0-9]+]] = (d0, d1) -> (d0, d1)
-// CHECK-DAG: #[[map_proj_d0d1_zerod1:map[0-9]+]] = (d0, d1) -> (0, d1)
-// CHECK-DAG: #[[map_proj_d0d1_d0zero:map[0-9]+]] = (d0, d1) -> (d0, 0)
-// VECT-DAG: #[[map_id1:map[0-9]+]] = (d0) -> (d0)
-// VECT-DAG: #[[map_id2:map[0-9]+]] = (d0, d1) -> (d0, d1)
-// VECT-DAG: #[[map_proj_d0d1_zerod1:map[0-9]+]] = (d0, d1) -> (0, d1)
-// VECT-DAG: #[[map_proj_d0d1_d0zero:map[0-9]+]] = (d0, d1) -> (d0, 0)
+// CHECK-DAG: #[[map_id1:map[0-9]+]] = affine_map<(d0) -> (d0)>
+// CHECK-DAG: #[[map_id2:map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
+// CHECK-DAG: #[[map_proj_d0d1_zerod1:map[0-9]+]] = affine_map<(d0, d1) -> (0, d1)>
+// CHECK-DAG: #[[map_proj_d0d1_d0zero:map[0-9]+]] = affine_map<(d0, d1) -> (d0, 0)>
+// VECT-DAG: #[[map_id1:map[0-9]+]] = affine_map<(d0) -> (d0)>
+// VECT-DAG: #[[map_id2:map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
+// VECT-DAG: #[[map_proj_d0d1_zerod1:map[0-9]+]] = affine_map<(d0, d1) -> (0, d1)>
+// VECT-DAG: #[[map_proj_d0d1_d0zero:map[0-9]+]] = affine_map<(d0, d1) -> (d0, 0)>
 
 func @vec2d(%A : memref<?x?x?xf32>) {
    %M = dim %A, 0 : memref<?x?x?xf32>
    %N = dim %A, 1 : memref<?x?x?xf32>
    %P = dim %A, 2 : memref<?x?x?xf32>
    // CHECK: for  {{.*}} = 0 to %{{.*}} {
    // CHECK:   for {{.*}} = 0 to %{{.*}} step 32
    // CHECK:     for {{.*}} = 0 to %{{.*}} step 256
func @vectorize_matmul(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
   //      VECT: %[[C0:.*]] = constant 0 : index
   // VECT-NEXT: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?xf32>
   // VECT-NEXT: %[[K:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
   // VECT-NEXT: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
   //      VECT: {{.*}} #[[map_id1]](%[[M]]) step 4 {
   // VECT-NEXT:   {{.*}} #[[map_id1]](%[[N]]) step 8 {
   //      VECT:     %[[VC0:.*]] = constant dense<0.000000e+00> : vector<4x8xf32>
   // VECT-NEXT:     vector.transfer_write %[[VC0]], %{{.*}}[%{{.*}}, %{{.*}}] {permutation_map = #[[map_id2]]} : vector<4x8xf32>, memref<?x?xf32>
-  affine.for %i0 = (d0) -> (d0)(%c0) to (d0) -> (d0)(%M) {
-    affine.for %i1 = (d0) -> (d0)(%c0) to (d0) -> (d0)(%N) {
+  affine.for %i0 = affine_map<(d0) -> (d0)>(%c0) to affine_map<(d0) -> (d0)>(%M) {
+    affine.for %i1 = affine_map<(d0) -> (d0)>(%c0) to affine_map<(d0) -> (d0)>(%N) {
       %cst = constant 0.000000e+00 : f32
       affine.store %cst, %arg2[%i0, %i1] : memref<?x?xf32>
     }
   }
   //      VECT:  affine.for %[[I2:.*]] = #[[map_id1]](%[[C0]]) to #[[map_id1]](%[[M]]) step 4 {
   // VECT-NEXT:    affine.for %[[I3:.*]] = #[[map_id1]](%[[C0]]) to #[[map_id1]](%[[N]]) step 8 {
   // VECT-NEXT:      affine.for %[[I4:.*]] = #map5(%[[C0]]) to #[[map_id1]](%[[K]]) {
   // VECT-NEXT:        %[[A:.*]] = vector.transfer_read %{{.*}}[%[[I4]], %[[I3]]], %{{.*}} {permutation_map = #[[map_proj_d0d1_zerod1]]} : memref<?x?xf32>, vector<4x8xf32>
   // VECT-NEXT:        %[[B:.*]] = vector.transfer_read %{{.*}}[%[[I2]], %[[I4]]], %{{.*}} {permutation_map = #[[map_proj_d0d1_d0zero]]} : memref<?x?xf32>, vector<4x8xf32>
   // VECT-NEXT:        %[[C:.*]] = mulf %[[B]], %[[A]] : vector<4x8xf32>
   // VECT-NEXT:        %[[D:.*]] = vector.transfer_read %{{.*}}[%[[I2]], %[[I3]]], %{{.*}} {permutation_map = #[[map_id2]]} : memref<?x?xf32>, vector<4x8xf32>
   // VECT-NEXT:        %[[E:.*]] = addf %[[D]], %[[C]] : vector<4x8xf32>
   // VECT-NEXT:        vector.transfer_write %[[E]], %{{.*}}[%[[I2]], %[[I3]]] {permutation_map = #[[map_id2]]} : vector<4x8xf32>, memref<?x?xf32>
-  affine.for %i2 = (d0) -> (d0)(%c0) to (d0) -> (d0)(%M) {
-    affine.for %i3 = (d0) -> (d0)(%c0) to (d0) -> (d0)(%N) {
-      affine.for %i4 = (d0) -> (d0)(%c0) to (d0) -> (d0)(%K) {
+  affine.for %i2 = affine_map<(d0) -> (d0)>(%c0) to affine_map<(d0) -> (d0)>(%M) {
+    affine.for %i3 = affine_map<(d0) -> (d0)>(%c0) to affine_map<(d0) -> (d0)>(%N) {
+      affine.for %i4 = affine_map<(d0) -> (d0)>(%c0) to affine_map<(d0) -> (d0)>(%K) {
         %6 = affine.load %arg1[%i4, %i3] : memref<?x?xf32>
         %7 = affine.load %arg0[%i2, %i4] : memref<?x?xf32>
         %8 = mulf %7, %6 : f32
         %9 = affine.load %arg2[%i2, %i3] : memref<?x?xf32>
         %10 = addf %9, %8 : f32
         affine.store %10, %arg2[%i2, %i3] : memref<?x?xf32>
       }
     }
   }
   return
 }

mlir/test/Transforms/Vectorize/vectorize_3d.mlir

 // RUN: mlir-opt %s -affine-vectorize -virtual-vector-size 32 -virtual-vector-size 64 -virtual-vector-size 256 --test-fastest-varying=2 --test-fastest-varying=1 --test-fastest-varying=0 | FileCheck %s
 
 // Permutation maps used in vectorization.
-// CHECK: #[[map_proj_d0d1d2_d0d1d2:map[0-9]+]] = (d0, d1, d2) -> (d0, d1, d2)
+// CHECK: #[[map_proj_d0d1d2_d0d1d2:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
 
 func @vec3d(%A : memref<?x?x?xf32>) {
    %0 = dim %A, 0 : memref<?x?x?xf32>
    %1 = dim %A, 1 : memref<?x?x?xf32>
    %2 = dim %A, 2 : memref<?x?x?xf32>
    // CHECK: affine.for %{{.*}} = 0 to %{{.*}} {
    // CHECK:   affine.for %{{.*}} = 0 to %{{.*}} {
    // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} step 32 {

mlir/test/Transforms/Vectorize/vectorize_outer_loop_2d.mlir

 // RUN: mlir-opt %s -affine-vectorize -virtual-vector-size 32 -virtual-vector-size 256 --test-fastest-varying=2 --test-fastest-varying=0 | FileCheck %s
 
 // Permutation maps used in vectorization.
-// CHECK: #[[map_proj_d0d1d2_d0d2:map[0-9]+]] = (d0, d1, d2) -> (d0, d2)
+// CHECK: #[[map_proj_d0d1d2_d0d2:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0, d2)>
 
 func @vec2d(%A : memref<?x?x?xf32>) {
    %M = dim %A, 0 : memref<?x?x?xf32>
    %N = dim %A, 1 : memref<?x?x?xf32>
    %P = dim %A, 2 : memref<?x?x?xf32>
    // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 32
    // CHECK:   affine.for %{{.*}} = 0 to %{{.*}} {
    // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} step 256

mlir/test/Transforms/Vectorize/vectorize_outer_loop_transpose_2d.mlir

 // RUN: mlir-opt %s -affine-vectorize -virtual-vector-size 32 -virtual-vector-size 256 --test-fastest-varying=0 --test-fastest-varying=2 | FileCheck %s
 
 // Permutation maps used in vectorization.
-// CHECK: #[[map_proj_d0d1d2_d2d0:map[0-9]+]] = (d0, d1, d2) -> (d2, d0)
+// CHECK: #[[map_proj_d0d1d2_d2d0:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d2, d0)>
 
 func @vec2d(%A : memref<?x?x?xf32>) {
    %M = dim %A, 0 : memref<?x?x?xf32>
    %N = dim %A, 1 : memref<?x?x?xf32>
    %P = dim %A, 2 : memref<?x?x?xf32>
    // CHECK: for  {{.*}} = 0 to %{{.*}} {
    // CHECK:   for  {{.*}} = 0 to %{{.*}} {
    // CHECK:     for  {{.*}} = 0 to %{{.*}} {

mlir/test/Transforms/Vectorize/vectorize_transpose_2d.mlir

 // RUN: mlir-opt %s -affine-vectorize -virtual-vector-size 32 -virtual-vector-size 256 --test-fastest-varying=0 --test-fastest-varying=1 | FileCheck %s
 
 // Permutation maps used in vectorization.
-// CHECK-DAG: #[[map_proj_d0d1d2_d2d1:map[0-9]+]] = (d0, d1, d2) -> (d2, d1)
+// CHECK-DAG: #[[map_proj_d0d1d2_d2d1:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d2, d1)>
 
 func @vec2d(%A : memref<?x?x?xf32>) {
    %M = dim %A, 0 : memref<?x?x?xf32>
    %N = dim %A, 1 : memref<?x?x?xf32>
    %P = dim %A, 2 : memref<?x?x?xf32>
    // CHECK: for  {{.*}} = 0 to %{{.*}} {
    // CHECK:   for  {{.*}} = 0 to %{{.*}} {
    // CHECK:     for  {{.*}} = 0 to %{{.*}} {

mlir/test/Transforms/affine-data-copy.mlir

 // RUN: mlir-opt %s -split-input-file -affine-data-copy-generate -affine-data-copy-generate-dma=false -affine-data-copy-generate-fast-mem-space=0 -affine-data-copy-generate-skip-non-unit-stride-loops | FileCheck %s
 // Small buffer size to trigger fine copies.
 // RUN: mlir-opt %s -affine-data-copy-generate -affine-data-copy-generate-dma=false -affine-data-copy-generate-fast-mem-space=0 -affine-data-copy-generate-fast-mem-capacity=1 | FileCheck --check-prefix=CHECK-SMALL %s
 
 // -copy-skip-non-stride-loops forces the copies to be placed right inside the
 // tile space loops, avoiding the sensitivity of copy placement depth to memory
 // footprint -- so that one could write a definite test case and not have to
 // update it each time something related to the cost functions change.
 
-#map0 = (d0) -> (d0)
-#map1 = (d0) -> (d0 + 128)
+#map0 = affine_map<(d0) -> (d0)>
+#map1 = affine_map<(d0) -> (d0 + 128)>
 
 // Map used to index the original memref while copying.
-// CHECK-DAG: [[MEM_IDX_MAP:map[0-9]+]] = (d0, d1) -> (d0 + d1)
+// CHECK-DAG: [[MEM_IDX_MAP:map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1)>
 // Map used to index the buffer while computing.
-// CHECK-DAG: [[BUF_IDX_MAP:map[0-9]+]] = (d0, d1, d2, d3) -> (-d0 + d2, -d1 + d3)
+// CHECK-DAG: [[BUF_IDX_MAP:map[0-9]+]] = affine_map<(d0, d1, d2, d3) -> (-d0 + d2, -d1 + d3)>
 
 // CHECK-LABEL: func @matmul
 func @matmul(%A: memref<4096x4096xf32>, %B: memref<4096x4096xf32>, %C: memref<4096x4096xf32>) -> memref<4096x4096xf32> {
   affine.for %i = 0 to 4096 step 128 {
     affine.for %j = 0 to 4096 step 128 {
       affine.for %k = 0 to 4096 step 128 {
         affine.for %ii = #map0(%i) to #map1(%i) {
           affine.for %jj = #map0(%j) to #map1(%j) {

mlir/test/Transforms/affine-loop-invariant-code-motion.mlir

 
 // The store-load forwarding can see through affine apply's since it relies on
 // dependence information.
 // CHECK-LABEL: func @store_affine_apply
 func @store_affine_apply() -> memref<10xf32> {
   %cf7 = constant 7.0 : f32
   %m = alloc() : memref<10xf32>
   affine.for %arg0 = 0 to 10 {
-      %t0 = affine.apply (d1) -> (d1 + 1)(%arg0)
+      %t0 = affine.apply affine_map<(d1) -> (d1 + 1)>(%arg0)
       affine.store %cf7, %m[%t0] : memref<10xf32>
   }
   return %m : memref<10xf32>
 // CHECK:       %cst = constant 7.000000e+00 : f32
 // CHECK-NEXT:  %0 = alloc() : memref<10xf32>
 // CHECK-NEXT:  affine.for %arg0 = 0 to 10 {
 // CHECK-NEXT:      %1 = affine.apply #map3(%arg0)
 // CHECK-NEXT:      affine.store %cst, %0[%1] : memref<10xf32>
func @single_loop_nothing_invariant() {
   return
 }
 
 func @invariant_code_inside_affine_if() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
-    %t0 = affine.apply (d1) -> (d1 + 1)(%arg0)
-    affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %t0) {
+    %t0 = affine.apply affine_map<(d1) -> (d1 + 1)>(%arg0)
+    affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %t0) {
         %cf9 = addf %cf8, %cf8 : f32
         affine.store %cf9, %m[%arg0] : memref<10xf32>
 
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
func @load_after_load() {
   return
 }
 
 func @invariant_affine_if() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg0] : memref<10xf32>
 
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
 
 
   return
 }
 
 func @invariant_affine_if2() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg1] : memref<10xf32>
 
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
func @invariant_affine_if2() {
   return
 }
 
 func @invariant_affine_nested_if() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg0] : memref<10xf32>
-          affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+          affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             affine.store %cf9, %m[%arg1] : memref<10xf32>
           }
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
func @invariant_affine_nested_if() {
   return
 }
 
 func @invariant_affine_nested_if_else() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg0] : memref<10xf32>
-          affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+          affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             affine.store %cf9, %m[%arg0] : memref<10xf32>
           } else {
             affine.store %cf9, %m[%arg1] : memref<10xf32>
           }
       }
     }
   }
 

 }
 
 func @invariant_affine_nested_if_else2() {
   %m = alloc() : memref<10xf32>
   %m2 = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           %tload1 = affine.load %m[%arg0] : memref<10xf32>
-          affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+          affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             affine.store %cf9, %m2[%arg0] : memref<10xf32>
           } else {
             %tload2 = affine.load %m[%arg0] : memref<10xf32>
           }
       }
     }
   }
 

 }
 
 
 func @invariant_affine_nested_if2() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           %v1 = affine.load %m[%arg0] : memref<10xf32>
-          affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+          affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             %v2 = affine.load %m[%arg0] : memref<10xf32>
           }
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
func @invariant_affine_nested_if2() {
   return
 }
 
 func @invariant_affine_for_inside_affine_if() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg0] : memref<10xf32>
           affine.for %arg2 = 0 to 10 {
             affine.store %cf9, %m[%arg2] : memref<10xf32>
           }
       }
     }
   }

mlir/test/Transforms/canonicalize.mlir

func @dyn_shape_fold(%L : index, %M : index) -> (memref<? x ? x i32>, memref<? x ? x f32>) {
   }
 
   // CHECK: alloc() : memref<9x9xf32>
   %d = alloc(%nine, %nine) : memref<? x ? x f32>
 
   return %c, %d : memref<? x ? x i32>, memref<? x ? x f32>
 }
 
-#map1 = (d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)
-#map2 = (d0, d1, d2)[s0, s1, s2] -> (d0 * s2 + d1 * s1 + d2 + s0)
+#map1 = affine_map<(d0, d1)[s0, s1, s2] -> (d0 * s1 + d1 * s2 + s0)>
+#map2 = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s2 + d1 * s1 + d2 + s0)>
 
 // CHECK-LABEL: func @dim_op_fold(%arg0: index, %arg1: index, %arg2: index,
 func @dim_op_fold(%arg0: index, %arg1: index, %arg2: index, %BUF: memref<?xi8>, %M : index, %N : index, %K : index) {
 // CHECK-SAME: [[M:arg[0-9]+]]: index
 // CHECK-SAME: [[N:arg[0-9]+]]: index
 // CHECK-SAME: [[K:arg[0-9]+]]: index
   %c0 = constant 0 : index
   %c1 = constant 1 : index
func @hoist_constant(%arg0: memref<8xi32>) {
   }
   return
 }
 
 // CHECK-LABEL: func @const_fold_propagate
 func @const_fold_propagate() -> memref<?x?xf32> {
   %VT_i = constant 512 : index
 
-  %VT_i_s = affine.apply (d0) -> (d0 floordiv  8) (%VT_i)
-  %VT_k_l = affine.apply (d0) -> (d0 floordiv  16) (%VT_i)
+  %VT_i_s = affine.apply affine_map<(d0) -> (d0 floordiv  8)> (%VT_i)
+  %VT_k_l = affine.apply affine_map<(d0) -> (d0 floordiv  16)> (%VT_i)
 
   // CHECK: = alloc() : memref<64x32xf32>
   %Av = alloc(%VT_i_s, %VT_k_l) : memref<?x?xf32>
   return %Av : memref<?x?xf32>
 }
 
 // CHECK-LABEL: func @br_folding
 func @br_folding() -> i32 {
func @indirect_call_folding() {
   // CHECK-NEXT: return
   %indirect_fn = constant @indirect_target : () -> ()
   call_indirect %indirect_fn() : () -> ()
   return
 }
 
 //
 // IMPORTANT NOTE: the operations in this test are exactly those produced by
-// lowering affine.apply (i) -> (i mod 42) to standard operations.  Please only
+// lowering affine.apply affine_map<(i) -> (i mod 42)> to standard operations.  Please only
 // change these operations together with the affine lowering pass tests.
 //
 // CHECK-LABEL: @lowered_affine_mod
 func @lowered_affine_mod() -> (index, index) {
 // CHECK-NEXT: {{.*}} = constant 41 : index
   %c-43 = constant -43 : index
   %c42 = constant 42 : index
   %0 = remi_signed %c-43, %c42 : index
// CHECK-NEXT: {{.*}} = constant 1 : index
   %5 = cmpi "slt", %4, %c0_1 : index
   %6 = addi %4, %c42_0 : index
   %7 = select %5, %6, %4 : index
   return %3, %7 : index, index
 }
 
 //
 // IMPORTANT NOTE: the operations in this test are exactly those produced by
-// lowering affine.apply (i) -> (i mod 42) to standard operations.  Please only
+// lowering affine.apply affine_map<(i) -> (i mod 42)> to standard operations.  Please only
 // change these operations together with the affine lowering pass tests.
 //
 // CHECK-LABEL: func @lowered_affine_floordiv
 func @lowered_affine_floordiv() -> (index, index) {
 // CHECK-NEXT: %c-2 = constant -2 : index
   %c-43 = constant -43 : index
   %c42 = constant 42 : index
   %c0 = constant 0 : index
// CHECK-NEXT: %c1 = constant 1 : index
   %9 = divi_signed %8, %c42_0 : index
   %10 = subi %c-1_2, %9 : index
   %11 = select %6, %10, %9 : index
   return %5, %11 : index, index
 }
 
 //
 // IMPORTANT NOTE: the operations in this test are exactly those produced by
-// lowering affine.apply (i) -> (i mod 42) to standard operations.  Please only
+// lowering affine.apply affine_map<(i) -> (i mod 42)> to standard operations.  Please only
 // change these operations together with the affine lowering pass tests.
 //
 // CHECK-LABEL: func @lowered_affine_ceildiv
 func @lowered_affine_ceildiv() -> (index, index) {
 // CHECK-NEXT:  %c-1 = constant -1 : index
   %c-43 = constant -43 : index
   %c42 = constant 42 : index
   %c0 = constant 0 : index
func @cast_values(%arg0: tensor<*xi32>, %arg1: memref<?xi32>) -> (tensor<2xi32>, memref<2xi32>) {
   %5 = memref_cast %3 : memref<2xi32> to memref<2xi32>
 
   // CHECK-NEXT: return %0, %1 : tensor<2xi32>, memref<2xi32>
   return %4, %5 : tensor<2xi32>, memref<2xi32>
 }
 
 // -----
 
-#TEST_VIEW_MAP0 = (d0, d1)[s0, s1] -> (d0 * s1 + d1 + s0)
-#TEST_VIEW_MAP1 = (d0, d1, d2)[s0, s1] -> (d0 * s1 + d1 * s0 + d2)
-#TEST_VIEW_MAP2 = (d0, d1)[s0] -> (d0 * 4 + d1 + s0)
-
-// CHECK-DAG: #[[VIEW_MAP0:map[0-9]+]] = (d0, d1) -> (d0 * 11 + d1 + 15)
-// CHECK-DAG: #[[VIEW_MAP1:map[0-9]+]] = (d0, d1)[s0] -> (d0 * 11 + s0 + d1)
-// CHECK-DAG: #[[VIEW_MAP2:map[0-9]+]] = (d0, d1)[s0] -> (d0 * s0 + d1 + 15)
-// CHECK-DAG: #[[VIEW_MAP3:map[0-9]+]] = (d0, d1, d2)[s0] -> (d0 * s0 + d1 * 7 + d2)
-// CHECK-DAG: #[[VIEW_MAP4:map[0-9]+]] = (d0, d1) -> (d0 * 4 + d1 + 15)
+#TEST_VIEW_MAP0 = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + d1 + s0)>
+#TEST_VIEW_MAP1 = affine_map<(d0, d1, d2)[s0, s1] -> (d0 * s1 + d1 * s0 + d2)>
+#TEST_VIEW_MAP2 = affine_map<(d0, d1)[s0] -> (d0 * 4 + d1 + s0)>
+
+// CHECK-DAG: #[[VIEW_MAP0:map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 11 + d1 + 15)>
+// CHECK-DAG: #[[VIEW_MAP1:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 * 11 + s0 + d1)>
+// CHECK-DAG: #[[VIEW_MAP2:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 * s0 + d1 + 15)>
+// CHECK-DAG: #[[VIEW_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2)[s0] -> (d0 * s0 + d1 * 7 + d2)>
+// CHECK-DAG: #[[VIEW_MAP4:map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1 + 15)>
 
 // CHECK-LABEL: func @view
 func @view(%arg0 : index) {
   // CHECK: %[[ALLOC_MEM:.*]] = alloc() : memref<2048xi8>
   %0 = alloc() : memref<2048xi8>
   %c0 = constant 0 : index
   %c7 = constant 7 : index
   %c11 = constant 11 : index
func @view(%arg0 : index) {
   %6 = memref_cast %0 : memref<2048xi8> to memref<?xi8>
   %7 = view %6[%c15][%c7] : memref<?xi8> to memref<?x?xf32>
   load %7[%c0, %c0] : memref<?x?xf32>
   return
 }
 
 // -----
 
-// CHECK-DAG: #[[BASE_MAP0:map[0-9]+]] = (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)
-// CHECK-DAG: #[[SUBVIEW_MAP0:map[0-9]+]] = (d0, d1, d2)[s0] -> (d0 * 64 + s0 + d1 * 4 + d2)
-// CHECK-DAG: #[[SUBVIEW_MAP1:map[0-9]+]] = (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2 + 79)
-// CHECK-DAG: #[[SUBVIEW_MAP2:map[0-9]+]] = (d0, d1, d2) -> (d0 * 128 + d1 * 28 + d2 * 11)
-// CHECK-DAG: #[[SUBVIEW_MAP3:map[0-9]+]] = (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)
-// CHECK-DAG: #[[SUBVIEW_MAP4:map[0-9]+]] = (d0, d1, d2)[s0] -> (d0 * 128 + s0 + d1 * 28 + d2 * 11)
-// CHECK-DAG: #[[SUBVIEW_MAP5:map[0-9]+]] = (d0, d1, d2)[s0, s1, s2] -> (d0 * s0 + d1 * s1 + d2 * s2 + 79)
-// CHECK-DAG: #[[SUBVIEW_MAP6:map[0-9]+]] = (d0, d1)[s0] -> (d0 * 4 + s0 + d1)
-// CHECK-DAG: #[[SUBVIEW_MAP7:map[0-9]+]] = (d0, d1) -> (d0 * 4 + d1 + 12)
+// CHECK-DAG: #[[BASE_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>
+// CHECK-DAG: #[[SUBVIEW_MAP0:map[0-9]+]] = affine_map<(d0, d1, d2)[s0] -> (d0 * 64 + s0 + d1 * 4 + d2)>
+// CHECK-DAG: #[[SUBVIEW_MAP1:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2 + 79)>
+// CHECK-DAG: #[[SUBVIEW_MAP2:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 * 128 + d1 * 28 + d2 * 11)>
+// CHECK-DAG: #[[SUBVIEW_MAP3:map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)>
+// CHECK-DAG: #[[SUBVIEW_MAP4:map[0-9]+]] = affine_map<(d0, d1, d2)[s0] -> (d0 * 128 + s0 + d1 * 28 + d2 * 11)>
+// CHECK-DAG: #[[SUBVIEW_MAP5:map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s0 + d1 * s1 + d2 * s2 + 79)>
+// CHECK-DAG: #[[SUBVIEW_MAP6:map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 * 4 + s0 + d1)>
+// CHECK-DAG: #[[SUBVIEW_MAP7:map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1 + 12)>
 
 // CHECK-LABEL: func @subview
 // CHECK-SAME: %[[ARG0:.*]]: index, %[[ARG1:.*]]: index
 func @subview(%arg0 : index, %arg1 : index) -> (index, index) {
   // CHECK: %[[C0:.*]] = constant 0 : index
   %c0 = constant 0 : index
   // CHECK: %[[C1:.*]] = constant 1 : index
   %c1 = constant 1 : index
   // CHECK: %[[C2:.*]] = constant 2 : index
   %c2 = constant 2 : index
   // CHECK: %[[C7:.*]] = constant 7 : index
   %c7 = constant 7 : index
   // CHECK: %[[C11:.*]] = constant 11 : index
   %c11 = constant 11 : index
   %c15 = constant 15 : index
 
   // CHECK: %[[ALLOC0:.*]] = alloc()
-  %0 = alloc() : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>
+  %0 = alloc() : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>>
 
   // Test: subview with constant base memref and constant operands is folded.
   // Note that the subview uses the base memrefs layout map because it used
   // zero offset and unit stride arguments.
   // CHECK: std.subview %[[ALLOC0]][][][] : memref<8x16x4xf32, #[[BASE_MAP0]]> to memref<7x11x2xf32, #[[BASE_MAP0]]>
   %1 = subview %0[%c0, %c0, %c0][%c7, %c11, %c2][%c1, %c1, %c1]
-    : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)> to
+    : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>> to
       memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
   load %1[%c0, %c0, %c0] : memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
 
   // Test: subview with one dynamic operand should not be folded.
   // CHECK: std.subview %[[ALLOC0]][%[[C0]], %[[ARG0]], %[[C0]]][][] : memref<8x16x4xf32, #[[BASE_MAP0]]> to memref<7x11x15xf32, #[[SUBVIEW_MAP0]]>
   %2 = subview %0[%c0, %arg0, %c0][%c7, %c11, %c15][%c1, %c1, %c1]
-    : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)> to
+    : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>> to
       memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
   load %2[%c0, %c0, %c0] : memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
 
   // CHECK: %[[ALLOC1:.*]] = alloc(%[[ARG0]])
-  %3 = alloc(%arg0) : memref<?x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>
+  %3 = alloc(%arg0) : memref<?x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>>
   // Test: subview with constant operands but dynamic base memref is folded as long as the strides and offset of the base memref are static.
   // CHECK: std.subview %[[ALLOC1]][][][] : memref<?x16x4xf32, #[[BASE_MAP0]]> to memref<7x11x15xf32, #[[BASE_MAP0]]>
   %4 = subview %3[%c0, %c0, %c0][%c7, %c11, %c15][%c1, %c1, %c1]
-    : memref<?x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)> to
+    : memref<?x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>> to
       memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
   load %4[%c0, %c0, %c0] : memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
 
   // Test: subview offset operands are folded correctly w.r.t. base strides.
   // CHECK: std.subview %[[ALLOC0]][][][] : memref<8x16x4xf32, #[[BASE_MAP0]]> to memref<7x11x2xf32, #[[SUBVIEW_MAP1]]>
   %5 = subview %0[%c1, %c2, %c7][%c7, %c11, %c2][%c1, %c1, %c1]
-    : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)> to
+    : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>> to
       memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
   load %5[%c0, %c0, %c0] : memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
 
   // Test: subview stride operands are folded correctly w.r.t. base strides.
   // CHECK: std.subview %[[ALLOC0]][][][] : memref<8x16x4xf32, #[[BASE_MAP0]]> to memref<7x11x2xf32, #[[SUBVIEW_MAP2]]>
   %6 = subview %0[%c0, %c0, %c0][%c7, %c11, %c2][%c2, %c7, %c11]
-    : memref<8x16x4xf32, (d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)> to
+    : memref<8x16x4xf32, affine_map<(d0, d1, d2) -> (d0 * 64 + d1 * 4 + d2)>> to
       memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
   load %6[%c0, %c0, %c0] : memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
 
   // Test: subview shape are folded, but offsets and strides are not even if base memref is static
   // CHECK: std.subview %[[ALLOC0]][%[[ARG0]], %[[ARG0]], %[[ARG0]]][][%[[ARG1]], %[[ARG1]], %[[ARG1]]] : memref<8x16x4xf32, #[[BASE_MAP0]]> to memref<7x11x2xf32, #[[SUBVIEW_MAP3]]>
   %10 = subview %0[%arg0, %arg0, %arg0][%c7, %c11, %c2][%arg1, %arg1, %arg1] : memref<8x16x4xf32, offset:0, strides:[64, 4, 1]> to memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
   load %10[%arg1, %arg1, %arg1] : memref<?x?x?xf32, offset: ?, strides: [?, ?, ?]>
 
   // Test: subview strides are folded, but offsets and shape are not even if base memref is static
   // CHECK: std.subview %[[ALLOC0]][%[[ARG0]], %[[ARG0]], %[[ARG0]]][%[[ARG1]], %[[ARG1]], %[[ARG1]]][] : memref<8x16x4xf32, #[[BASE_MAP0]]> to memref<?x?x?xf32, #[[SUBVIEW_MAP4]]
func @subview(%arg0 : index, %arg1 : index) -> (index, index) {
 
   // TEST: subview strides and sizes are maintained when offsets are folded
   // CHECK: std.subview %[[ALLOC3]][][][] : memref<12x4xf32> to memref<12x4xf32, #[[SUBVIEW_MAP7]]>
   %20 = subview %18[%c2, %c4][][] : memref<12x4xf32> to memref<12x4xf32, offset: ?, strides:[4, 1]>
   load %20[%arg1, %arg1] : memref<12x4xf32, offset: ?, strides:[4, 1]>
 
   // Test: dim on subview is rewritten to size operand.
   %7 = dim %4, 0 : memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
   %8 = dim %4, 1 : memref<?x?x?xf32,
-       (d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>
+       affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + d1 * s2 + d2 * s3 + s0)>>
 
   // CHECK: return %[[C7]], %[[C11]]
   return %7, %8 : index, index
 }

mlir/test/Transforms/constant-fold.mlir

 // CHECK-LABEL: func @affine_apply
 func @affine_apply(%variable : index) -> (index, index, index) {
   %c177 = constant 177 : index
   %c211 = constant 211 : index
   %N = constant 1075 : index
 
   // CHECK:[[C1159:%.+]] = constant 1159 : index
   // CHECK:[[C1152:%.+]] = constant 1152 : index
-  %x0 = affine.apply (d0, d1)[S0] -> ( (d0 + 128 * S0) floordiv 128 + d1 mod 128)
+  %x0 = affine.apply affine_map<(d0, d1)[S0] -> ( (d0 + 128 * S0) floordiv 128 + d1 mod 128)>
            (%c177, %c211)[%N]
-  %x1 = affine.apply (d0, d1)[S0] -> (128 * (S0 ceildiv 128))
+  %x1 = affine.apply affine_map<(d0, d1)[S0] -> (128 * (S0 ceildiv 128))>
            (%c177, %c211)[%N]
 
   // CHECK:[[C42:%.+]] = constant 42 : index
-  %y = affine.apply (d0) -> (42) (%variable)
+  %y = affine.apply affine_map<(d0) -> (42)> (%variable)
 
   // CHECK: return [[C1159]], [[C1152]], [[C42]]
   return %x0, %x1, %y : index, index, index
 }
 
 // -----
 
 // CHECK-LABEL: func @simple_mulf

mlir/test/Transforms/cse.mlir

 // RUN: mlir-opt %s -pass-pipeline='func(cse)' | FileCheck %s
 
-// CHECK-DAG: #map0 = (d0) -> (d0 mod 2)
-#map0 = (d0) -> (d0 mod 2)
+// CHECK-DAG: #map0 = affine_map<(d0) -> (d0 mod 2)>
+#map0 = affine_map<(d0) -> (d0 mod 2)>
 
 // CHECK-LABEL: @simple_constant
 func @simple_constant() -> (i32, i32) {
   // CHECK-NEXT: %c1_i32 = constant 1 : i32
   %0 = constant 1 : i32
 
   // CHECK-NEXT: return %c1_i32, %c1_i32 : i32, i32
   %1 = constant 1 : i32

mlir/test/Transforms/dma-generate.mlir

 // RUN: mlir-opt %s -split-input-file -affine-data-copy-generate -affine-data-copy-generate-dma -affine-data-copy-generate-fast-mem-space=2 -affine-data-copy-generate-skip-non-unit-stride-loops -verify-diagnostics | FileCheck %s
 // RUN: mlir-opt %s -split-input-file -affine-data-copy-generate -affine-data-copy-generate-dma -affine-data-copy-generate-fast-mem-capacity=16 -affine-data-copy-generate-fast-mem-space=2 | FileCheck %s --check-prefix FAST-MEM-16KB
 
 // We run most test cases with -copy-skip-non-unit-stride-loops to allow testing
 // DMA generation at inner levels easily - since the DMA generation would
 // otherwise always generate DMAs at the outermost level (default for fast mem
 // capacity is infinite). Using a specific capacity makes it harder to write
 // a test case as one would have to calculate total footprints. With
 // -copy-skip-non-unit-stride-loops, non-unit strides will always be skipped and
 // its inner loops will be traversed till a unit stride loop is found (or the
 // innermost block is reached).
 
 // -----
 
 // Index of the buffer for the second DMA is remapped.
-// CHECK-DAG: [[MAP_PLUS_256:#map[0-9]+]] = (d0) -> (d0 + 256)
-// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0)
+// CHECK-DAG: [[MAP_PLUS_256:#map[0-9]+]] = affine_map<(d0) -> (d0 + 256)>
+// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL: func @loop_nest_1d() {
 func @loop_nest_1d() {
   %A = alloc() : memref<256 x f32>
   %B = alloc() : memref<512 x f32>
   %F = alloc() : memref<256 x f32, 2>
   // First DMA buffer.
   // CHECK:  %{{.*}} = alloc() : memref<256xf32>
func @loop_nest_1d() {
   // CHECK-NEXT: }
   // CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
   // CHECK-NEXT: dealloc %{{.*}} : memref<256xf32, 2>
   // CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
   // CHECK-NEXT: dealloc %{{.*}} : memref<256xf32, 2>
   // CHECK-NEXT: return
   affine.for %i = 0 to 256 {
     affine.load %A[%i] : memref<256 x f32>
-    %idx = affine.apply (d0) -> (d0 + 256)(%i)
+    %idx = affine.apply affine_map<(d0) -> (d0 + 256)>(%i)
     affine.load %B[%idx] : memref<512 x f32>
     affine.load %F[%i] : memref<256 x f32, 2>
   }
   return
 }
 
 // -----
 
func @loop_nest_high_d(%A: memref<512 x 32 x f32>,
     %B: memref<512 x 32 x f32>, %C: memref<512 x 32 x f32>) {
   // DMAs will be performed at this level (jT is the first loop without a stride).
   // A and B are read, while C is both read and written. A total of three new buffers
   // are allocated and existing load's/store's are replaced by accesses to those buffers.
   affine.for %jT = 0 to 32 {
     affine.for %kT = 0 to 32 {
       affine.for %iT = 0 to 32 {
         affine.for %kk = 0 to 16 { // k intratile
-          %k = affine.apply (d0, d1) -> (16*d0 + d1) (%kT, %kk)
+          %k = affine.apply affine_map<(d0, d1) -> (16*d0 + d1)> (%kT, %kk)
           %v0 = affine.load %B[%k, %jT] : memref<512 x 32 x f32>
           "foo"(%v0) : (f32) -> ()
         }
         affine.for %ii = 0 to 16 { // i intratile.
-          %i = affine.apply (d0, d1) -> (16*d0 + d1)(%iT, %ii)
+          %i = affine.apply affine_map<(d0, d1) -> (16*d0 + d1)>(%iT, %ii)
           %v1 = affine.load %A[%i, %kT] : memref<512 x 32 x f32>
           "bar"(%v1) : (f32) -> ()
         }
         affine.for %ii_ = 0 to 16 { // i intratile.
           %v2 = "abc_compute"() : () -> f32
-          %i_ = affine.apply (d0, d1) -> (16*d0 + d1)(%iT, %ii_)
+          %i_ = affine.apply affine_map<(d0, d1) -> (16*d0 + d1)>(%iT, %ii_)
           %v3 =  affine.load %C[%i_, %jT] : memref<512 x 32 x f32>
           %v4 = "addf32"(%v2, %v3) : (f32, f32) -> (f32)
           affine.store %v4, %C[%i_, %jT] : memref<512 x 32 x f32>
         }
         "foobar"() : () -> ()
       }
     }
   }

 // CHECK-NEXT:      dealloc %{{.*}} : memref<1x2xf32, 2>
 // CHECK-NEXT:    }
 // CHECK-NEXT:    return
 func @loop_nest_modulo() {
   %A = alloc() : memref<256 x 8 x f32>
   affine.for %i = 0 to 32 step 4 {
     // DMAs will be performed at this level (%j is the first unit stride loop)
     affine.for %j = 0 to 8 {
-      %idx = affine.apply (d0) -> (d0 mod 2) (%j)
+      %idx = affine.apply affine_map<(d0) -> (d0 mod 2)> (%j)
       // A buffer of size 32 x 2 will be allocated (original buffer was 256 x 8).
       %v = affine.load %A[%i, %idx] : memref<256 x 8 x f32>
     }
   }
   return
 }
 
 // -----
 
 // DMA on tiled loop nest. This also tests the case where the bounds are
 // dependent on outer loop IVs.
 // CHECK-LABEL: func @loop_nest_tiled() -> memref<256x1024xf32> {
 func @loop_nest_tiled() -> memref<256x1024xf32> {
   %0 = alloc() : memref<256x1024xf32>
   affine.for %i0 = 0 to 256 step 32 {
     affine.for %i1 = 0 to 1024 step 32 {
 // CHECK:      %{{.*}} = alloc() : memref<32x32xf32, 2>
 // CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
 // Strided DMA here: 32 x 32 tile in a 256 x 1024 memref.
 // CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<256x1024xf32>, memref<32x32xf32, 2>, memref<1xi32>
 // CHECK-NEXT: affine.dma_wait
 // CHECK-NEXT: affine.for %{{.*}} = #map
 // CHECK-NEXT:   affine.for %{{.*}} = #map
-      affine.for %i2 = (d0) -> (d0)(%i0) to (d0) -> (d0 + 32)(%i0) {
-        affine.for %i3 = (d0) -> (d0)(%i1) to (d0) -> (d0 + 32)(%i1) {
+      affine.for %i2 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 32)>(%i0) {
+        affine.for %i3 = affine_map<(d0) -> (d0)>(%i1) to affine_map<(d0) -> (d0 + 32)>(%i1) {
           // CHECK: %{{.*}} = affine.load %{{.*}}[-%{{.*}} + %{{.*}}, -%{{.*}} + %{{.*}}] : memref<32x32xf32, 2>
           %1 = affine.load %0[%i2, %i3] : memref<256x1024xf32>
         } // CHECK-NEXT: }
       }
     }
   }
   return %0 : memref<256x1024xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @dma_constant_dim_access
 func @dma_constant_dim_access(%A : memref<100x100xf32>) {
   %one = constant 1 : index
   %N = constant 100 : index
   // CHECK:      %{{.*}} = alloc() : memref<1x100xf32, 2>
   // CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
   // No strided DMA needed here.
   // CHECK:      affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}  : memref<100x100xf32>, memref<1x100xf32, 2>,
   // CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
   affine.for %i = 0 to 100 {
-    affine.for %j = 0 to ()[s0] -> (s0) ()[%N] {
+    affine.for %j = 0 to affine_map<()[s0] -> (s0)> ()[%N] {
       // CHECK: %{{.*}} = affine.load %{{.*}}[0, %{{.*}}] : memref<1x100xf32, 2>
       affine.load %A[%one, %j] : memref<100 x 100 x f32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK-DAG: [[MAP_SYM_SHIFT:#map[0-9]+]] = (d0, d1)[s0, s1] -> (d1 + s0 + s1)
+// CHECK-DAG: [[MAP_SYM_SHIFT:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d1 + s0 + s1)>
 
 // CHECK-LABEL: func @dma_with_symbolic_accesses
 func @dma_with_symbolic_accesses(%A : memref<100x100xf32>, %M : index) {
   %N = constant 9 : index
   affine.for %i = 0 to 100 {
     affine.for %j = 0 to 100 {
-      %idy = affine.apply (d0, d1) [s0, s1] -> (d1 + s0 + s1)(%i, %j)[%M, %N]
+      %idy = affine.apply affine_map<(d0, d1) [s0, s1] -> (d1 + s0 + s1)>(%i, %j)[%M, %N]
       affine.load %A[%i, %idy] : memref<100 x 100 x f32>
     }
   }
   return
 // CHECK:       %{{.*}} = alloc() : memref<100x100xf32, 2>
 // CHECK-NEXT:  %{{.*}} = alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[0, symbol(%{{.*}}) + 9], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}}

 // The buffer size can't be bound by a constant smaller than the original
 // memref size; so the DMA buffer is the entire 100x100.
 // CHECK:       %{{.*}} = alloc() : memref<100x100xf32, 2>
 // CHECK-NEXT:  %{{.*}} = alloc() : memref<1xi32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
   affine.for %i = 0 to 100 {
     affine.for %j = %M to %N {
-      %idy = affine.apply (d1) [s0] -> (d1 + s0)(%j)[%K]
+      %idy = affine.apply affine_map<(d1) [s0] -> (d1 + s0)>(%j)[%K]
       affine.load %A[%i, %idy] : memref<100 x 100 x f32>
     }
   }
   return
 }
 
 // -----
 

 
 // -----
 
 // CHECK-LABEL: func @dma_memref_3d
 func @dma_memref_3d(%arg0: memref<1024x1024x1024xf32>) {
   affine.for %i = 0 to 1024 {
     affine.for %j = 0 to 1024 {
       affine.for %k = 0 to 1024 {
-        %idx = affine.apply (d0) -> (d0 mod 128)(%i)
-        %idy = affine.apply (d0) -> (d0 mod 128)(%j)
-        %idz = affine.apply (d0) -> (d0 mod 128)(%k)
+        %idx = affine.apply affine_map<(d0) -> (d0 mod 128)>(%i)
+        %idy = affine.apply affine_map<(d0) -> (d0 mod 128)>(%j)
+        %idz = affine.apply affine_map<(d0) -> (d0 mod 128)>(%k)
         // DMA with nested striding (or emulating with loop around strided DMA)
         // not yet implemented.
         // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<1024x1024x1024xf32>
         %v = affine.load %arg0[%idx, %idy, %idz] : memref<1024 x 1024 x 1024 x f32>
         // expected-error@-10 {{copy generation failed for one or more memref's in this block}}
       }
     }
   }
   return
 }
 
 // -----
 
-// CHECK-DAG: [[MAP_PLUS_64:#map[0-9]+]] = (d0) -> (d0 + 64)
-// CHECK-DAG: [[MAP_PLUS_128:#map[0-9]+]] = (d0) -> (d0 + 128)
-// CHECK-DAG: [[MAP_PLUS_2:#map[0-9]+]] = (d0) -> (d0 + 2)
-// CHECK-DAG: [[MAP_PLUS_192:#map[0-9]+]] = (d0) -> (d0 + 192)
+// CHECK-DAG: [[MAP_PLUS_64:#map[0-9]+]] = affine_map<(d0) -> (d0 + 64)>
+// CHECK-DAG: [[MAP_PLUS_128:#map[0-9]+]] = affine_map<(d0) -> (d0 + 128)>
+// CHECK-DAG: [[MAP_PLUS_2:#map[0-9]+]] = affine_map<(d0) -> (d0 + 2)>
+// CHECK-DAG: [[MAP_PLUS_192:#map[0-9]+]] = affine_map<(d0) -> (d0 + 192)>
 
 // The first load accesses ([2,258), [128,384))
 // The second load accesses ([64,320), [2,258))
 // The first store writes to ([2,258), [192,448))
 // The second store writes to ([128,320), [2,258))
 // The union of all these regions is of size 318 x 446 and has its origin at (2,
 // 2), i.e., the window ([2,320), [2,448)) in the original space.
 
 // CHECK-LABEL: func @multi_load_store_union() {
 func @multi_load_store_union() {
   %A = alloc() : memref<512 x 512 x f32>
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 256 {
-      %idx = affine.apply (d0) -> (d0 + 64)(%i)
-      %idy = affine.apply (d0) -> (d0 + 128)(%j)
-      %ishift = affine.apply (d0) -> (d0 + 2)(%i)
-      %jshift = affine.apply (d0) -> (d0 + 2)(%j)
+      %idx = affine.apply affine_map<(d0) -> (d0 + 64)>(%i)
+      %idy = affine.apply affine_map<(d0) -> (d0 + 128)>(%j)
+      %ishift = affine.apply affine_map<(d0) -> (d0 + 2)>(%i)
+      %jshift = affine.apply affine_map<(d0) -> (d0 + 2)>(%j)
 
       %u = affine.load %A[%ishift, %idy] : memref<512 x 512 x f32>
       %v = affine.load %A[%idx, %jshift] : memref<512 x 512 x f32>
 
-      %sidx = affine.apply (d0) -> (d0 + 128)(%i)
-      %sidy = affine.apply (d0) -> (d0 + 192)(%j)
+      %sidx = affine.apply affine_map<(d0) -> (d0 + 128)>(%i)
+      %sidy = affine.apply affine_map<(d0) -> (d0 + 192)>(%j)
 
       affine.store %u, %A[%ishift, %sidy] : memref<512 x 512 x f32>
       affine.store %v, %A[%sidx, %jshift] : memref<512 x 512 x f32>
     }
   }
   return
 }
 // CHECK:       %{{.*}} = alloc() : memref<512x512xf32>

 // CHECK:         affine.for %{{.*}} = 0 to 256 {
 // CHECK-NEXT:      %{{.*}} = affine.load [[BUF]][%{{.*}}, %{{.*}}] : memref<256x256xvector<8xf32>, 2>
 
 // -----
 
 // CHECK-LABEL: func @relative_loop_bounds
 func @relative_loop_bounds(%arg0: memref<1027xf32>) {
   affine.for %i0 = 0 to 1024 {
-    affine.for %i2 = (d0) -> (d0)(%i0) to (d0) -> (d0 + 4)(%i0) {
+    affine.for %i2 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 4)>(%i0) {
       %0 = constant 0.0 : f32
       affine.store %0, %arg0[%i2] : memref<1027xf32>
     }
   }
   return
 }
 // CHECK:      [[BUF:%[0-9]+]] = alloc() : memref<1027xf32, 2>
 // CHECK-NEXT: [[MEM:%[0-9]+]] = alloc() : memref<1xi32>
 // CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
 // CHECK-NEXT:    affine.for %{{.*}} = {{#map[0-9]+}}(%{{.*}}) to {{#map[0-9]+}}(%{{.*}}) {
 // CHECK-NEXT:      %{{.*}} = constant 0.000000e+00 : f32
 // CHECK-NEXT:      affine.store %{{.*}}, [[BUF]][%{{.*}}] : memref<1027xf32, 2>
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // CHECK-NEXT:  affine.dma_start [[BUF]][%{{.*}}], %{{.*}}[%{{.*}}], [[MEM]][%{{.*}}], %{{.*}}  : memref<1027xf32, 2>, memref<1027xf32>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait [[MEM]][%{{.*}}], %{{.*}} : memref<1xi32>
 
 // -----
 
-// CHECK-DAG: [[MAP_READ_OFFSET:#map[0-9]+]] = (d0) -> (d0 + 100)
-// CHECK-DAG: [[MAP_WRITE_OFFSET:#map[0-9]+]] = (d0) -> (d0 + 25)
+// CHECK-DAG: [[MAP_READ_OFFSET:#map[0-9]+]] = affine_map<(d0) -> (d0 + 100)>
+// CHECK-DAG: [[MAP_WRITE_OFFSET:#map[0-9]+]] = affine_map<(d0) -> (d0 + 25)>
 
 func @test_read_write_region_union() {
   %0 = alloc() : memref<256xf32>
   affine.for %i0 = 0 to 10 {
     // memref dims:  [0, 256)
     // read region:  [100, 110)
     // write region: [25, 35)
     // union region: [25, 110)
-    %a0 = affine.apply (d0) -> (d0 + 100)(%i0)
-    %a1 = affine.apply (d0) -> (d0 + 25)(%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0 + 100)>(%i0)
+    %a1 = affine.apply affine_map<(d0) -> (d0 + 25)>(%i0)
     %1 = affine.load %0[%a0] : memref<256xf32>
     affine.store %1, %0[%a1] : memref<256xf32>
   }
   return
 }
 
 // CHECK:       %{{.*}} = alloc() : memref<256xf32>
 // CHECK-NEXT:  %{{.*}} = alloc() : memref<85xf32, 2>

 // CHECK-NEXT:  }
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<85xf32, 2>, memref<256xf32>, memref<1xi32>
 // CHECK-NEXT:  affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
 
 // -----
 
 // This should create a buffer of size 2 affine.for %arg2.
 
-#map_lb = (d0) -> (d0)
-#map_ub = (d0) -> (d0 + 3)
-#map_acc = (d0) -> (d0 floordiv 8)
+#map_lb = affine_map<(d0) -> (d0)>
+#map_ub = affine_map<(d0) -> (d0 + 3)>
+#map_acc = affine_map<(d0) -> (d0 floordiv 8)>
 // CHECK-LABEL: func @test_analysis_util
 func @test_analysis_util(%arg0: memref<4x4x16x1xf32>, %arg1: memref<144x9xf32>, %arg2: memref<2xf32>) -> (memref<144x9xf32>, memref<2xf32>) {
   %c0 = constant 0 : index
   %0 = alloc() : memref<64x1xf32>
   %1 = alloc() : memref<144x4xf32>
   %2 =  constant 0.0 : f32
   affine.for %i8 = 0 to 9 step 3 {
     affine.for %i9 = #map_lb(%i8) to #map_ub(%i8) {

 // CHECK:       affine.for %{{.*}} = 0 to 9 step 3 {
 // CHECK:         [[BUF:%[0-9]+]] = alloc() : memref<2xf32, 2>
 // CHECK:         affine.dma_start %{{.*}}[%{{.*}} floordiv 8], [[BUF]]
 // CHECK:         affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
 // CHECK:         affine.for %{{.*}} =
 
 // ----
 
-#map3 = (d0) -> (d0)
-#map12 = (d0) -> (d0 + 3)
-#map14 = (d0, d1) -> ((d0 + d1 * 72) floordiv 2304 + ((((d0 + d1 * 72) mod 2304) mod 1152) mod 9) floordiv 3)
-#map15 = (d0, d1) -> ((d0 + d1 * 72) mod 2304 - (((d0 + d1 * 72) mod 2304) floordiv 1152) * 1151 - ((((d0 + d1 * 72) mod 2304) mod 1152) floordiv 9) * 9 - (((((d0 + d1 * 72) mod 2304) mod 1152) mod 9) floordiv 3) * 3)
-#map16 = (d0, d1) -> (((((d0 + d1 * 72) mod 2304) mod 1152) floordiv 9) floordiv 8)
+#map3 = affine_map<(d0) -> (d0)>
+#map12 = affine_map<(d0) -> (d0 + 3)>
+#map14 = affine_map<(d0, d1) -> ((d0 + d1 * 72) floordiv 2304 + ((((d0 + d1 * 72) mod 2304) mod 1152) mod 9) floordiv 3)>
+#map15 = affine_map<(d0, d1) -> ((d0 + d1 * 72) mod 2304 - (((d0 + d1 * 72) mod 2304) floordiv 1152) * 1151 - ((((d0 + d1 * 72) mod 2304) mod 1152) floordiv 9) * 9 - (((((d0 + d1 * 72) mod 2304) mod 1152) mod 9) floordiv 3) * 3)>
+#map16 = affine_map<(d0, d1) -> (((((d0 + d1 * 72) mod 2304) mod 1152) floordiv 9) floordiv 8)>
 // Test for test case in b/128303048 #4.
 func @test_memref_bounds(%arg0: memref<4x4x16x1xvector<8x128xf32>>, %arg1: memref<144x9xvector<8x128xf32>>, %arg2: memref<2xvector<8x128xf32>>) -> (memref<144x9xvector<8x128xf32>>, memref<2xvector<8x128xf32>>) {
   %c0 = constant 0 : index
   affine.for %i8 = 0 to 9 step 3 {
     affine.for %i9 = #map3(%i8) to #map12(%i8) {
       affine.for %i10 = 0 to 64 {
         %10 = affine.apply #map14(%i9, %i10)
         %11 = affine.apply #map15(%i9, %i10)
func @load_store_same_memref(%arg0: memref<256x1024xf32>) {
   // FAST-MEM-16KB:  affine.for %{{.*}} = 0 to 256 step 4
   affine.for %i0 = 0 to 256 step 4 {
     // FAST-MEM-16KB: [[BUF:%[0-9]+]] = alloc() : memref<4x1024xf32, 2>
     // FAST-MEM-16KB:    affine.dma_start %{{.*}}
     // FAST-MEM-16KB-NEXT: affine.dma_wait
     // FAST-MEM-16KB:  affine.for %{{.*}}
     affine.for %i1 = 0 to 1024 step 4 {
       // FAST-MEM-16KB:  affine.for %{{.*}}
-      affine.for %i2 = (d0) -> (d0)(%i0) to (d0) -> (d0 + 4)(%i0) {
+      affine.for %i2 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 4)>(%i0) {
         // FAST-MEM-16KB:  affine.for %{{.*}}
-        affine.for %i3 = (d0) -> (d0)(%i1) to (d0) -> (d0 + 4)(%i1) {
+        affine.for %i3 = affine_map<(d0) -> (d0)>(%i1) to affine_map<(d0) -> (d0 + 4)>(%i1) {
           %3 = affine.load %arg0[%i2, %i3] : memref<256x1024xf32>
           %4 = mulf %3, %3 : f32
           affine.store %4, %arg0[%i2, %i3] : memref<256x1024xf32>
         } // FAST-MEM-16KB: }
       } // FAST-MEM-16KB: }
     } // FAST-MEM-16KB: }
     // FAST-MEM-16KB:    affine.dma_start [[BUF]]
     // FAST-MEM-16KB-NEXT: affine.dma_wait
   }
   return
 }
 
 // -----
 
 // This a 3-d loop nest tiled by 4 x 4 x 4. Under %i, %j, %k, the size of a
 // tile of arg0, arg1, and arg2 accessed is 4 KB (each), i.e., 12 KB in total.
 // With fast mem capacity set to 16 KB, the DMAs if placed under %k will fit.
 // However, the region of arg2 accessed is invariant w.r.t the %k loop unlike
 // %arg0 and %arg1. So, its DMA can be hoisted one level up and placed under
 // %j, while the DMAs for arg0 and arg1 appear right under the %k loop.
 
-#map0 = (d0) -> (d0)
-#map1 = (d0) -> (d0 + 4)
+#map0 = affine_map<(d0) -> (d0)>
+#map1 = affine_map<(d0) -> (d0 + 4)>
 // FAST-MEM-16KB-LABEL: func @simple_matmul
 func @simple_matmul(%arg0: memref<8x8xvector<64xf32>>, %arg1: memref<8x8xvector<64xf32>>, %arg2: memref<8x8xvector<64xf32>>) -> memref<8x8xvector<64xf32>> {
   affine.for %i = 0 to 8 step 4 {
     affine.for %j = 0 to 8 step 4 {
       affine.for %k = 0 to 8 step 4 {
         affine.for %ii = #map0(%i) to #map1(%i) {
           affine.for %jj = #map0(%j) to #map1(%j) {
             affine.for %kk = #map0(%k) to #map1(%k) {

mlir/test/Transforms/loop-fusion-slice-computation.mlir

 // Slice loop bounds should be adjusted such that the load/store are for the
 // same location.
 // CHECK-LABEL: func @slice_depth1_loop_nest_with_offsets() {
 func @slice_depth1_loop_nest_with_offsets() {
   %0 = alloc() : memref<100xf32>
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 16 {
     // expected-remark@-1 {{slice ( src loop: 1, dst loop: 0, depth: 1 : insert point: (1, 2) loop bounds: [(d0) -> (d0 + 3), (d0) -> (d0 + 4)] )}}
-    %a0 = affine.apply (d0) -> (d0 + 2)(%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0 + 2)>(%i0)
     affine.store %cst, %0[%a0] : memref<100xf32>
   }
   affine.for %i1 = 4 to 8 {
     // expected-remark@-1 {{slice ( src loop: 0, dst loop: 1, depth: 1 : insert point: (1, 0) loop bounds: [(d0) -> (d0 - 3), (d0) -> (d0 - 2)] )}}
-    %a1 = affine.apply (d0) -> (d0 - 1)(%i1)
+    %a1 = affine.apply affine_map<(d0) -> (d0 - 1)>(%i1)
     %1 = affine.load %0[%a1] : memref<100xf32>
   }
   return
 }
 
 // -----
 
 // Slices at loop depth 1 should only slice the loop bounds of the first loop.

mlir/test/Transforms/loop-fusion.mlir

func @should_fuse_reduction_to_pointwise() {
   // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
-// CHECK-DAG: [[MAP_SHIFT_MINUS_ONE_R1:#map[0-9]+]] = (d0) -> (d0 - 1)
-// CHECK-DAG: [[MAP_SHIFT_BY_ONE:#map[0-9]+]] = (d0) -> (d0 + 1)
+// CHECK-DAG: [[MAP_SHIFT_MINUS_ONE_R1:#map[0-9]+]] = affine_map<(d0) -> (d0 - 1)>
+// CHECK-DAG: [[MAP_SHIFT_BY_ONE:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
 
 // CHECK-LABEL: func @should_fuse_loop_nests_with_shifts() {
 func @should_fuse_loop_nests_with_shifts() {
   %a = alloc() : memref<10x10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 9 {
     affine.for %i1 = 0 to 9 {
-      %idx = affine.apply (d0) -> (d0 + 1) (%i0)
-      %idy = affine.apply (d0) -> (d0 + 1) (%i1)
+      %idx = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0)
+      %idy = affine.apply affine_map<(d0) -> (d0 + 1)> (%i1)
       affine.store %cf7, %a[%idx, %idy] : memref<10x10xf32>
     }
   }
   affine.for %i2 = 1 to 10 {
     affine.for %i3 = 1 to 10 {
       %v0 = affine.load %a[%i2, %i3] : memref<10x10xf32>
     }
   }
func @should_fuse_no_top_level_access() {
   // CHECK-NEXT:   %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: return
   return
 }
 
 // -----
 
-#set0 = (d0) : (1 == 0)
+#set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK-LABEL: func @should_not_fuse_if_inst_at_top_level() {
 func @should_not_fuse_if_inst_at_top_level() {
   %m = alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
 
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
func @should_not_fuse_if_inst_at_top_level() {
   // CHECK:      affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:   %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT: }
   return
 }
 
 // -----
 
-#set0 = (d0) : (1 == 0)
+#set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK-LABEL: func @should_not_fuse_if_inst_in_loop_nest() {
 func @should_not_fuse_if_inst_in_loop_nest() {
   %m = alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %c4 = constant 4 : index
 
   affine.for %i0 = 0 to 10 {

 // CHECK-NEXT:  }
 // CHECK-NEXT:  return
 
   return
 }
 
 // -----
 
-// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d0 * 4 + d1)
-// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0) -> (d0 floordiv 4)
-// CHECK-DAG: [[MAP2:#map[0-9]+]] = (d0) -> (d0 mod 4)
+// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1)>
+// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 4)>
+// CHECK-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 mod 4)>
 
 // Reshape from a 64 x f32 to 16 x 4 x f32.
 // CHECK-LABEL: func @fuse_reshape_64_16_4
 func @fuse_reshape_64_16_4(%in : memref<64xf32>) {
   %out = alloc() : memref<16x4xf32>
 
   affine.for %i0 = 0 to 64 {
     %v = affine.load %in[%i0] : memref<64xf32>
-    %idx = affine.apply (d0) -> (d0 floordiv 4) (%i0)
-    %idy = affine.apply (d0) -> (d0 mod 4) (%i0)
+    %idx = affine.apply affine_map<(d0) -> (d0 floordiv 4)> (%i0)
+    %idy = affine.apply affine_map<(d0) -> (d0 mod 4)> (%i0)
     affine.store %v, %out[%idx, %idy] : memref<16x4xf32>
   }
 
   affine.for %i1 = 0 to 16 {
     affine.for %i2 = 0 to 4 {
       %w = affine.load %out[%i1, %i2] : memref<16x4xf32>
       "foo"(%w) : (f32) -> ()
     }
   }
   return
   // CHECK:      affine.for %{{.*}} =
   // CHECK-NEXT:   affine.for %{{.*}} =
   // CHECK-NOT:    for
   // CHECK:        }
   // CHECK-NEXT: }
   // CHECK-NEXT: return
 }
 
 // -----
-// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0 floordiv 4)
-// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0) -> (d0 mod 4)
-// CHECK-DAG: [[MAP2:#map[0-9]+]] = (d0, d1) -> (d0 * 4 + d1)
+// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 4)>
+// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 mod 4)>
+// CHECK-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 4 + d1)>
 
 // Reshape a 16x4xf32 to 64xf32.
 // CHECK-LABEL: func @fuse_reshape_16_4_64
 func @fuse_reshape_16_4_64() {
   %in = alloc() : memref<16x4xf32>
   %out = alloc() : memref<64xf32>
 
   affine.for %i0 = 0 to 16 {
     affine.for %i1 = 0 to 4 {
       %v = affine.load %in[%i0, %i1] : memref<16x4xf32>
-      %idx = affine.apply (d0, d1) -> (4*d0 + d1) (%i0, %i1)
+      %idx = affine.apply affine_map<(d0, d1) -> (4*d0 + d1)> (%i0, %i1)
       affine.store %v, %out[%idx] : memref<64xf32>
     }
   }
 
   affine.for %i2 = 0 to 64 {
     %w = affine.load %out[%i2] : memref<64xf32>
     "foo"(%w) : (f32) -> ()
   }
affine.for %i1 = 0 to 2 {
         }
       }
     }
   }
 
   affine.for %ii = 0 to 64 {
     affine.for %jj = 0 to 9 {
       // Convert output coordinates to linear index.
-      %a0 = affine.apply (d0, d1) -> (d0 * 9 + d1) (%ii, %jj)
-      %0 = affine.apply (d0) -> (d0 floordiv (2 * 3 * 3 * 16 * 1))(%a0)
-      %1 = affine.apply (d0) -> ((d0 mod 288) floordiv (3 * 3 * 16 * 1))(%a0)
-      %2 = affine.apply (d0) -> (((d0 mod 288) mod 144) floordiv (3 * 16 * 1))(%a0)
-      %3 = affine.apply (d0) -> ((((d0 mod 288) mod 144) mod 48) floordiv (16 * 1))(%a0)
-      %4 = affine.apply (d0) -> ((((d0 mod 288) mod 144) mod 48) mod 16)(%a0)
-      %5 = affine.apply (d0) -> (((((d0 mod 144) mod 144) mod 48) mod 16) mod 1)(%a0)
+      %a0 = affine.apply affine_map<(d0, d1) -> (d0 * 9 + d1)> (%ii, %jj)
+      %0 = affine.apply affine_map<(d0) -> (d0 floordiv (2 * 3 * 3 * 16 * 1))>(%a0)
+      %1 = affine.apply affine_map<(d0) -> ((d0 mod 288) floordiv (3 * 3 * 16 * 1))>(%a0)
+      %2 = affine.apply affine_map<(d0) -> (((d0 mod 288) mod 144) floordiv (3 * 16 * 1))>(%a0)
+      %3 = affine.apply affine_map<(d0) -> ((((d0 mod 288) mod 144) mod 48) floordiv (16 * 1))>(%a0)
+      %4 = affine.apply affine_map<(d0) -> ((((d0 mod 288) mod 144) mod 48) mod 16)>(%a0)
+      %5 = affine.apply affine_map<(d0) -> (((((d0 mod 144) mod 144) mod 48) mod 16) mod 1)>(%a0)
       %v = affine.load %in[%0, %1, %2, %3, %4, %5] : memref<2x2x3x3x16x1xi32>
       affine.store %v, %out[%ii, %jj] : memref<64x9xi32>
     }
   }
 
   affine.for %i = 0 to 64 {
     affine.for %j = 0 to 9 {
       %a = affine.load %out[%i, %j] : memref<64x9xi32>
       %b = muli %a, %a : i32
       affine.store %b, %live_out[%i, %j] : memref<64x9xi32>
     }
   }
   return %live_out : memref<64x9xi32>
 }
 // Everything above is fused to a single 2-d loop nest, and the 6-d tensor %in
 // is eliminated if -memref-dataflow-opt is also supplied.
 //
-// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0, d1) -> ((d0 * 9 + d1) floordiv 288)
-// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0, d1) -> (((d0 * 9 + d1) mod 288) floordiv 144)
-// CHECK-DAG: [[MAP2:#map[0-9]+]] = (d0, d1) -> ((((d0 * 9 + d1) mod 288) mod 144) floordiv 48)
-// CHECK-DAG: [[MAP3:#map[0-9]+]] = (d0, d1) -> (((((d0 * 9 + d1) mod 288) mod 144) mod 48) floordiv 16)
-// CHECK-DAG: [[MAP4:#map[0-9]+]] = (d0, d1) -> (((((d0 * 9 + d1) mod 288) mod 144) mod 48) mod 16)
-// CHECK-DAG: [[MAP11:#map[0-9]+]] = (d0, d1) -> (d0 * 9 + d1)
-// CHECK-DAG: [[MAP12:#map[0-9]+]] = (d0) -> (d0 floordiv 288)
-// CHECK-DAG: [[MAP13:#map[0-9]+]] = (d0) -> ((d0 mod 288) floordiv 144)
-// CHECK-DAG: [[MAP14:#map[0-9]+]] = (d0) -> (((d0 mod 288) mod 144) floordiv 48)
-// CHECK-DAG: [[MAP15:#map[0-9]+]] = (d0) -> ((((d0 mod 288) mod 144) mod 48) floordiv 16)
-// CHECK-DAG: [[MAP16:#map[0-9]+]] = (d0) -> ((((d0 mod 288) mod 144) mod 48) mod 16)
-// CHECK-DAG: [[MAP17:#map[0-9]+]] = (d0) -> (0)
+// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> ((d0 * 9 + d1) floordiv 288)>
+// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (((d0 * 9 + d1) mod 288) floordiv 144)>
+// CHECK-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> ((((d0 * 9 + d1) mod 288) mod 144) floordiv 48)>
+// CHECK-DAG: [[MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 9 + d1) mod 288) mod 144) mod 48) floordiv 16)>
+// CHECK-DAG: [[MAP4:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 9 + d1) mod 288) mod 144) mod 48) mod 16)>
+// CHECK-DAG: [[MAP11:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 9 + d1)>
+// CHECK-DAG: [[MAP12:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 288)>
+// CHECK-DAG: [[MAP13:#map[0-9]+]] = affine_map<(d0) -> ((d0 mod 288) floordiv 144)>
+// CHECK-DAG: [[MAP14:#map[0-9]+]] = affine_map<(d0) -> (((d0 mod 288) mod 144) floordiv 48)>
+// CHECK-DAG: [[MAP15:#map[0-9]+]] = affine_map<(d0) -> ((((d0 mod 288) mod 144) mod 48) floordiv 16)>
+// CHECK-DAG: [[MAP16:#map[0-9]+]] = affine_map<(d0) -> ((((d0 mod 288) mod 144) mod 48) mod 16)>
+// CHECK-DAG: [[MAP17:#map[0-9]+]] = affine_map<(d0) -> (0)>
 
 //
 // CHECK-LABEL: func @R6_to_R2_reshape
 // CHECK:       %{{.*}} = alloc() : memref<1x2x3x3x16x1xi32>
 // CHECK:       %{{.*}} = alloc() : memref<1x1xi32>
 // CHECK:       %{{.*}} = alloc() : memref<64x9xi32>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 64 {
 // CHECK-NEXT:    affine.for %{{.*}} = 0 to 9 {

 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // CHECK-NEXT:  return %{{.*}} : memref<64x9xi32>
 
 // -----
 
 // CHECK-LABEL: func @fuse_symbolic_bounds
 func @fuse_symbolic_bounds(%M : index, %N : index) {
-  %N_plus_5 = affine.apply (d0) -> (d0 + 5)(%N)
+  %N_plus_5 = affine.apply affine_map<(d0) -> (d0 + 5)>(%N)
   %m = alloc(%M, %N_plus_5) : memref<? x ? x f32>
 
   %c0 = constant 0.0 : f32
   %s = constant 5 : index
 
   affine.for %i0 = 0 to %M {
-    affine.for %i1 = 0 to (d0) -> (d0 + 5) (%N) {
+    affine.for %i1 = 0 to affine_map<(d0) -> (d0 + 5)> (%N) {
       affine.store %c0, %m[%i0, %i1] : memref<? x ? x f32>
     }
   }
 
   affine.for %i2 = 0 to %M {
     affine.for %i3 = 0 to %N {
-      %idy = affine.apply (d0)[s0] -> (d0 + s0) (%i3)[%s]
+      %idy = affine.apply affine_map<(d0)[s0] -> (d0 + s0)> (%i3)[%s]
       %v = affine.load %m[%i2, %idy] : memref<? x ? x f32>
     }
   }
 
   return
 }
 
 // -----
func @should_fuse_at_src_depth1_and_dst_depth1() {
   // CHECK-NEXT:      "op2"(%{{.*}}) : (f32) -> ()
   // CHECK-NEXT:    }
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   return
 }
 
 // -----
-// CHECK: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d0 * 10 + d1)
+// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 10 + d1)>
 
 // CHECK-LABEL: func @should_fuse_src_depth1_at_dst_depth2
 func @should_fuse_src_depth1_at_dst_depth2() {
   %a = alloc() : memref<100xf32>
   %c0 = constant 0.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.store %c0, %a[%i0] : memref<100xf32>
   }
 
   affine.for %i1 = 0 to 10 {
     affine.for %i2 = 0 to 10 {
-      %a0 = affine.apply (d0, d1) -> (d0 * 10 + d1) (%i1, %i2)
+      %a0 = affine.apply affine_map<(d0, d1) -> (d0 * 10 + d1)> (%i1, %i2)
       %v0 = affine.load %a[%a0] : memref<100xf32>
     }
   }
   // The source loop nest slice loop bound is a function of both destination
   // loop IVs, so we should slice at depth 1 and insert the slice at depth 2.
   // CHECK:       affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:    affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:      %{{.*}} = affine.apply [[MAP0]](%{{.*}}, %{{.*}})
affine.for %i1 = 0 to 3 {
         %val = "foo"(%i0, %i1, %i2) : (index, index, index) -> i32
         affine.store %val, %in[%i0, %i1, %i2] : memref<2x3x16xi32>
       }
     }
   }
 
   affine.for %ii = 0 to 32 {
     affine.for %jj = 0 to 3 {
-      %a0 = affine.apply (d0, d1) -> (d0 * 3 + d1) (%ii, %jj)
-      %idx = affine.apply (d0) -> (d0 floordiv (3 * 16)) (%a0)
+      %a0 = affine.apply affine_map<(d0, d1) -> (d0 * 3 + d1)> (%ii, %jj)
+      %idx = affine.apply affine_map<(d0) -> (d0 floordiv (3 * 16))> (%a0)
       %v = affine.load %in[%idx, %jj, %c0]
         : memref<2x3x16xi32>
     }
   }
   return
 }
-// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0, d1) -> ((d0 * 3 + d1) floordiv 48)
-// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0, d1) -> (d0 * 3 + d1)
-// CHECK-DAG: [[MAP2:#map[0-9]+]] = (d0) -> (d0 floordiv 48)
+// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> ((d0 * 3 + d1) floordiv 48)>
+// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 3 + d1)>
+// CHECK-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 floordiv 48)>
 
 // CHECK-LABEL: func @R3_to_R2_reshape()
 // CHECK-DAG:    %{{.*}} = alloc() : memref<1x1x1xi32>
 // CHECK:        affine.for %{{.*}} = 0 to 32 {
 // CHECK-NEXT:     affine.for %{{.*}} = 0 to 3 {
 // CHECK-NEXT:      %{{.*}} = affine.apply [[MAP0]](%{{.*}}, %{{.*}})
 // CHECK-NEXT:      %{{.*}} = "foo"(%{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index) -> i32
 // CHECK-NEXT:      affine.store %{{.*}}, %{{.*}}[0, 0, 0] : memref<1x1x1xi32>
func @should_fuse_and_preserve_dep_on_constant() {
   // CHECK-NEXT:    affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   return
 }
 
 // -----
 
-// CHECK: [[MAP2:#map[0-9]+]] = (d0, d1) -> (d0 * 16 - d1 + 15)
-// CHECK: [[MAP3:#map[0-9]+]] = (d0, d1) -> (d0 * 16 + d1)
+// CHECK: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>
+// CHECK: [[MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 
 // CHECK-LABEL: func @should_fuse_at_depth_above_loop_carried_dependence(%{{.*}}: memref<64x4xf32>, %{{.*}}: memref<64x4xf32>) {
 func @should_fuse_at_depth_above_loop_carried_dependence(%arg0: memref<64x4xf32>, %arg1: memref<64x4xf32>) {
   %out = alloc() : memref<64x4xf32>
   %0 = constant 0.0 : f32
   affine.for %i0 = 0 to 64 {
     affine.for %i1 = 0 to 4 {
       affine.store %0, %out[%i0, %i1] : memref<64x4xf32>
     }
   }
   affine.for %i2 = 0 to 4 {
     affine.for %i3 = 0 to 4 {
       affine.for %i4 = 0 to 16 {
-        %1 = affine.apply (d0, d1) -> (d0 * 16 - d1 + 15)(%i3, %i4)
+        %1 = affine.apply affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>(%i3, %i4)
         %2 = affine.load %arg1[%1, %i2] : memref<64x4xf32>
         "op0"(%2) : (f32) -> ()
       }
       affine.for %i5 = 0 to 4 {
         affine.for %i6 = 0 to 16 {
-          %3 = affine.apply (d0, d1) -> (d0 * 16 - d1 + 15)(%i5, %i6)
+          %3 = affine.apply affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>(%i5, %i6)
           %4 = affine.load %arg0[%3, %i3] : memref<64x4xf32>
           "op1"(%4) : (f32) -> ()
         }
         affine.for %i7 = 0 to 16 {
           %5 = "op2"() : () -> (f32)
-          %6 = affine.apply (d0, d1) -> (d0 * 16 + d1)(%i5, %i7)
+          %6 = affine.apply affine_map<(d0, d1) -> (d0 * 16 + d1)>(%i5, %i7)
           %7 = affine.load %out[%6, %i2] : memref<64x4xf32>
           %8 = addf %7, %5 : f32
           affine.store %8, %out[%6, %i2] : memref<64x4xf32>
         }
       }
     }
   }
 
func @should_fuse_live_out_writer(%arg0 : memref<10xf32>) -> memref<10xf32> {
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return %{{.*}} : memref<10xf32>
 }
 
 // -----
 
 // The fused slice has 16 iterations from along %i0.
 
-// CHECK-DAG: [[MAP_LB:#map[0-9]+]] = (d0) -> (d0 * 16)
-// CHECK-DAG: [[MAP_UB:#map[0-9]+]] = (d0) -> (d0 * 16 + 16)
+// CHECK-DAG: [[MAP_LB:#map[0-9]+]] = affine_map<(d0) -> (d0 * 16)>
+// CHECK-DAG: [[MAP_UB:#map[0-9]+]] = affine_map<(d0) -> (d0 * 16 + 16)>
 
-#map = (d0, d1) -> (d0 * 16 + d1)
+#map = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 
 // CHECK-LABEL: slice_tile
 func @slice_tile(%arg0: memref<128x8xf32>, %arg1: memref<32x8xf32>, %0 : f32) -> memref<32x8xf32> {
   affine.for %i0 = 0 to 32 {
     affine.for %i1 = 0 to 8 {
       affine.store %0, %arg1[%i0, %i1] : memref<32x8xf32>
     }
   }
func @test_add_slice_bounds() {
   %a = alloc() : memref<10xf32>
   %b = alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %c0 = constant 0 : index
 
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
-        %a0 = affine.apply (d0) -> (d0) (%i0)
-        %a1 = affine.apply (d0) -> (d0) (%i0)
-        %a2 = affine.apply (d0, d1) -> (d0 - d1) (%a0, %a1)
+        %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
+        %a1 = affine.apply affine_map<(d0) -> (d0)> (%i0)
+        %a2 = affine.apply affine_map<(d0, d1) -> (d0 - d1)> (%a0, %a1)
         affine.store %cf7, %a[%a2] : memref<10xf32>
       }
     }
   }
   affine.for %i3 = 0 to 10 {
     affine.for %i4 = 0 to 10 {
       affine.for %i5 = 0 to 10 {
         %v0 = affine.load %a[%c0] : memref<10xf32>

 // CHECK-NEXT:       "op2"(%{{.*}}) : (f32) -> ()
 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
   return
 }
 
 // -----
 
-#map0 = (d0, d1) -> (d0 * 16 + d1)
+#map0 = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 func @fuse_across_dim_mismatch(%arg0: memref<4x4x16x1xf32>, %arg1: memref<144x9xf32>, %arg2: memref<9xf32>) {
   %1 = alloc() : memref<144x4xf32>
   %2 = constant 0.0 : f32
   affine.for %i2 = 0 to 9 {
     affine.for %i3 = 0 to 4 {
       affine.for %i5 = 0 to 16 {
         %7 = affine.apply #map0(%i2, %i5)
         affine.store %2, %1[%7, %i3] : memref<144x4xf32>
       }
     }
   }
   affine.for %i6 = 0 to 9 {
     affine.for %i7 = 0 to 9 {
       affine.for %i8 = 0 to 4 {
         affine.for %i10 = 0 to 16 {
           %10 = affine.apply #map0(%i6, %i10)
           %11 = affine.load %1[%10, %i8] : memref<144x4xf32>
         }
       }
     }
   }
   return
 }
-// MAXIMAL:      #map0 = (d0, d1) -> (d0 * 16 + d1)
+// MAXIMAL:      #map0 = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 // MAXIMAL-LABEL: func @fuse_across_dim_mismatch
 // MAXIMAL:        %{{.*}} = alloc() : memref<1x1xf32>
 // MAXIMAL:        affine.for %{{.*}} = 0 to 9 {
 // MAXIMAL-NEXT:    affine.for %{{.*}} = 0 to 9 {
 // MAXIMAL-NEXT:      affine.for %{{.*}} = 0 to 4 {
 // MAXIMAL-NEXT:        affine.for %{{.*}} = 0 to 16 {
 // MAXIMAL-NEXT:          %{{.*}} = affine.apply #map0(%{{.*}}, %{{.*}})
 // MAXIMAL-NEXT:          affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
 // MAXIMAL-NEXT:          %{{.*}} = affine.apply #map0(%{{.*}}, %{{.*}})
 // MAXIMAL-NEXT:          %{{.*}} = affine.load %{{.*}}[0, 0] : memref<1x1xf32>
 // MAXIMAL-NEXT:        }
 // MAXIMAL-NEXT:      }
 // MAXIMAL-NEXT:    }
 // MAXIMAL-NEXT:  }
 
 // -----
 
-#map3 = (d0, d1) -> ((d0 * 72 + d1) floordiv 2304)
-#map4 = (d0, d1) -> (((d0 * 72 + d1) mod 2304) floordiv 1152)
-#map5 = (d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)
-#map6 = (d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)
-#map7 = (d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) mod 3)
-#map10 = (d0, d1) -> (d0 * 16 + d1)
-#map11 = (d0, d1) -> (d0 * 16 + d1)
-#map12 = (d0, d1) -> (d0 * 16 - d1 + 15)
+#map3 = affine_map<(d0, d1) -> ((d0 * 72 + d1) floordiv 2304)>
+#map4 = affine_map<(d0, d1) -> (((d0 * 72 + d1) mod 2304) floordiv 1152)>
+#map5 = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)>
+#map6 = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)>
+#map7 = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) mod 3)>
+#map10 = affine_map<(d0, d1) -> (d0 * 16 + d1)>
+#map11 = affine_map<(d0, d1) -> (d0 * 16 + d1)>
+#map12 = affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>
 func @fuse_across_varying_dims_complex(%arg0: f32) {
   %c0 = constant 0 : index
   %0 = alloc() : memref<2x2x3x3x16x1xf32>
   %1 = alloc() : memref<64x9xf32>
   %2 = alloc() : memref<144x4xf32>
   affine.for %i0 = 0 to 64 {
     affine.for %i1 = 0 to 9 {
       %4 = affine.apply #map3(%i0, %i1)
affine.for %i7 = 0 to 9 {
           %15 = affine.apply #map12(%i8, %i9)
           %16 = affine.load %1[%15, %i7] : memref<64x9xf32>
         }
       }
     }
   }
   return
 }
-// MAXIMAL-DAG: [[MAP0:#map[0-9]+]] = (d0, d1) -> ((d0 * 72 + d1) floordiv 2304)
-// MAXIMAL-DAG: [[MAP1:#map[0-9]+]] = (d0, d1) -> (((d0 * 72 + d1) mod 2304) floordiv 1152)
-// MAXIMAL-DAG: [[MAP2:#map[0-9]+]] = (d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)
-// MAXIMAL-DAG: [[MAP3:#map[0-9]+]] = (d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)
-// MAXIMAL-DAG: [[MAP4:#map[0-9]+]] = (d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) mod 3)
-// MAXIMAL-DAG: [[MAP7:#map[0-9]+]] = (d0, d1) -> (d0 * 16 + d1)
-// MAXIMAL-DAG: [[MAP8:#map[0-9]+]] = (d0, d1) -> (d0 * 16 - d1 + 15)
+// MAXIMAL-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> ((d0 * 72 + d1) floordiv 2304)>
+// MAXIMAL-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (((d0 * 72 + d1) mod 2304) floordiv 1152)>
+// MAXIMAL-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)>
+// MAXIMAL-DAG: [[MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)>
+// MAXIMAL-DAG: [[MAP4:#map[0-9]+]] = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) mod 3)>
+// MAXIMAL-DAG: [[MAP7:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 + d1)>
+// MAXIMAL-DAG: [[MAP8:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 - d1 + 15)>
 // MAXIMAL-LABEL: func @fuse_across_varying_dims_complex
 // MAXIMAL-NEXT:  %{{.*}} = alloc() : memref<64x1xf32>
 // MAXIMAL-NEXT:  %{{.*}} = constant 0 : index
 // MAXIMAL-NEXT:  %{{.*}} = alloc() : memref<2x2x3x3x16x1xf32>
 // MAXIMAL-NEXT:  %{{.*}} = alloc() : memref<144x4xf32>
 // MAXIMAL-NEXT:  affine.for %{{.*}} = 0 to 9 {
 // MAXIMAL-NEXT:    affine.for %{{.*}} = 0 to 9 {
 // MAXIMAL-NEXT:      affine.for %{{.*}} = 0 to 4 {

mlir/test/Transforms/loop-invariant-code-motion.mlir

func @single_loop_nothing_invariant() {
   return
 }
 
 func @invariant_code_inside_affine_if() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
 
   affine.for %arg0 = 0 to 10 {
-    %t0 = affine.apply (d1) -> (d1 + 1)(%arg0)
-    affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %t0) {
+    %t0 = affine.apply affine_map<(d1) -> (d1 + 1)>(%arg0)
+    affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %t0) {
         %cf9 = addf %cf8, %cf8 : f32
         affine.store %cf9, %m[%arg0] : memref<10xf32>
 
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: %1 = affine.apply #map3(%arg0)
   // CHECK-NEXT: affine.if #set0(%arg0, %1) {
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %2, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
 
 
   return
 }
 
 func @invariant_affine_if() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %[[CST:.*]] = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %[[ARG:.*]] = 0 to 10 {
   // CHECK-NEXT: affine.if #set0(%[[ARG]], %[[ARG]]) {
   // CHECK-NEXT: addf %[[CST]], %[[CST]] : f32
   // CHECK-NEXT: }
 
   return
 }
 
 func @invariant_affine_if2() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg1] : memref<10xf32>
       }
     }
   }
 
   // CHECK: alloc
   // CHECK-NEXT: constant
   // CHECK-NEXT: affine.for
   // CHECK-NEXT: affine.for
   // CHECK-NEXT: affine.if
   // CHECK-NEXT: addf
   // CHECK-NEXT: affine.store
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
   return
 }
 
 func @invariant_affine_nested_if() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
-          affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+          affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             %cf10 = addf %cf9, %cf9 : f32
           }
       }
     }
   }
 
   // CHECK: alloc
   // CHECK-NEXT: constant
func @invariant_affine_nested_if() {
   return
 }
 
 func @invariant_affine_nested_if_else() {
   %m = alloc() : memref<10xf32>
   %cf8 = constant 8.0 : f32
   affine.for %arg0 = 0 to 10 {
     affine.for %arg1 = 0 to 10 {
-      affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+      affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
           %cf9 = addf %cf8, %cf8 : f32
           affine.store %cf9, %m[%arg0] : memref<10xf32>
-          affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
+          affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %arg0) {
             %cf10 = addf %cf9, %cf9 : f32
           } else {
             affine.store %cf9, %m[%arg1] : memref<10xf32>
           }
       }
     }
   }
 

mlir/test/Transforms/loop-tiling.mlir

 // RUN: mlir-opt %s -split-input-file  -affine-loop-tile -tile-size=32 | FileCheck %s
 // RUN: mlir-opt %s -split-input-file -affine-loop-tile -tile-cache-size=512 | FileCheck %s --check-prefix=MODEL
 
 // -----
 
-// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0 + 32)
-// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0) -> (d0 + 32, 50)
-// CHECK-DAG: [[IDENTITY:#map[0-9]+]] = (d0) -> (d0)
+// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 + 32)>
+// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 + 32, 50)>
+// CHECK-DAG: [[IDENTITY:#map[0-9]+]] = affine_map<(d0) -> (d0)>
 
 // CHECK-LABEL: func @loop_tiling()
 // CHECK-NEXT:   affine.for %{{.*}} = 0 to 256 step 32 {
 // CHECK-NEXT:     affine.for %{{.*}} = 0 to 512 step 32 {
 // CHECK-NEXT:       affine.for %{{.*}} = 0 to 1024 step 32 {
 // CHECK-NEXT:         affine.for %{{.*}} = [[IDENTITY]](%{{.*}}) to [[MAP0]](%{{.*}}) {
 // CHECK-NEXT:           affine.for %{{.*}} = [[IDENTITY]](%{{.*}}) to [[MAP0]](%{{.*}}) {
 // CHECK-NEXT:             affine.for %{{.*}} = [[IDENTITY]](%{{.*}}) to [[MAP0]](%{{.*}}) {
affine.for %y = 0 to 21 {
     "foobar"(%y) : (index) -> ()
   }
 
   return
 }
 
 // -----
 
-// CHECK-DAG: [[IDENTITY:#map[0-9]+]] = (d0) -> (d0)
-// CHECK-DAG: [[LB:#map[0-9]+]] = ()[s0] -> (0, s0)
-// CHECK-DAG: [[UB:#map[0-9]+]] = ()[s0, s1] -> (s0, 4096 floordiv s1)
-// CHECK-DAG: [[UB_INTRA_TILE:#map[0-9]+]] = (d0)[s0, s1] -> (d0 + 32, s0, 4096 floordiv s1)
+// CHECK-DAG: [[IDENTITY:#map[0-9]+]] = affine_map<(d0) -> (d0)>
+// CHECK-DAG: [[LB:#map[0-9]+]] = affine_map<()[s0] -> (0, s0)>
+// CHECK-DAG: [[UB:#map[0-9]+]] = affine_map<()[s0, s1] -> (s0, 4096 floordiv s1)>
+// CHECK-DAG: [[UB_INTRA_TILE:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> (d0 + 32, s0, 4096 floordiv s1)>
 
-#lb = ()[s0] -> (0, s0)
-#ub = ()[s0, s1] -> (s0, 4096 floordiv s1)
+#lb = affine_map<()[s0] -> (0, s0)>
+#ub = affine_map<()[s0, s1] -> (s0, 4096 floordiv s1)>
 // CHECK-LABEL: func @loop_max_min_bound(%{{.*}}: memref<?xi32>, %{{.*}}: index, %{{.*}}: index) {
 func @loop_max_min_bound(%A : memref<? x i32>, %L : index, %U : index) {
   %M = dim %A, 0 : memref<? x i32>
   affine.for %iTT = max #lb()[%L] to min #ub()[%M, %U] {
-      %out = affine.apply (d0) -> (d0) (%iTT)
+      %out = affine.apply affine_map<(d0) -> (d0)> (%iTT)
   }
   return
 // CHECK:       affine.for %{{.*}} = max [[LB]]()[%{{.*}}] to min [[UB]]()[%{{.*}}, %{{.*}}] step 32 {
 // CHECK-NEXT:    affine.for %{{.*}} = [[IDENTITY]](%{{.*}}) to min [[UB_INTRA_TILE]](%{{.*}})[%{{.*}}, %{{.*}}] {
 // CHECK-NEXT:      %{{.*}} = affine.apply [[IDENTITY]](%{{.*}})
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 }

 }
 // MODEL:       affine.for %{{.*}} = 0 to 256 step 4 {
 // MODEL-NEXT:    affine.for %{{.*}} = 0 to 256 step 4 {
 // MODEL-NEXT:      affine.for %{{.*}} = 0 to 250 step 5 {
 
 
 // -----
 
-// CHECK-DAG: [[UBMAP:#map[0-9]+]] = (d0)[s0] -> (d0 + 32, s0)
+// CHECK-DAG: [[UBMAP:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 + 32, s0)>
 
 func @tile_with_symbolic_loop_upper_bounds(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
   %cst = constant 0.000000e+00 : f32
   %0 = dim %arg0, 0 : memref<?x?xf32>
   affine.for %i0 = 0 to %0 {
     affine.for %i1 = 0 to %0 {
       affine.store %cst, %arg2[%i0, %i1] : memref<?x?xf32>
       affine.for %i2 = 0 to %0 {

 // CHECK-NEXT:        }
 // CHECK-NEXT:      }
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // CHECK-NEXT:  return
 
 // -----
 
-// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0)
-// CHECK-DAG: [[MAP1:#map[0-9]+]] = ()[s0, s1] -> (s0 + s1)
-// CHECK-DAG: [[UBMAP:#map[0-9]+]] = (d0)[s0, s1] -> (d0 + 32, s0 + s1)
+// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0)>
+// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<()[s0, s1] -> (s0 + s1)>
+// CHECK-DAG: [[UBMAP:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> (d0 + 32, s0 + s1)>
 
 func @tile_with_loop_upper_bounds_in_two_symbols(%arg0: memref<?xf32>, %limit: index) {
   %dim0 = dim %arg0, 0 : memref<?xf32>
-  affine.for %i0 = 0 to ()[s0, s1] -> (s0 + s1) ()[%dim0, %limit] {
+  affine.for %i0 = 0 to affine_map<()[s0, s1] -> (s0 + s1)> ()[%dim0, %limit] {
     %v0 = affine.load %arg0[%i0] : memref<?xf32>
   }
   return
 }
 
 // CHECK:       %{{.*}} = dim %{{.*}}, 0 : memref<?xf32>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to [[MAP1]]()[%{{.*}}, %{{.*}}] step 32 {
 // CHECK-NEXT:    affine.for %{{.*}} = [[MAP0]](%{{.*}}) to min [[UBMAP]](%{{.*}})[%{{.*}}, %{{.*}}] {

mlir/test/Transforms/lower-affine.mlir

 // CHECK-NEXT:     for %{{.*}} = %{{.*}} to %[[c42]] step %[[c1_0]] {
 // CHECK-NEXT:       call @body2(%{{.*}}, %{{.*}}) : (index, index) -> ()
 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
 // CHECK-NEXT:   return
 // CHECK-NEXT: }
 func @affine_apply_loops_shorthand(%N : index) {
   affine.for %i = 0 to %N {
-    affine.for %j = (d0)[]->(d0)(%i)[] to 42 {
+    affine.for %j = affine_map<(d0)[]->(d0)>(%i)[] to 42 {
       call @body2(%i, %j) : (index, index) -> ()
     }
   }
   return
 }
 
 /////////////////////////////////////////////////////////////////////
 
 func @get_idx() -> (index)
 
-#set1 = (d0) : (20 - d0 >= 0)
-#set2 = (d0) : (d0 - 10 >= 0)
+#set1 = affine_set<(d0) : (20 - d0 >= 0)>
+#set2 = affine_set<(d0) : (d0 - 10 >= 0)>
 
 // CHECK-LABEL: func @if_only
 // CHECK-NEXT:   %[[v0:.*]] = call @get_idx() : () -> index
 // CHECK-NEXT:   %[[c0:.*]] = constant 0 : index
 // CHECK-NEXT:   %[[cm1:.*]] = constant -1 : index
 // CHECK-NEXT:   %[[v1:.*]] = muli %[[v0]], %[[cm1]] : index
 // CHECK-NEXT:   %[[c20:.*]] = constant 20 : index
 // CHECK-NEXT:   %[[v2:.*]] = addi %[[v1]], %[[c20]] : index
func @nested_ifs() {
   } else {
     affine.if #set2(%i) {
       call @mid(%i) : (index) -> ()
     }
   }
   return
 }
 
-#setN = (d0)[N,M,K,L] : (N - d0 + 1 >= 0, N - 1 >= 0, M - 1 >= 0, K - 1 >= 0, L - 42 == 0)
+#setN = affine_set<(d0)[N,M,K,L] : (N - d0 + 1 >= 0, N - 1 >= 0, M - 1 >= 0, K - 1 >= 0, L - 42 == 0)>
 
 // CHECK-LABEL: func @multi_cond
 // CHECK-NEXT:   %[[v0:.*]] = call @get_idx() : () -> index
 // CHECK-NEXT:   %[[c0:.*]] = constant 0 : index
 // CHECK-NEXT:   %[[cm1:.*]] = constant -1 : index
 // CHECK-NEXT:   %[[v1:.*]] = muli %[[v0]], %[[cm1]] : index
 // CHECK-NEXT:   %[[v2:.*]] = addi %[[v1]], %{{.*}} : index
 // CHECK-NEXT:   %[[c1:.*]] = constant 1 : index
affine.if #set2(%k) {
         call @body3(%k, %l) : (index, index) -> ()
       }
     }
   }
 //      CHECK:   return
   return
 }
 
-#lbMultiMap = (d0)[s0] -> (d0, s0 - d0)
-#ubMultiMap = (d0)[s0] -> (s0, d0 + 10)
+#lbMultiMap = affine_map<(d0)[s0] -> (d0, s0 - d0)>
+#ubMultiMap = affine_map<(d0)[s0] -> (s0, d0 + 10)>
 
 // CHECK-LABEL: func @loop_min_max
 // CHECK-NEXT:   %[[c0:.*]] = constant 0 : index
 // CHECK-NEXT:   %[[c42:.*]] = constant 42 : index
 // CHECK-NEXT:   %[[c1:.*]] = constant 1 : index
 // CHECK-NEXT:   for %{{.*}} = %[[c0]] to %[[c42]] step %[[c1]] {
 // CHECK-NEXT:     %[[cm1:.*]] = constant -1 : index
 // CHECK-NEXT:     %[[a:.*]] = muli %{{.*}}, %[[cm1]] : index
func @loop_min_max(%N : index) {
   affine.for %i = 0 to 42 {
     affine.for %j = max #lbMultiMap(%i)[%N] to min #ubMultiMap(%i)[%N] {
       call @body2(%i, %j) : (index, index) -> ()
     }
   }
   return
 }
 
-#map_7_values = (i) -> (i, i, i, i, i, i, i)
+#map_7_values = affine_map<(i) -> (i, i, i, i, i, i, i)>
 
 // Check that the "min" (cmpi "slt" + select) reduction sequence is emitted
 // correctly for a an affine map with 7 results.
 
 // CHECK-LABEL: func @min_reduction_tree
 // CHECK-NEXT:   %[[c0:.*]] = constant 0 : index
 // CHECK-NEXT:   %[[c01:.+]] = cmpi "slt", %{{.*}}, %{{.*}} : index
 // CHECK-NEXT:   %[[r01:.+]] = select %[[c01]], %{{.*}}, %{{.*}} : index
func @min_reduction_tree(%v : index) {
   affine.for %i = 0 to min #map_7_values(%v)[] {
     call @body(%i) : (index) -> ()
   }
   return
 }
 
 /////////////////////////////////////////////////////////////////////
 
-#map0 = () -> (0)
-#map1 = ()[s0] -> (s0)
-#map2 = (d0) -> (d0)
-#map3 = (d0)[s0] -> (d0 + s0 + 1)
-#map4 = (d0,d1,d2,d3)[s0,s1,s2] -> (d0 + 2*d1 + 3*d2 + 4*d3 + 5*s0 + 6*s1 + 7*s2)
-#map5 = (d0,d1,d2) -> (d0,d1,d2)
-#map6 = (d0,d1,d2) -> (d0 + d1 + d2)
+#map0 = affine_map<() -> (0)>
+#map1 = affine_map<()[s0] -> (s0)>
+#map2 = affine_map<(d0) -> (d0)>
+#map3 = affine_map<(d0)[s0] -> (d0 + s0 + 1)>
+#map4 = affine_map<(d0,d1,d2,d3)[s0,s1,s2] -> (d0 + 2*d1 + 3*d2 + 4*d3 + 5*s0 + 6*s1 + 7*s2)>
+#map5 = affine_map<(d0,d1,d2) -> (d0,d1,d2)>
+#map6 = affine_map<(d0,d1,d2) -> (d0 + d1 + d2)>
 
 // CHECK-LABEL: func @affine_applies(
 func @affine_applies(%arg0 : index) {
 // CHECK: %[[c0:.*]] = constant 0 : index
   %zero = affine.apply #map0()
 
 // Identity maps are just discarded.
 // CHECK-NEXT: %[[c101:.*]] = constant 101 : index

 
 //===---------------------------------------------------------------------===//
 // Test lowering of Euclidean (floor) division, ceil division and modulo
 // operation used in affine expressions.  In addition to testing the
 // operation-level output, check that the obtained results are correct by
 // applying constant folding transformation after affine lowering.
 //===---------------------------------------------------------------------===//
 
-#mapmod = (i) -> (i mod 42)
+#mapmod = affine_map<(i) -> (i mod 42)>
 
 // --------------------------------------------------------------------------//
 // IMPORTANT NOTE: if you change this test, also change the @lowered_affine_mod
 // test in the "constant-fold.mlir" test to reflect the expected output of
 // affine.apply lowering.
 // --------------------------------------------------------------------------//
 // CHECK-LABEL: func @affine_apply_mod
 func @affine_apply_mod(%arg0 : index) -> (index) {
 // CHECK-NEXT: %[[c42:.*]] = constant 42 : index
 // CHECK-NEXT: %[[v0:.*]] = remi_signed %{{.*}}, %[[c42]] : index
 // CHECK-NEXT: %[[c0:.*]] = constant 0 : index
 // CHECK-NEXT: %[[v1:.*]] = cmpi "slt", %[[v0]], %[[c0]] : index
 // CHECK-NEXT: %[[v2:.*]] = addi %[[v0]], %[[c42]] : index
 // CHECK-NEXT: %[[v3:.*]] = select %[[v1]], %[[v2]], %[[v0]] : index
   %0 = affine.apply #mapmod (%arg0)
   return %0 : index
 }
 
-#mapfloordiv = (i) -> (i floordiv 42)
+#mapfloordiv = affine_map<(i) -> (i floordiv 42)>
 
 // --------------------------------------------------------------------------//
 // IMPORTANT NOTE: if you change this test, also change the @lowered_affine_mod
 // test in the "constant-fold.mlir" test to reflect the expected output of
 // affine.apply lowering.
 // --------------------------------------------------------------------------//
 // CHECK-LABEL: func @affine_apply_floordiv
 func @affine_apply_floordiv(%arg0 : index) -> (index) {
 // CHECK-NEXT: %[[c42:.*]] = constant 42 : index
 // CHECK-NEXT: %[[c0:.*]] = constant 0 : index
 // CHECK-NEXT: %[[cm1:.*]] = constant -1 : index
 // CHECK-NEXT: %[[v0:.*]] = cmpi "slt", %{{.*}}, %[[c0]] : index
 // CHECK-NEXT: %[[v1:.*]] = subi %[[cm1]], %{{.*}} : index
 // CHECK-NEXT: %[[v2:.*]] = select %[[v0]], %[[v1]], %{{.*}} : index
 // CHECK-NEXT: %[[v3:.*]] = divi_signed %[[v2]], %[[c42]] : index
 // CHECK-NEXT: %[[v4:.*]] = subi %[[cm1]], %[[v3]] : index
 // CHECK-NEXT: %[[v5:.*]] = select %[[v0]], %[[v4]], %[[v3]] : index
   %0 = affine.apply #mapfloordiv (%arg0)
   return %0 : index
 }
 
-#mapceildiv = (i) -> (i ceildiv 42)
+#mapceildiv = affine_map<(i) -> (i ceildiv 42)>
 
 // --------------------------------------------------------------------------//
 // IMPORTANT NOTE: if you change this test, also change the @lowered_affine_mod
 // test in the "constant-fold.mlir" test to reflect the expected output of
 // affine.apply lowering.
 // --------------------------------------------------------------------------//
 // CHECK-LABEL: func @affine_apply_ceildiv
 func @affine_apply_ceildiv(%arg0 : index) -> (index) {

mlir/test/Transforms/memref-bound-check.mlir

 // RUN: mlir-opt %s -memref-bound-check -split-input-file -verify-diagnostics | FileCheck %s
 
 // -----
 
 // CHECK-LABEL: func @test() {
 func @test() {
   %zero = constant 0 : index
   %minusone = constant -1 : index
   %sym = constant 111 : index
 
   %A = alloc() : memref<9 x 9 x i32>
   %B = alloc() : memref<111 x i32>
 
   affine.for %i = -1 to 10 {
     affine.for %j = -1 to 10 {
-      %idx0 = affine.apply (d0, d1) -> (d0)(%i, %j)
-      %idx1 = affine.apply (d0, d1) -> (d1)(%i, %j)
+      %idx0 = affine.apply affine_map<(d0, d1) -> (d0)>(%i, %j)
+      %idx1 = affine.apply affine_map<(d0, d1) -> (d1)>(%i, %j)
       // Out of bound access.
       %x  = affine.load %A[%idx0, %idx1] : memref<9 x 9 x i32>
       // expected-error@-1 {{'affine.load' op memref out of upper bound access along dimension #1}}
       // expected-error@-2 {{'affine.load' op memref out of lower bound access along dimension #1}}
       // expected-error@-3 {{'affine.load' op memref out of upper bound access along dimension #2}}
       // expected-error@-4 {{'affine.load' op memref out of lower bound access along dimension #2}}
       // This will access 0 to 110 - hence an overflow.
-      %idy = affine.apply (d0, d1) -> (10*d0 - d1 + 19)(%i, %j)
+      %idy = affine.apply affine_map<(d0, d1) -> (10*d0 - d1 + 19)>(%i, %j)
       %y = affine.load %B[%idy] : memref<111 x i32>
     }
   }
 
   affine.for %k = 0 to 10 {
       // In bound.
       %u = affine.load %B[%zero] : memref<111 x i32>
       // Out of bounds.
       %v = affine.load %B[%sym] : memref<111 x i32> // expected-error {{'affine.load' op memref out of upper bound access along dimension #1}}
       // Out of bounds.
       affine.store %v, %B[%minusone] : memref<111 x i32>  // expected-error {{'affine.store' op memref out of lower bound access along dimension #1}}
   }
   return
 }
 
 // CHECK-LABEL: func @test_mod_floordiv_ceildiv
 func @test_mod_floordiv_ceildiv() {
   %zero = constant 0 : index
   %A = alloc() : memref<128 x 64 x 64 x i32>
 
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 256 {
-      %idx0 = affine.apply (d0, d1, d2) -> (d0 mod 128 + 1)(%i, %j, %j)
-      %idx1 = affine.apply (d0, d1, d2) -> (d1 floordiv 4 + 1)(%i, %j, %j)
-      %idx2 = affine.apply (d0, d1, d2) -> (d2 ceildiv 4)(%i, %j, %j)
+      %idx0 = affine.apply affine_map<(d0, d1, d2) -> (d0 mod 128 + 1)>(%i, %j, %j)
+      %idx1 = affine.apply affine_map<(d0, d1, d2) -> (d1 floordiv 4 + 1)>(%i, %j, %j)
+      %idx2 = affine.apply affine_map<(d0, d1, d2) -> (d2 ceildiv 4)>(%i, %j, %j)
       %x  = affine.load %A[%idx0, %idx1, %idx2] : memref<128 x 64 x 64 x i32>
       // expected-error@-1 {{'affine.load' op memref out of upper bound access along dimension #1}}
       // expected-error@-2 {{'affine.load' op memref out of upper bound access along dimension #2}}
       // expected-error@-3 {{'affine.load' op memref out of upper bound access along dimension #3}}
-      %idy0 = affine.apply (d0, d1, d2) -> (d0 mod 128)(%i, %j, %j)
-      %idy1 = affine.apply (d0, d1, d2) -> (d1 floordiv 4)(%i, %j, %j)
-      %idy2 = affine.apply (d0, d1, d2) -> (d2 ceildiv 4 - 1)(%i, %j, %j)
+      %idy0 = affine.apply affine_map<(d0, d1, d2) -> (d0 mod 128)>(%i, %j, %j)
+      %idy1 = affine.apply affine_map<(d0, d1, d2) -> (d1 floordiv 4)>(%i, %j, %j)
+      %idy2 = affine.apply affine_map<(d0, d1, d2) -> (d2 ceildiv 4 - 1)>(%i, %j, %j)
       affine.store %x, %A[%idy0, %idy1, %idy2] : memref<128 x 64 x 64 x i32> // expected-error {{'affine.store' op memref out of lower bound access along dimension #3}}
     } // CHECK }
   } // CHECK }
   return
 }
 
 // CHECK-LABEL: func @test_no_out_of_bounds()
 func @test_no_out_of_bounds() {
   %zero = constant 0 : index
   %A = alloc() : memref<257 x 256 x i32>
   %C = alloc() : memref<257 x i32>
   %B = alloc() : memref<1 x i32>
 
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 256 {
       // All of these accesses are in bound; check that no errors are emitted.
       // CHECK: %{{.*}} = affine.apply {{#map.*}}(%{{.*}}, %{{.*}})
       // CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<257x256xi32>
       // CHECK-NEXT: %{{.*}} = affine.apply {{#map.*}}(%{{.*}}, %{{.*}})
       // CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<1xi32>
-      %idx0 = affine.apply (d0, d1) -> ( 64 * (d0 ceildiv 64))(%i, %j)
+      %idx0 = affine.apply affine_map<(d0, d1) -> ( 64 * (d0 ceildiv 64))>(%i, %j)
       // Without GCDTightenInequalities(), the upper bound on the region
       // accessed along first memref dimension would have come out as d0 <= 318
       // (instead of d0 <= 256), and led to a false positive out of bounds.
       %x  = affine.load %A[%idx0, %zero] : memref<257 x 256 x i32>
-      %idy = affine.apply (d0, d1) -> (d0 floordiv 256)(%i, %i)
+      %idy = affine.apply affine_map<(d0, d1) -> (d0 floordiv 256)>(%i, %i)
       %y  = affine.load %B[%idy] : memref<1 x i32>
     } // CHECK-NEXT }
   }
   return
 }
 
 // CHECK-LABEL: func @mod_div
 func @mod_div() {
   %zero = constant 0 : index
   %A = alloc() : memref<128 x 64 x 64 x i32>
 
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 256 {
-      %idx0 = affine.apply (d0, d1, d2) -> (d0 mod 128 + 1)(%i, %j, %j)
-      %idx1 = affine.apply (d0, d1, d2) -> (d1 floordiv 4 + 1)(%i, %j, %j)
-      %idx2 = affine.apply (d0, d1, d2) -> (d2 ceildiv 4)(%i, %j, %j)
+      %idx0 = affine.apply affine_map<(d0, d1, d2) -> (d0 mod 128 + 1)>(%i, %j, %j)
+      %idx1 = affine.apply affine_map<(d0, d1, d2) -> (d1 floordiv 4 + 1)>(%i, %j, %j)
+      %idx2 = affine.apply affine_map<(d0, d1, d2) -> (d2 ceildiv 4)>(%i, %j, %j)
       %x  = affine.load %A[%idx0, %idx1, %idx2] : memref<128 x 64 x 64 x i32>
       // expected-error@-1 {{'affine.load' op memref out of upper bound access along dimension #1}}
       // expected-error@-2 {{'affine.load' op memref out of upper bound access along dimension #2}}
       // expected-error@-3 {{'affine.load' op memref out of upper bound access along dimension #3}}
-      %idy0 = affine.apply (d0, d1, d2) -> (d0 mod 128)(%i, %j, %j)
-      %idy1 = affine.apply (d0, d1, d2) -> (d1 floordiv 4)(%i, %j, %j)
-      %idy2 = affine.apply (d0, d1, d2) -> (d2 ceildiv 4 - 1)(%i, %j, %j)
+      %idy0 = affine.apply affine_map<(d0, d1, d2) -> (d0 mod 128)>(%i, %j, %j)
+      %idy1 = affine.apply affine_map<(d0, d1, d2) -> (d1 floordiv 4)>(%i, %j, %j)
+      %idy2 = affine.apply affine_map<(d0, d1, d2) -> (d2 ceildiv 4 - 1)>(%i, %j, %j)
       affine.store %x, %A[%idy0, %idy1, %idy2] : memref<128 x 64 x 64 x i32> // expected-error {{'affine.store' op memref out of lower bound access along dimension #3}}
     }
   }
   return
 }
 
 // Tests with nested mod's and floordiv's.
 // CHECK-LABEL: func @mod_floordiv_nested() {
 func @mod_floordiv_nested() {
   %A = alloc() : memref<256 x 256 x i32>
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 256 {
-      %idx0 = affine.apply (d0, d1) -> ((d0 mod 1024) floordiv 4)(%i, %j)
-      %idx1 = affine.apply (d0, d1) -> ((((d1 mod 128) mod 32) ceildiv 4) * 32)(%i, %j)
+      %idx0 = affine.apply affine_map<(d0, d1) -> ((d0 mod 1024) floordiv 4)>(%i, %j)
+      %idx1 = affine.apply affine_map<(d0, d1) -> ((((d1 mod 128) mod 32) ceildiv 4) * 32)>(%i, %j)
       affine.load %A[%idx0, %idx1] : memref<256 x 256 x i32> // expected-error {{'affine.load' op memref out of upper bound access along dimension #2}}
     }
   }
   return
 }
 
 // CHECK-LABEL: func @test_semi_affine_bailout
 func @test_semi_affine_bailout(%N : index) {
   %B = alloc() : memref<10 x i32>
   affine.for %i = 0 to 10 {
-    %idx = affine.apply (d0)[s0] -> (d0 * s0)(%i)[%N]
+    %idx = affine.apply affine_map<(d0)[s0] -> (d0 * s0)>(%i)[%N]
     %y = affine.load %B[%idx] : memref<10 x i32>
     // expected-error@-1 {{getMemRefRegion: compose affine map failed}}
   }
   return
 }
 
 // CHECK-LABEL: func @multi_mod_floordiv
 func @multi_mod_floordiv() {
   %A = alloc() : memref<2x2xi32>
   affine.for %ii = 0 to 64 {
-      %idx0 = affine.apply (d0) -> ((d0 mod 147456) floordiv 1152) (%ii)
-      %idx1 = affine.apply (d0) -> (((d0 mod 147456) mod 1152) floordiv 384) (%ii)
+      %idx0 = affine.apply affine_map<(d0) -> ((d0 mod 147456) floordiv 1152)> (%ii)
+      %idx1 = affine.apply affine_map<(d0) -> (((d0 mod 147456) mod 1152) floordiv 384)> (%ii)
       %v = affine.load %A[%idx0, %idx1] : memref<2x2xi32>
   }
   return
 }
 
 // CHECK-LABEL: func @delinearize_mod_floordiv
 func @delinearize_mod_floordiv() {
   %c0 = constant 0 : index
   %in = alloc() : memref<2x2x3x3x16x1xi32>
   %out = alloc() : memref<64x9xi32>
 
   // Reshape '%in' into '%out'.
   affine.for %ii = 0 to 64 {
     affine.for %jj = 0 to 9 {
-      %a0 = affine.apply (d0, d1) -> (d0 * (9 * 1024) + d1 * 128) (%ii, %jj)
-      %a10 = affine.apply (d0) ->
-        (d0 floordiv (2 * 3 * 3 * 128 * 128)) (%a0)
-      %a11 = affine.apply (d0) ->
-        ((d0 mod 294912) floordiv (3 * 3 * 128 * 128)) (%a0)
-      %a12 = affine.apply (d0) ->
-        ((((d0 mod 294912) mod 147456) floordiv 1152) floordiv 8) (%a0)
-      %a13 = affine.apply (d0) ->
-        ((((d0 mod 294912) mod 147456) mod 1152) floordiv 384) (%a0)
-      %a14 = affine.apply (d0) ->
-        (((((d0 mod 294912) mod 147456) mod 1152) mod 384) floordiv 128) (%a0)
-      %a15 = affine.apply (d0) ->
+      %a0 = affine.apply affine_map<(d0, d1) -> (d0 * (9 * 1024) + d1 * 128)> (%ii, %jj)
+      %a10 = affine.apply affine_map<(d0) ->
+        (d0 floordiv (2 * 3 * 3 * 128 * 128))> (%a0)
+      %a11 = affine.apply affine_map<(d0) ->
+        ((d0 mod 294912) floordiv (3 * 3 * 128 * 128))> (%a0)
+      %a12 = affine.apply affine_map<(d0) ->
+        ((((d0 mod 294912) mod 147456) floordiv 1152) floordiv 8)> (%a0)
+      %a13 = affine.apply affine_map<(d0) ->
+        ((((d0 mod 294912) mod 147456) mod 1152) floordiv 384)> (%a0)
+      %a14 = affine.apply affine_map<(d0) ->
+        (((((d0 mod 294912) mod 147456) mod 1152) mod 384) floordiv 128)> (%a0)
+      %a15 = affine.apply affine_map<(d0) ->
         ((((((d0 mod 294912) mod 147456) mod 1152) mod 384) mod 128)
-          floordiv 128) (%a0)
+          floordiv 128)> (%a0)
       %v0 = affine.load %in[%a10, %a11, %a13, %a14, %a12, %a15]
         : memref<2x2x3x3x16x1xi32>
     }
   }
   return
 }
 
 // CHECK-LABEL: func @zero_d_memref
 func @zero_d_memref(%arg0: memref<i32>) {
   %c0 = constant 0 : i32
   // A 0-d memref always has in-bound accesses!
   affine.store %c0, %arg0[] : memref<i32>
   return
 }
 
 // CHECK-LABEL: func @out_of_bounds
 func @out_of_bounds() {
   %in = alloc() : memref<1xi32>
   %c9 = constant 9 : i32
 
   affine.for %i0 = 10 to 11 {
-    %idy = affine.apply (d0) ->  (100 * d0 floordiv 1000) (%i0)
+    %idy = affine.apply affine_map<(d0) ->  (100 * d0 floordiv 1000)> (%i0)
     affine.store %c9, %in[%idy] : memref<1xi32> // expected-error {{'affine.store' op memref out of upper bound access along dimension #1}}
   }
   return
 }
 
 // -----
 
 // This test case accesses within bounds. Without removal of a certain type of
 // trivially redundant constraints (those differing only in their constant
 // term), the number of constraints here explodes, and this would return out of
 // bounds errors conservatively due to FlatAffineConstraints::kExplosionFactor.
-#map3 = (d0, d1) -> ((d0 * 72 + d1) floordiv 2304 + ((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)
-#map4 = (d0, d1) -> ((d0 * 72 + d1) mod 2304 - (((d0 * 72 + d1) mod 2304) floordiv 1152) * 1151 - ((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) * 9 - (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3) * 3)
-#map5 = (d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)
+#map3 = affine_map<(d0, d1) -> ((d0 * 72 + d1) floordiv 2304 + ((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3)>
+#map4 = affine_map<(d0, d1) -> ((d0 * 72 + d1) mod 2304 - (((d0 * 72 + d1) mod 2304) floordiv 1152) * 1151 - ((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) * 9 - (((((d0 * 72 + d1) mod 2304) mod 1152) mod 9) floordiv 3) * 3)>
+#map5 = affine_map<(d0, d1) -> (((((d0 * 72 + d1) mod 2304) mod 1152) floordiv 9) floordiv 8)>
 // CHECK-LABEL: func @test_complex_mod_floordiv
 func @test_complex_mod_floordiv(%arg0: memref<4x4x16x1xf32>) {
   %c0 = constant 0 : index
   %0 = alloc() : memref<1x2x3x3x16x1xf32>
   affine.for %i0 = 0 to 64 {
     affine.for %i1 = 0 to 9 {
       %2 = affine.apply #map3(%i0, %i1)
       %3 = affine.apply #map4(%i0, %i1)
       %4 = affine.apply #map5(%i0, %i1)
       %5 = affine.load %arg0[%2, %c0, %4, %c0] : memref<4x4x16x1xf32>
     }
   }
   return
 }
 
 // -----
 
 // The first load is within bounds, but not the second one.
-#map0 = (d0) -> (d0 mod 4)
-#map1 = (d0) -> (d0 mod 4 + 4)
+#map0 = affine_map<(d0) -> (d0 mod 4)>
+#map1 = affine_map<(d0) -> (d0 mod 4 + 4)>
 
 // CHECK-LABEL: func @test_mod_bound
 func @test_mod_bound() {
   %0 = alloc() : memref<7 x f32>
   %1 = alloc() : memref<6 x f32>
   affine.for %i0 = 0 to 4096 {
     affine.for %i1 = #map0(%i0) to #map1(%i0) {
       affine.load %0[%i1] : memref<7 x f32>
       affine.load %1[%i1] : memref<6 x f32>
       // expected-error@-1 {{'affine.load' op memref out of upper bound access along dimension #1}}
     }
   }
   return
 }
 
 // -----
 
-#map0 = (d0) -> (d0 floordiv 4)
-#map1 = (d0) -> (d0 floordiv 4 + 4)
-#map2 = (d0) -> (4 * (d0 floordiv 4)  + d0 mod 4)
+#map0 = affine_map<(d0) -> (d0 floordiv 4)>
+#map1 = affine_map<(d0) -> (d0 floordiv 4 + 4)>
+#map2 = affine_map<(d0) -> (4 * (d0 floordiv 4)  + d0 mod 4)>
 
 // CHECK-LABEL: func @test_floordiv_bound
 func @test_floordiv_bound() {
   %0 = alloc() : memref<1027 x f32>
   %1 = alloc() : memref<1026 x f32>
   %2 = alloc() : memref<4096 x f32>
   %N = constant 2048 : index
   affine.for %i0 = 0 to 4096 {
func @test_floordiv_bound() {
   return
 }
 
 // -----
 
 // This should not give an out of bounds error. The result of the affine.apply
 // is composed into the bound map during analysis.
 
-#map_lb = (d0) -> (d0)
-#map_ub = (d0) -> (d0 + 4)
+#map_lb = affine_map<(d0) -> (d0)>
+#map_ub = affine_map<(d0) -> (d0 + 4)>
 
 // CHECK-LABEL: func @non_composed_bound_operand
 func @non_composed_bound_operand(%arg0: memref<1024xf32>) {
   affine.for %i0 = 4 to 1028 step 4 {
-    %i1 = affine.apply (d0) -> (d0 - 4) (%i0)
+    %i1 = affine.apply affine_map<(d0) -> (d0 - 4)> (%i0)
     affine.for %i2 = #map_lb(%i1) to #map_ub(%i1) {
         %0 = affine.load %arg0[%i2] : memref<1024xf32>
     }
   }
   return
 }

mlir/test/Transforms/memref-dataflow-opt.mlir

 // RUN: mlir-opt %s -memref-dataflow-opt | FileCheck %s
 
-// CHECK-DAG: [[MAP0:#map[0-9]+]] = (d0, d1) -> (d1 + 1)
-// CHECK-DAG: [[MAP1:#map[0-9]+]] = (d0, d1) -> (d0)
-// CHECK-DAG: [[MAP2:#map[0-9]+]] = (d0, d1) -> (d1)
-// CHECK-DAG: [[MAP3:#map[0-9]+]] = (d0, d1) -> (d0 - 1)
-// CHECK-DAG: [[MAP4:#map[0-9]+]] = (d0) -> (d0 + 1)
+// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d1 + 1)>
+// CHECK-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0)>
+// CHECK-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (d1)>
+// CHECK-DAG: [[MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 - 1)>
+// CHECK-DAG: [[MAP4:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
 
 // CHECK-LABEL: func @simple_store_load() {
 func @simple_store_load() {
   %cf7 = constant 7.0 : f32
   %m = alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
     %v0 = affine.load %m[%i0] : memref<10xf32>

 // The store-load forwarding can see through affine apply's since it relies on
 // dependence information.
 // CHECK-LABEL: func @store_load_affine_apply
 func @store_load_affine_apply() -> memref<10x10xf32> {
   %cf7 = constant 7.0 : f32
   %m = alloc() : memref<10x10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
-      %t0 = affine.apply (d0, d1) -> (d1 + 1)(%i0, %i1)
-      %t1 = affine.apply (d0, d1) -> (d0)(%i0, %i1)
-      %idx0 = affine.apply (d0, d1) -> (d1) (%t0, %t1)
-      %idx1 = affine.apply (d0, d1) -> (d0 - 1) (%t0, %t1)
+      %t0 = affine.apply affine_map<(d0, d1) -> (d1 + 1)>(%i0, %i1)
+      %t1 = affine.apply affine_map<(d0, d1) -> (d0)>(%i0, %i1)
+      %idx0 = affine.apply affine_map<(d0, d1) -> (d1)> (%t0, %t1)
+      %idx1 = affine.apply affine_map<(d0, d1) -> (d0 - 1)> (%t0, %t1)
       affine.store %cf7, %m[%idx0, %idx1] : memref<10x10xf32>
       // CHECK-NOT: affine.load %{{[0-9]+}}
       %v0 = affine.load %m[%i0, %i1] : memref<10x10xf32>
       %v1 = addf %v0, %v0 : f32
     }
   }
   // The memref and its stores won't be erased due to this memref return.
   return %m : memref<10x10xf32>
func @store_load_store_nested_fwd(%N : index) -> f32 {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %m = alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     affine.store %cf7, %m[%i0] : memref<10xf32>
     affine.for %i1 = 0 to %N {
       %v0 = affine.load %m[%i0] : memref<10xf32>
       %v1 = addf %v0, %v0 : f32
-      %idx = affine.apply (d0) -> (d0 + 1) (%i0)
+      %idx = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0)
       affine.store %cf9, %m[%idx] : memref<10xf32>
     }
   }
   // Due to this load, the memref isn't optimized away.
   %v3 = affine.load %m[%c1] : memref<10xf32>
   return %v3 : f32
 // CHECK:       %{{.*}} = alloc() : memref<10xf32>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to 10 {
func @should_not_fwd(%A: memref<100xf32>, %M : index, %N : index) -> f32 {
   // CHECK: affine.load %{{.*}}[%{{.*}}]
   %v = affine.load %A[%N] : memref<100xf32>
   return %v : f32
 }
 
 // Can store forward to A[%j, %i], but no forwarding to load on %A[%i, %j]
 // CHECK-LABEL: func @refs_not_known_to_be_equal
 func @refs_not_known_to_be_equal(%A : memref<100 x 100 x f32>, %M : index) {
-  %N = affine.apply (d0) -> (d0 + 1) (%M)
+  %N = affine.apply affine_map<(d0) -> (d0 + 1)> (%M)
   %cf1 = constant 1.0 : f32
   affine.for %i = 0 to 100 {
   // CHECK: affine.for %[[I:.*]] =
     affine.for %j = 0 to 100 {
     // CHECK: affine.for %[[J:.*]] =
       // CHECK: affine.load %{{.*}}[%[[I]], %[[J]]]
       %u = affine.load %A[%i, %j] : memref<100x100xf32>
       // CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%[[J]], %[[I]]]

mlir/test/Transforms/memref-dependence-check.mlir

 // RUN: mlir-opt %s -test-memref-dependence-check  -split-input-file -verify-diagnostics | FileCheck %s
 
 // -----
 
-#set0 = (d0) : (1 == 0)
+#set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK-LABEL: func @store_may_execute_before_load() {
 func @store_may_execute_before_load() {
   %m = alloc() : memref<10xf32>
   %cf7 = constant 7.0 : f32
   %c0 = constant 4 : index
   // There is a dependence from store 0 to load 1 at depth 1 because the
   // ancestor IfOp of the store, dominates the ancestor ForSmt of the load,

 }
 
 // -----
 // CHECK-LABEL: func @store_load_diff_element_affine_apply_const() {
 func @store_load_diff_element_affine_apply_const() {
   %m = alloc() : memref<100xf32>
   %c1 = constant 1 : index
   %c8 = constant 8.0 : f32
-  %a0 = affine.apply (d0) -> (d0) (%c1)
+  %a0 = affine.apply affine_map<(d0) -> (d0)> (%c1)
   affine.store %c8, %m[%a0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
-  %a1 = affine.apply (d0) -> (d0 + 1) (%c1)
+  %a1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%c1)
   %v0 = affine.load %m[%a1] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_same_element_affine_apply_const() {
 func @store_load_same_element_affine_apply_const() {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c9 = constant 9 : index
   %c11 = constant 11 : index
-  %a0 = affine.apply (d0) -> (d0 + 1) (%c9)
+  %a0 = affine.apply affine_map<(d0) -> (d0 + 1)> (%c9)
   affine.store %c7, %m[%a0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
-  %a1 = affine.apply (d0) -> (d0 - 1) (%c11)
+  %a1 = affine.apply affine_map<(d0) -> (d0 - 1)> (%c11)
   %v0 = affine.load %m[%a1] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_affine_apply_symbol(%arg0: index) {
 func @store_load_affine_apply_symbol(%arg0: index) {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
-  %a0 = affine.apply (d0) -> (d0) (%arg0)
+  %a0 = affine.apply affine_map<(d0) -> (d0)> (%arg0)
   affine.store %c7, %m[%a0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
-  %a1 = affine.apply (d0) -> (d0) (%arg0)
+  %a1 = affine.apply affine_map<(d0) -> (d0)> (%arg0)
   %v0 = affine.load %m[%a1] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_affine_apply_symbol_offset(%arg0: index) {
 func @store_load_affine_apply_symbol_offset(%arg0: index) {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
-  %a0 = affine.apply (d0) -> (d0) (%arg0)
+  %a0 = affine.apply affine_map<(d0) -> (d0)> (%arg0)
   affine.store %c7, %m[%a0] : memref<100xf32>
   // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
-  %a1 = affine.apply (d0) -> (d0 + 1) (%arg0)
+  %a1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%arg0)
   %v0 = affine.load %m[%a1] : memref<100xf32>
   // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
   // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_range_load_after_range() {
 func @store_range_load_after_range() {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c10 = constant 10 : index
   affine.for %i0 = 0 to 10 {
-    %a0 = affine.apply (d0) -> (d0) (%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
-    %a1 = affine.apply (d0) -> (d0) (%c10)
+    %a1 = affine.apply affine_map<(d0) -> (d0)> (%c10)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_load_func_symbol(%arg0: index, %arg1: index) {
 func @store_load_func_symbol(%arg0: index, %arg1: index) {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c10 = constant 10 : index
   affine.for %i0 = 0 to %arg1 {
-    %a0 = affine.apply (d0) -> (d0) (%arg0)
+    %a0 = affine.apply affine_map<(d0) -> (d0)> (%arg0)
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = [1, +inf]}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [1, +inf]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}
-    %a1 = affine.apply (d0) -> (d0) (%arg0)
+    %a1 = affine.apply affine_map<(d0) -> (d0)> (%arg0)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, +inf]}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_range_load_last_in_range() {
 func @store_range_load_last_in_range() {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c10 = constant 10 : index
   affine.for %i0 = 0 to 10 {
-    %a0 = affine.apply (d0) -> (d0) (%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     // For dependence from 0 to 1, we do not have a loop carried dependence
     // because only the final write in the loop accesses the same element as the
     // load, so this dependence appears only at depth 2 (loop independent).
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}
-    %a1 = affine.apply (d0) -> (d0 - 1) (%c10)
+    %a1 = affine.apply affine_map<(d0) -> (d0 - 1)> (%c10)
     // For dependence from 1 to 0, we have write-after-read (WAR) dependences
     // for all loads in the loop to the store on the last iteration.
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 9]}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_range_load_before_range() {
 func @store_range_load_before_range() {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c0 = constant 0 : index
   affine.for %i0 = 1 to 11 {
-    %a0 = affine.apply (d0) -> (d0) (%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
-    %a1 = affine.apply (d0) -> (d0) (%c0)
+    %a1 = affine.apply affine_map<(d0) -> (d0)> (%c0)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_range_load_first_in_range() {
 func @store_range_load_first_in_range() {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   %c0 = constant 0 : index
   affine.for %i0 = 1 to 11 {
-    %a0 = affine.apply (d0) -> (d0) (%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     // Dependence from 0 to 1 at depth 1 is a range because all loads at
     // constant index zero are reads after first store at index zero during
     // first iteration of the loop.
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [1, 9]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}
-    %a1 = affine.apply (d0) -> (d0 + 1) (%c0)
+    %a1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%c0)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @store_plus_3() {
 func @store_plus_3() {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 1 to 11 {
-    %a0 = affine.apply (d0) -> (d0 + 3) (%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0 + 3)> (%i0)
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [3, 3]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
-    %a1 = affine.apply (d0) -> (d0) (%i0)
+    %a1 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @load_minus_2() {
 func @load_minus_2() {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 2 to 11 {
-    %a0 = affine.apply (d0) -> (d0) (%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     affine.store %c7, %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [2, 2]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
-    %a1 = affine.apply (d0) -> (d0 - 2) (%i0)
+    %a1 = affine.apply affine_map<(d0) -> (d0 - 2)> (%i0)
     %v0 = affine.load %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @perfectly_nested_loops_loop_independent() {
 func @perfectly_nested_loops_loop_independent() {
   %m = alloc() : memref<10x10xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to 11 {
     affine.for %i1 = 0 to 11 {
       // Dependence from access 0 to 1 is loop independent at depth = 3.
-      %a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
-      %a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
+      %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
+      %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 3 = true}}
-      %a10 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
-      %a11 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
+      %a10 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
+      %a11 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       %v0 = affine.load %m[%a10, %a11] : memref<10x10xf32>
       // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @perfectly_nested_loops_loop_carried_at_depth1() {
 func @perfectly_nested_loops_loop_carried_at_depth1() {
   %m = alloc() : memref<10x10xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to 9 {
     affine.for %i1 = 0 to 9 {
       // Dependence from access 0 to 1 is loop carried at depth 1.
-      %a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
-      %a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
+      %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
+      %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = [2, 2][0, 0]}}
       // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 3 = false}}
-      %a10 = affine.apply (d0, d1) -> (d0 - 2) (%i0, %i1)
-      %a11 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
+      %a10 = affine.apply affine_map<(d0, d1) -> (d0 - 2)> (%i0, %i1)
+      %a11 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       %v0 = affine.load %m[%a10, %a11] : memref<10x10xf32>
       // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @perfectly_nested_loops_loop_carried_at_depth2() {
 func @perfectly_nested_loops_loop_carried_at_depth2() {
   %m = alloc() : memref<10x10xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       // Dependence from access 0 to 1 is loop carried at depth 2.
-      %a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
-      %a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
+      %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
+      %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 2 = [0, 0][3, 3]}}
       // expected-remark@above {{dependence from 0 to 1 at depth 3 = false}}
-      %a10 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
-      %a11 = affine.apply (d0, d1) -> (d1 - 3) (%i0, %i1)
+      %a10 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
+      %a11 = affine.apply affine_map<(d0, d1) -> (d1 - 3)> (%i0, %i1)
       %v0 = affine.load %m[%a10, %a11] : memref<10x10xf32>
       // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @one_common_loop() {
 func @one_common_loop() {
   %m = alloc() : memref<10x10xf32>
   %c7 = constant 7.0 : f32
   // There is a loop-independent dependence from access 0 to 1 at depth 2.
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
-      %a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
-      %a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
+      %a00 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
+      %a01 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       affine.store %c7, %m[%a00, %a01] : memref<10x10xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 2 = true}}
     }
     affine.for %i2 = 0 to 9 {
-      %a10 = affine.apply (d0, d1) -> (d0) (%i0, %i2)
-      %a11 = affine.apply (d0, d1) -> (d1) (%i0, %i2)
+      %a10 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i2)
+      %a11 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i2)
       %v0 = affine.load %m[%a10, %a11] : memref<10x10xf32>
       // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @dependence_cycle() {
 func @dependence_cycle() {
   %m.a = alloc() : memref<100xf32>
   %m.b = alloc() : memref<100xf32>
 
   // Dependences:
   // *) loop-independent dependence from access 1 to 2 at depth 2.
   // *) loop-carried dependence from access 3 to 0 at depth 1.
   affine.for %i0 = 0 to 9 {
-    %a0 = affine.apply (d0) -> (d0) (%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     %v0 = affine.load %m.a[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 2 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 2 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 3 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 3 at depth 2 = false}}
-    %a1 = affine.apply (d0) -> (d0) (%i0)
+    %a1 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     affine.store %v0, %m.b[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 2 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 2 at depth 2 = true}}
     // expected-remark@above {{dependence from 1 to 3 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 3 at depth 2 = false}}
-    %a2 = affine.apply (d0) -> (d0) (%i0)
+    %a2 = affine.apply affine_map<(d0) -> (d0)> (%i0)
     %v1 = affine.load %m.b[%a2] : memref<100xf32>
     // expected-remark@above {{dependence from 2 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 2 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 2 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 2 to 1 at depth 2 = false}}
     // expected-remark@above {{dependence from 2 to 2 at depth 1 = false}}
     // expected-remark@above {{dependence from 2 to 2 at depth 2 = false}}
     // expected-remark@above {{dependence from 2 to 3 at depth 1 = false}}
     // expected-remark@above {{dependence from 2 to 3 at depth 2 = false}}
-    %a3 = affine.apply (d0) -> (d0 + 1) (%i0)
+    %a3 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0)
     affine.store %v1, %m.a[%a3] : memref<100xf32>
     // expected-remark@above {{dependence from 3 to 0 at depth 1 = [1, 1]}}
     // expected-remark@above {{dependence from 3 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 3 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 3 to 1 at depth 2 = false}}
     // expected-remark@above {{dependence from 3 to 2 at depth 1 = false}}
     // expected-remark@above {{dependence from 3 to 2 at depth 2 = false}}
     // expected-remark@above {{dependence from 3 to 3 at depth 1 = false}}
     // expected-remark@above {{dependence from 3 to 3 at depth 2 = false}}
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @negative_and_positive_direction_vectors(%arg0: index, %arg1: index) {
 func @negative_and_positive_direction_vectors(%arg0: index, %arg1: index) {
   %m = alloc() : memref<10x10xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to %arg0 {
     affine.for %i1 = 0 to %arg1 {
-      %a00 = affine.apply (d0, d1) -> (d0 - 1) (%i0, %i1)
-      %a01 = affine.apply (d0, d1) -> (d1 + 1) (%i0, %i1)
+      %a00 = affine.apply affine_map<(d0, d1) -> (d0 - 1)> (%i0, %i1)
+      %a01 = affine.apply affine_map<(d0, d1) -> (d1 + 1)> (%i0, %i1)
       %v0 = affine.load %m[%a00, %a01] : memref<10x10xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 3 = false}}
-      %a10 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
-      %a11 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
+      %a10 = affine.apply affine_map<(d0, d1) -> (d0)> (%i0, %i1)
+      %a11 = affine.apply affine_map<(d0, d1) -> (d1)> (%i0, %i1)
       affine.store %c7, %m[%a10, %a11] : memref<10x10xf32>
       // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 1][-1, -1]}}
       // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @war_raw_waw_deps() {
 func @war_raw_waw_deps() {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
-      %a0 = affine.apply (d0) -> (d0 + 1) (%i1)
+      %a0 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i1)
       %v0 = affine.load %m[%a0] : memref<100xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = [1, 9][1, 1]}}
       // expected-remark@above {{dependence from 0 to 1 at depth 2 = [0, 0][1, 1]}}
       // expected-remark@above {{dependence from 0 to 1 at depth 3 = false}}
-      %a1 = affine.apply (d0) -> (d0) (%i1)
+      %a1 = affine.apply affine_map<(d0) -> (d0)> (%i1)
       affine.store %c7, %m[%a1] : memref<100xf32>
       // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 9][-1, -1]}}
       // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 1 = [1, 9][0, 0]}}
       // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
 }
 
 // -----
 // CHECK-LABEL: func @mod_deps() {
 func @mod_deps() {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   affine.for %i0 = 0 to 10 {
-    %a0 = affine.apply (d0) -> (d0 mod 2) (%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0 mod 2)> (%i0)
     // Results are conservative here since we currently don't have a way to
     // represent strided sets in FlatAffineConstraints.
     %v0 = affine.load %m[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [1, 9]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
-    %a1 = affine.apply (d0) -> ( (d0 + 1) mod 2) (%i0)
+    %a1 = affine.apply affine_map<(d0) -> ( (d0 + 1) mod 2)> (%i0)
     affine.store %c7, %m[%a1] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 9]}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = [2, 9]}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
affine.for %i1 = 0 to 8 {
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = true}}
     }
   }
   affine.for %i2 = 0 to 8 {
     affine.for %i3 = 0 to 8 {
       affine.for %i4 = 0 to 8 {
         affine.for %i5 = 0 to 16 {
-          %8 = affine.apply (d0, d1) -> (d0 * 16 + d1)(%i4, %i5)
+          %8 = affine.apply affine_map<(d0, d1) -> (d0 * 16 + d1)>(%i4, %i5)
           %9 = affine.load %0[%8, %i3] : memref<100x100xf32>
           // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
           // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
           // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
           // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}
           // expected-remark@above {{dependence from 1 to 1 at depth 4 = false}}
           // expected-remark@above {{dependence from 1 to 1 at depth 5 = false}}
         }
       }
     }
   }
   return
 }
 
 // -----
 // Test case to exercise sanity when flattening multiple expressions involving
 // mod/div's successively.
 // CHECK-LABEL: func @mod_div_3d() {
 func @mod_div_3d() {
   %M = alloc() : memref<2x2x2xi32>
   %c0 = constant 0 : i32
   affine.for %i0 = 0 to 8 {
     affine.for %i1 = 0 to 8 {
       affine.for %i2 = 0 to 8 {
-        %idx0 = affine.apply (d0, d1, d2) -> (d0 floordiv 4) (%i0, %i1, %i2)
-        %idx1 = affine.apply (d0, d1, d2) -> (d1 mod 2) (%i0, %i1, %i2)
-        %idx2 = affine.apply (d0, d1, d2) -> (d2 floordiv 4) (%i0, %i1, %i2)
+        %idx0 = affine.apply affine_map<(d0, d1, d2) -> (d0 floordiv 4)> (%i0, %i1, %i2)
+        %idx1 = affine.apply affine_map<(d0, d1, d2) -> (d1 mod 2)> (%i0, %i1, %i2)
+        %idx2 = affine.apply affine_map<(d0, d1, d2) -> (d2 floordiv 4)> (%i0, %i1, %i2)
         affine.store %c0, %M[%idx0, %idx1, %idx2] : memref<2 x 2 x 2 x i32>
         // expected-remark@above {{dependence from 0 to 0 at depth 1 = [1, 3][-7, 7][-3, 3]}}
         // expected-remark@above {{dependence from 0 to 0 at depth 2 = [0, 0][2, 7][-3, 3]}}
         // expected-remark@above {{dependence from 0 to 0 at depth 3 = [0, 0][0, 0][1, 3]}}
         // expected-remark@above {{dependence from 0 to 0 at depth 4 = false}}
       }
     }
   }
// expected-remark@above {{dependence from 0 to 2 at depth 1 = false}}
           }
         }
       }
     }
   }
 
   affine.for %ii = 0 to 64 {
     affine.for %jj = 0 to 9 {
-      %a0 = affine.apply (d0, d1) -> (d0 * (9 * 1024) + d1 * 128) (%ii, %jj)
-      %a10 = affine.apply (d0) ->
-        (d0 floordiv (2 * 3 * 3 * 128 * 128)) (%a0)
-      %a11 = affine.apply (d0) ->
-        ((d0 mod 294912) floordiv (3 * 3 * 128 * 128)) (%a0)
-      %a12 = affine.apply (d0) ->
-        ((((d0 mod 294912) mod 147456) floordiv 1152) floordiv 8) (%a0)
-      %a13 = affine.apply (d0) ->
-        ((((d0 mod 294912) mod 147456) mod 1152) floordiv 384) (%a0)
-      %a14 = affine.apply (d0) ->
-        (((((d0 mod 294912) mod 147456) mod 1152) mod 384) floordiv 128) (%a0)
-      %a15 = affine.apply (d0) ->
+      %a0 = affine.apply affine_map<(d0, d1) -> (d0 * (9 * 1024) + d1 * 128)> (%ii, %jj)
+      %a10 = affine.apply affine_map<(d0) ->
+        (d0 floordiv (2 * 3 * 3 * 128 * 128))> (%a0)
+      %a11 = affine.apply affine_map<(d0) ->
+        ((d0 mod 294912) floordiv (3 * 3 * 128 * 128))> (%a0)
+      %a12 = affine.apply affine_map<(d0) ->
+        ((((d0 mod 294912) mod 147456) floordiv 1152) floordiv 8)> (%a0)
+      %a13 = affine.apply affine_map<(d0) ->
+        ((((d0 mod 294912) mod 147456) mod 1152) floordiv 384)> (%a0)
+      %a14 = affine.apply affine_map<(d0) ->
+        (((((d0 mod 294912) mod 147456) mod 1152) mod 384) floordiv 128)> (%a0)
+      %a15 = affine.apply affine_map<(d0) ->
         ((((((d0 mod 294912) mod 147456) mod 1152) mod 384) mod 128)
-          floordiv 128) (%a0)
+          floordiv 128)> (%a0)
       %v0 = affine.load %in[%a10, %a11, %a13, %a14, %a12, %a15] : memref<2x2x3x3x16x1xi32>
 // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
 // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
 // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
 // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}
 // expected-remark@above {{dependence from 1 to 2 at depth 1 = false}}
 // expected-remark@above {{dependence from 1 to 2 at depth 2 = false}}
 // expected-remark@above {{dependence from 1 to 2 at depth 3 = false}}

 // -----
 
 // Load and store ops access alternating memref elements: no dependence.
 // CHECK-LABEL: func @strided_loop_with_no_dependence
 func @strided_loop_with_no_dependence() {
   %0 = alloc() : memref<10xf32>
   %cf0 = constant 0.0 : f32
   affine.for %i0 = 0 to 8 step 2 {
-    %a0 = affine.apply (d0) -> (d0 + 1)(%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0 + 1)>(%i0)
     affine.store %cf0, %0[%a0] : memref<10xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     %v0 = affine.load %0[%i0] : memref<10xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 
 // Affine.Store op accesses memref elements at offset causing loop-carried dependence.
 // CHECK-LABEL: func @strided_loop_with_loop_carried_dependence_at_depth1
 func @strided_loop_with_loop_carried_dependence_at_depth1() {
   %0 = alloc() : memref<10xf32>
   %cf0 = constant 0.0 : f32
   affine.for %i0 = 0 to 8 step 2 {
-    %a0 = affine.apply (d0) -> (d0 + 4)(%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0 + 4)>(%i0)
     affine.store %cf0, %0[%a0] : memref<10xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = [4, 4]}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     %v0 = affine.load %0[%i0] : memref<10xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
 
 // -----
 
 // Test that the loop carried dependence from load to store on '%i0' is
 // properly computed when the load and store are at different loop depths.
 // CHECK-LABEL: func @test_dep_store_depth1_load_depth2
 func @test_dep_store_depth1_load_depth2() {
   %0 = alloc() : memref<100xf32>
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 10 {
-    %a0 = affine.apply (d0) -> (d0 - 1)(%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0 - 1)>(%i0)
     affine.store %cst, %0[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
-    affine.for %i1 = (d0) -> (d0)(%i0) to (d0) -> (d0 + 1)(%i0) {
+    affine.for %i1 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 1)>(%i0) {
       %1 = affine.load %0[%i1] : memref<100xf32>
       // expected-remark@above {{dependence from 1 to 0 at depth 1 = [1, 1]}}
       // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
       // expected-remark@above {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
 }
 
 // -----
 
 // Test that the loop carried dependence from store to load on '%i0' is
 // properly computed when the load and store are at different loop depths.
 // CHECK-LABEL: func @test_dep_store_depth2_load_depth1
 func @test_dep_store_depth2_load_depth1() {
   %0 = alloc() : memref<100xf32>
   %cst = constant 7.000000e+00 : f32
   affine.for %i0 = 0 to 10 {
-    affine.for %i1 = (d0) -> (d0)(%i0) to (d0) -> (d0 + 1)(%i0) {
+    affine.for %i1 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 1)>(%i0) {
       affine.store %cst, %0[%i1] : memref<100xf32>
       // expected-remark@above {{dependence from 0 to 0 at depth 1 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 2 = false}}
       // expected-remark@above {{dependence from 0 to 0 at depth 3 = false}}
       // expected-remark@above {{dependence from 0 to 1 at depth 1 = [2, 2]}}
       // expected-remark@above {{dependence from 0 to 1 at depth 2 = false}}
     }
-    %a0 = affine.apply (d0) -> (d0 - 2)(%i0)
+    %a0 = affine.apply affine_map<(d0) -> (d0 - 2)>(%i0)
     %1 = affine.load %0[%a0] : memref<100xf32>
     // expected-remark@above {{dependence from 1 to 0 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 0 at depth 2 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 1 = false}}
     // expected-remark@above {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }

mlir/test/Transforms/memref-normalize.mlir

 // RUN: mlir-opt -simplify-affine-structures %s | FileCheck %s
 
 // CHECK-LABEL: func @permute()
 func @permute() {
-  %A = alloc() : memref<64x256xf32, (d0, d1) -> (d1, d0)>
+  %A = alloc() : memref<64x256xf32, affine_map<(d0, d1) -> (d1, d0)>>
   affine.for %i = 0 to 64 {
     affine.for %j = 0 to 256 {
-      affine.load %A[%i, %j] : memref<64x256xf32, (d0, d1) -> (d1, d0)>
+      affine.load %A[%i, %j] : memref<64x256xf32, affine_map<(d0, d1) -> (d1, d0)>>
     }
   }
-  dealloc %A : memref<64x256xf32, (d0, d1) -> (d1, d0)>
+  dealloc %A : memref<64x256xf32, affine_map<(d0, d1) -> (d1, d0)>>
   return
 }
 // The old memref alloc should disappear.
 // CHECK-NOT:  memref<64x256xf32>
 // CHECK:      [[MEM:%[0-9]+]] = alloc() : memref<256x64xf32>
 // CHECK-NEXT: affine.for %[[I:arg[0-9]+]] = 0 to 64 {
 // CHECK-NEXT:   affine.for %[[J:arg[0-9]+]] = 0 to 256 {
 // CHECK-NEXT:     affine.load [[MEM]][%[[J]], %[[I]]] : memref<256x64xf32>
 // CHECK-NEXT:   }
 // CHECK-NEXT: }
 // CHECK-NEXT: dealloc [[MEM]]
 // CHECK-NEXT: return
 
 // CHECK-LABEL: func @shift
 func @shift(%idx : index) {
   // CHECK-NEXT: alloc() : memref<65xf32>
-  %A = alloc() : memref<64xf32, (d0) -> (d0 + 1)>
+  %A = alloc() : memref<64xf32, affine_map<(d0) -> (d0 + 1)>>
   // CHECK-NEXT: affine.load %{{.*}}[symbol(%arg0) + 1] : memref<65xf32>
-  affine.load %A[%idx] : memref<64xf32, (d0) -> (d0 + 1)>
+  affine.load %A[%idx] : memref<64xf32, affine_map<(d0) -> (d0 + 1)>>
   affine.for %i = 0 to 64 {
-    affine.load %A[%i] : memref<64xf32, (d0) -> (d0 + 1)>
+    affine.load %A[%i] : memref<64xf32, affine_map<(d0) -> (d0 + 1)>>
     // CHECK: %{{.*}} = affine.load %{{.*}}[%arg{{.*}} + 1] : memref<65xf32>
   }
   return
 }
 
 // CHECK-LABEL: func @high_dim_permute()
 func @high_dim_permute() {
   // CHECK-NOT: memref<64x128x256xf32,
-  %A = alloc() : memref<64x128x256xf32, (d0, d1, d2) -> (d2, d0, d1)>
+  %A = alloc() : memref<64x128x256xf32, affine_map<(d0, d1, d2) -> (d2, d0, d1)>>
   // CHECK: %[[I:arg[0-9]+]]
   affine.for %i = 0 to 64 {
     // CHECK: %[[J:arg[0-9]+]]
     affine.for %j = 0 to 128 {
       // CHECK: %[[K:arg[0-9]+]]
       affine.for %k = 0 to 256 {
-        affine.load %A[%i, %j, %k] : memref<64x128x256xf32, (d0, d1, d2) -> (d2, d0, d1)>
+        affine.load %A[%i, %j, %k] : memref<64x128x256xf32, affine_map<(d0, d1, d2) -> (d2, d0, d1)>>
         // CHECK: %{{.*}} = affine.load %{{.*}}[%[[K]], %[[I]], %[[J]]] : memref<256x64x128xf32>
       }
     }
   }
   return
 }
 
 // CHECK-LABEL: func @invalid_map
 func @invalid_map() {
-  %A = alloc() : memref<64x128xf32, (d0, d1) -> (d0, -d1 - 10)>
+  %A = alloc() : memref<64x128xf32, affine_map<(d0, d1) -> (d0, -d1 - 10)>>
   // CHECK: %{{.*}} = alloc() : memref<64x128xf32,
   return
 }
 
 // A tiled layout.
 // CHECK-LABEL: func @data_tiling
 func @data_tiling(%idx : index) {
   // CHECK: alloc() : memref<8x32x8x16xf32>
-  %A = alloc() : memref<64x512xf32, (d0, d1) -> (d0 floordiv 8, d1 floordiv 16, d0 mod 8, d1 mod 16)>
+  %A = alloc() : memref<64x512xf32, affine_map<(d0, d1) -> (d0 floordiv 8, d1 floordiv 16, d0 mod 8, d1 mod 16)>>
   // CHECK: affine.load %{{.*}}[symbol(%arg0) floordiv 8, symbol(%arg0) floordiv 16, symbol(%arg0) mod 8, symbol(%arg0) mod 16]
-  affine.load %A[%idx, %idx] : memref<64x512xf32, (d0, d1) -> (d0 floordiv 8, d1 floordiv 16, d0 mod 8, d1 mod 16)>
+  affine.load %A[%idx, %idx] : memref<64x512xf32, affine_map<(d0, d1) -> (d0 floordiv 8, d1 floordiv 16, d0 mod 8, d1 mod 16)>>
   return
 }
 
 // Strides 2 and 4 along respective dimensions.
 // CHECK-LABEL: func @strided
 func @strided() {
-  %A = alloc() : memref<64x128xf32, (d0, d1) -> (2*d0, 4*d1)>
+  %A = alloc() : memref<64x128xf32, affine_map<(d0, d1) -> (2*d0, 4*d1)>>
   // CHECK: affine.for %[[IV0:.*]] =
   affine.for %i = 0 to 64 {
     // CHECK: affine.for %[[IV1:.*]] =
     affine.for %j = 0 to 128 {
       // CHECK: affine.load %{{.*}}[%[[IV0]] * 2, %[[IV1]] * 4] : memref<127x509xf32>
-      affine.load %A[%i, %j] : memref<64x128xf32, (d0, d1) -> (2*d0, 4*d1)>
+      affine.load %A[%i, %j] : memref<64x128xf32, affine_map<(d0, d1) -> (2*d0, 4*d1)>>
     }
   }
   return
 }
 
 // Strided, but the strides are in the linearized space.
 // CHECK-LABEL: func @strided_cumulative
 func @strided_cumulative() {
-  %A = alloc() : memref<2x5xf32, (d0, d1) -> (3*d0 + 17*d1)>
+  %A = alloc() : memref<2x5xf32, affine_map<(d0, d1) -> (3*d0 + 17*d1)>>
   // CHECK: affine.for %[[IV0:.*]] =
   affine.for %i = 0 to 2 {
     // CHECK: affine.for %[[IV1:.*]] =
     affine.for %j = 0 to 5 {
       // CHECK: affine.load %{{.*}}[%[[IV0]] * 3 + %[[IV1]] * 17] : memref<72xf32>
-      affine.load %A[%i, %j]  : memref<2x5xf32, (d0, d1) -> (3*d0 + 17*d1)>
+      affine.load %A[%i, %j]  : memref<2x5xf32, affine_map<(d0, d1) -> (3*d0 + 17*d1)>>
     }
   }
   return
 }
 
 // Symbolic operand for alloc, although unused. Tests replaceAllMemRefUsesWith
 // when the index remap has symbols.
 // CHECK-LABEL: func @symbolic_operands
 func @symbolic_operands(%s : index) {
   // CHECK: alloc() : memref<100xf32>
-  %A = alloc()[%s] : memref<10x10xf32, (d0,d1)[s0] -> (10*d0 + d1)>
+  %A = alloc()[%s] : memref<10x10xf32, affine_map<(d0,d1)[s0] -> (10*d0 + d1)>>
   affine.for %i = 0 to 10 {
     affine.for %j = 0 to 10 {
       // CHECK: affine.load %{{.*}}[%{{.*}} * 10 + %{{.*}}] : memref<100xf32>
-      affine.load %A[%i, %j] : memref<10x10xf32, (d0,d1)[s0] -> (10*d0 + d1)>
+      affine.load %A[%i, %j] : memref<10x10xf32, affine_map<(d0,d1)[s0] -> (10*d0 + d1)>>
     }
   }
   return
 }
 
 // Memref escapes; no normalization.
 // CHECK-LABEL: func @escaping() -> memref<64xf32, #map{{[0-9]+}}>
-func @escaping() ->  memref<64xf32, (d0) -> (d0 + 2)> {
+func @escaping() ->  memref<64xf32, affine_map<(d0) -> (d0 + 2)>> {
   // CHECK: %{{.*}} = alloc() : memref<64xf32, #map{{[0-9]+}}>
-  %A = alloc() : memref<64xf32, (d0) -> (d0 + 2)>
-  return %A : memref<64xf32, (d0) -> (d0 + 2)>
+  %A = alloc() : memref<64xf32, affine_map<(d0) -> (d0 + 2)>>
+  return %A : memref<64xf32, affine_map<(d0) -> (d0 + 2)>>
 }
 
 // Semi-affine maps, normalization not implemented yet.
 // CHECK-LABEL: func @semi_affine_layout_map
 func @semi_affine_layout_map(%s0: index, %s1: index) {
-  %A = alloc()[%s0, %s1] : memref<256x1024xf32, (d0, d1)[s0, s1] -> (d0*s0 + d1*s1)>
+  %A = alloc()[%s0, %s1] : memref<256x1024xf32, affine_map<(d0, d1)[s0, s1] -> (d0*s0 + d1*s1)>>
   affine.for %i = 0 to 256 {
     affine.for %j = 0 to 1024 {
       // CHECK: memref<256x1024xf32, #map{{[0-9]+}}>
-      affine.load %A[%i, %j] : memref<256x1024xf32, (d0, d1)[s0, s1] -> (d0*s0 + d1*s1)>
+      affine.load %A[%i, %j] : memref<256x1024xf32, affine_map<(d0, d1)[s0, s1] -> (d0*s0 + d1*s1)>>
     }
   }
   return
 }

mlir/test/Transforms/pipeline-data-transfer.mlir

 // RUN: mlir-opt %s -split-input-file -affine-pipeline-data-transfer | FileCheck %s
 
 // -----
 
-// CHECK-DAG: [[MOD_2:#map[0-9]+]] = (d0) -> (d0 mod 2)
-// CHECK-DAG: [[MAP_MINUS_1:#map[0-9]+]] = (d0) -> (d0 - 1)
+// CHECK-DAG: [[MOD_2:#map[0-9]+]] = affine_map<(d0) -> (d0 mod 2)>
+// CHECK-DAG: [[MAP_MINUS_1:#map[0-9]+]] = affine_map<(d0) -> (d0 - 1)>
 
 // CHECK-LABEL: func @loop_nest_dma() {
 func @loop_nest_dma() {
 
-  %A = alloc() : memref<256 x f32, (d0) -> (d0), 0>
-  %Ah = alloc() : memref<32 x f32, (d0) -> (d0), 1>
+  %A = alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
+  %Ah = alloc() : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
 
   %tag = alloc() : memref<1 x f32>
 
   %zero = constant 0 : index
   %num_elts = constant 32 : index
 
   affine.for %i = 0 to 8 {
     affine.dma_start %A[%i], %Ah[%i], %tag[%zero], %num_elts : memref<256 x f32>, memref<32 x f32, 1>, memref<1 x f32>
     affine.dma_wait %tag[%zero], %num_elts : memref<1 x f32>
-    %v = affine.load %Ah[%i] : memref<32 x f32, (d0) -> (d0), 1>
+    %v = affine.load %Ah[%i] : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
     %r = "compute"(%v) : (f32) -> (f32)
-    affine.store %r, %Ah[%i] : memref<32 x f32, (d0) -> (d0), 1>
+    affine.store %r, %Ah[%i] : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
     affine.for %j = 0 to 32 {
       "do_more_compute"(%i, %j) : (index, index) -> ()
     }
   }
   dealloc %tag : memref<1 x f32>
-  dealloc %Ah : memref<32 x f32, (d0) -> (d0), 1>
+  dealloc %Ah : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
   return
 }
 // CHECK:       %{{.*}} = alloc() : memref<256xf32>
 // CHECK:       %{{.*}} = alloc() : memref<2x32xf32, 1>
 // CHECK-NEXT:  %{{.*}} = alloc() : memref<2x1xf32>
 // CHECK-NEXT:  affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}} mod 2, %{{.*}}], %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>
 // CHECK-NEXT:  affine.for %{{.*}} = 1 to 8 {
 // CHECK-NEXT:    affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}} mod 2, %{{.*}}], %{{.*}}[%{{.*}} mod 2, 0], %{{.*}} : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>

 // CHECK-NEXT:  }
 // CHECK-NEXT:  dealloc %{{.*}} : memref<2x1xf32>
 // CHECK-NEXT:  dealloc %{{.*}} : memref<2x32xf32, 1>
 // CHECK-NEXT:  return
 // CHECK-NEXT:}
 
 // -----
 
-// CHECK-DAG: [[FLOOR_MOD_2:#map[0-9]+]] = (d0) -> ((d0 floordiv 4) mod 2)
-// CHECK-DAG: [[REMAP_SHIFT_MINUS_4:#map[0-9]+]] = (d0) -> (d0 - 4)
+// CHECK-DAG: [[FLOOR_MOD_2:#map[0-9]+]] = affine_map<(d0) -> ((d0 floordiv 4) mod 2)>
+// CHECK-DAG: [[REMAP_SHIFT_MINUS_4:#map[0-9]+]] = affine_map<(d0) -> (d0 - 4)>
 
 // CHECK-LABEL: @loop_step
 func @loop_step(%arg0: memref<512xf32>,
                   %arg1: memref<512xf32>) {
   %c0 = constant 0 : index
   %c4 = constant 4 : index
   affine.for %i0 = 0 to 512 step 4 {
     %1 = alloc() : memref<4xf32, 1>

 // CHECK-NEXT:   "compute"(%{{.*}}) : (index) -> ()
 // CHECK-NEXT:   dealloc [[TAG]] : memref<2x1xi32>
 // CHECK-NEXT:   dealloc [[BUF]] : memref<2x4xf32, 1>
 // CHECK-NEXT:   return
 // CHECK-NEXT: }
 
 // -----
 
-#map1 = (d0, d1) -> ((d0 * 2048 + d1 * 256) floordiv 32)
-#map2 = (d0) -> ((d0 * 2048) floordiv 32)
+#map1 = affine_map<(d0, d1) -> ((d0 * 2048 + d1 * 256) floordiv 32)>
+#map2 = affine_map<(d0) -> ((d0 * 2048) floordiv 32)>
 // CHECK-LABEL: func @loop_dma_nested(%{{.*}}: memref<512x32xvector<8xf32>
 func @loop_dma_nested(%arg0: memref<512x32xvector<8xf32>>, %arg1: memref<512x32xvector<8xf32>>, %arg2: memref<512x32xvector<8xf32>>) {
   %num_elts = constant 256 : index
   %c0 = constant 0 : index
   %0 = alloc() : memref<64x4xvector<8xf32>, 2>
   %1 = alloc() : memref<64x4xvector<8xf32>, 2>
   %2 = alloc() : memref<64x4xvector<8xf32>, 2>
   %3 = alloc() : memref<2xi32>

 // CHECK-DAG:  dealloc [[BUF_ARG1_NESTED]] : memref<2x64x4xvector<8xf32>, 2>
 // CHECK-DAG:  dealloc [[BUF_ARG0_NESTED]] : memref<2x64x4xvector<8xf32>, 2>
 // CHECK-DAG:  dealloc [[TAG_ARG2]] : memref<2x2xi32>
 // CHECK-DAG:  dealloc [[BUF_ARG2]] : memref<2x64x4xvector<8xf32>, 2>
 // CHECK-NEXT: return
 }
 
 // -----
-#map2 = (d0) -> ((d0 * 2048) floordiv 32)
+#map2 = affine_map<(d0) -> ((d0 * 2048) floordiv 32)>
 
 // CHECK: func @loop_dma_dependent
 func @loop_dma_dependent(%arg2: memref<512x32xvector<8xf32>>) {
   %num_elts = constant 256 : index
   %c0 = constant 0 : index
   %0 = alloc() : memref<64x4xvector<8xf32>, 2>
   %1 = alloc() : memref<64x4xvector<8xf32>, 2>
   %2 = alloc() : memref<64x4xvector<8xf32>, 2>

 }
 
 // Memref replacement will fail here due to a non-dereferencing use. However,
 // no incorrect transformation is performed in spite of one of the uses being a
 // dereferencing one since replaceAllMemRefUsesWith checks for escaping uses
 // before performing any replacement.
 // CHECK-LABEL: func @escaping_and_indexed_use_mix
 func @escaping_and_indexed_use_mix() {
-  %A = alloc() : memref<256 x f32, (d0) -> (d0), 0>
-  %Ah = alloc() : memref<32 x f32, (d0) -> (d0), 1>
+  %A = alloc() : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
+  %Ah = alloc() : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
   %tag = alloc() : memref<1 x f32>
   %zero = constant 0 : index
   %num_elts = constant 32 : index
 
   // alloc for the buffer is created but no replacement should happen.
   affine.for %i = 0 to 8 {
     affine.dma_start %A[%i], %Ah[%i], %tag[%zero], %num_elts : memref<256 x f32>, memref<32 x f32, 1>, memref<1 x f32>
     affine.dma_wait %tag[%zero], %num_elts : memref<1 x f32>
     "compute"(%Ah) : (memref<32 x f32, 1>) -> ()
-    %v = affine.load %Ah[%i] : memref<32 x f32, (d0) -> (d0), 1>
+    %v = affine.load %Ah[%i] : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
     "foo"(%v) : (f32) -> ()
   }
-  dealloc %A : memref<256 x f32, (d0) -> (d0), 0>
-  dealloc %Ah : memref<32 x f32, (d0) -> (d0), 1>
+  dealloc %A : memref<256 x f32, affine_map<(d0) -> (d0)>, 0>
+  dealloc %Ah : memref<32 x f32, affine_map<(d0) -> (d0)>, 1>
   return
 }
 // No replacement.
 // CHECK: affine.for %{{.*}} = 0 to 8 {
 // CHECK-NEXT:   affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}
 // CHECK-NEXT:   affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xf32>
 // CHECK-NEXT:   "compute"(%{{.*}}) : (memref<32xf32, 1>) -> ()
 // CHECK-NEXT:   [[VAL:%[0-9]+]] = affine.load %{{.*}}[%{{.*}}] : memref<32xf32, 1>
 // CHECK-NEXT:   "foo"([[VAL]]) : (f32) -> ()

mlir/test/Transforms/simplify-affine-structures.mlir

 // RUN: mlir-opt %s -simplify-affine-structures | FileCheck %s
 
-// CHECK-DAG: [[SET_EMPTY_2D:#set[0-9]+]] = (d0, d1) : (1 == 0)
-// CHECK-DAG: #set1 = (d0, d1) : (d0 - 100 == 0, d1 - 10 == 0, -d0 + 100 >= 0, d1 >= 0, d1 + 101 >= 0)
-// CHECK-DAG: #set2 = (d0, d1)[s0, s1] : (1 == 0)
-// CHECK-DAG: #set3 = (d0, d1)[s0, s1] : (d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0, d0 * 5 - d1 * 11 + s0 * 7 + s1 == 0, d0 * 11 + d1 * 7 - s0 * 5 + s1 == 0, d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0)
-// CHECK-DAG: [[SET_EMPTY_1D:#set[0-9]+]] = (d0) : (1 == 0)
-// CHECK-DAG: [[SET_EMPTY_1D_2S:#set[0-9]+]] = (d0)[s0, s1] : (1 == 0)
-// CHECK-DAG: [[SET_EMPTY_3D:#set[0-9]+]] = (d0, d1, d2) : (1 == 0)
+// CHECK-DAG: [[SET_EMPTY_2D:#set[0-9]+]] = affine_set<(d0, d1) : (1 == 0)>
+// CHECK-DAG: #set1 = affine_set<(d0, d1) : (d0 - 100 == 0, d1 - 10 == 0, -d0 + 100 >= 0, d1 >= 0, d1 + 101 >= 0)>
+// CHECK-DAG: #set2 = affine_set<(d0, d1)[s0, s1] : (1 == 0)>
+// CHECK-DAG: #set3 = affine_set<(d0, d1)[s0, s1] : (d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0, d0 * 5 - d1 * 11 + s0 * 7 + s1 == 0, d0 * 11 + d1 * 7 - s0 * 5 + s1 == 0, d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0)>
+// CHECK-DAG: [[SET_EMPTY_1D:#set[0-9]+]] = affine_set<(d0) : (1 == 0)>
+// CHECK-DAG: [[SET_EMPTY_1D_2S:#set[0-9]+]] = affine_set<(d0)[s0, s1] : (1 == 0)>
+// CHECK-DAG: [[SET_EMPTY_3D:#set[0-9]+]] = affine_set<(d0, d1, d2) : (1 == 0)>
 
 // Set for test case: test_gaussian_elimination_non_empty_set2
-// #set2 = (d0, d1) : (d0 - 100 == 0, d1 - 10 == 0, -d0 + 100 >= 0, d1 >= 0, d1 + 101 >= 0)
-#set2 = (d0, d1) : (d0 - 100 == 0, d1 - 10 == 0, -d0 + 100 >= 0, d1 >= 0, d1 + 101 >= 0)
+// #set2 = affine_set<(d0, d1) : (d0 - 100 == 0, d1 - 10 == 0, -d0 + 100 >= 0, d1 >= 0, d1 + 101 >= 0)>
+#set2 = affine_set<(d0, d1) : (d0 - 100 == 0, d1 - 10 == 0, -d0 + 100 >= 0, d1 >= 0, d1 + 101 >= 0)>
 
 // Set for test case: test_gaussian_elimination_empty_set3
-// #set3 = (d0, d1)[s0, s1] : (1 == 0)
-#set3 = (d0, d1)[s0, s1] : (d0 - s0 == 0, d0 + s0 == 0, s0 - 1 == 0)
+// #set3 = affine_set<(d0, d1)[s0, s1] : (1 == 0)>
+#set3 = affine_set<(d0, d1)[s0, s1] : (d0 - s0 == 0, d0 + s0 == 0, s0 - 1 == 0)>
 
 // Set for test case: test_gaussian_elimination_non_empty_set4
-#set4 = (d0, d1)[s0, s1] : (d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0,
+#set4 = affine_set<(d0, d1)[s0, s1] : (d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0,
                                        d0 * 5 - d1 * 11 + s0 * 7 + s1 == 0,
                                        d0 * 11 + d1 * 7 - s0 * 5 + s1 == 0,
-                            d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0)
+                                       d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0)>
 
 // Add invalid constraints to previous non-empty set to make it empty.
 // Set for test case: test_gaussian_elimination_empty_set5
-#set5 = (d0, d1)[s0, s1] : (d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0,
+#set5 = affine_set<(d0, d1)[s0, s1] : (d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0,
                                        d0 * 5 - d1 * 11 + s0 * 7 + s1 == 0,
                                        d0 * 11 + d1 * 7 - s0 * 5 + s1 == 0,
                                        d0 * 7 + d1 * 5 + s0 * 11 + s1 == 0,
-                             d0 - 1 == 0, d0 + 2 == 0)
+                                       d0 - 1 == 0, d0 + 2 == 0)>
 
 // This is an artificially created system to exercise the worst case behavior of
 // FM elimination - as a safeguard against improperly constructed constraint
 // systems or fuzz input.
-#set_fuzz_virus = (d0, d1, d2, d3, d4, d5) : ( 1089234*d0 + 203472*d1 + 82342 >= 0,
+#set_fuzz_virus = affine_set<(d0, d1, d2, d3, d4, d5) : (
+                            1089234*d0 + 203472*d1 + 82342 >= 0,
                             -55*d0 + 24*d1 + 238*d2 - 234*d3 - 9743 >= 0,
                             -5445*d0 - 284*d1 + 23*d2 + 34*d3 - 5943 >= 0,
                             -5445*d0 + 284*d1 + 238*d2 - 34*d3 >= 0,
                             445*d0 + 284*d1 + 238*d2 + 39*d3 >= 0,
                             -545*d0 + 214*d1 + 218*d2 - 94*d3 >= 0,
                             44*d0 - 184*d1 - 231*d2 + 14*d3 >= 0,
                             -45*d0 + 284*d1 + 138*d2 - 39*d3 >= 0,
                             154*d0 - 84*d1 + 238*d2 - 34*d3 >= 0,
#set_fuzz_virus = affine_set<(d0, d1, d2, d3, d4, d5) : (
                             -947*d0 - 953*d2 + 234 >= 0,
                             184*d0 - 884*d2 + 884 >= 0,
                             -174*d0 + 834*d2 + 234 >= 0,
                             844*d0 + 634*d2 + 9874 >= 0,
                             -797*d2 - 79*d3 + 257 >= 0,
                             2039*d0 + 793*d2 - 99*d3 - 24*d4 + 234*d5 >= 0,
                             78*d2 - 788*d5 + 257 >= 0,
                             d3 - (d5 + 97*d0) floordiv 423 >= 0,
-                            234* (d0 + d3 mod 5 floordiv 2342) mod 2309 
+                            234* (d0 + d3 mod 5 floordiv 2342) mod 2309
                             + (d0 + 2038*d3) floordiv 208 >= 0,
-                            239* (d0 + 2300 * d3) floordiv 2342 
+                            239* (d0 + 2300 * d3) floordiv 2342
                             mod 2309 mod 239423 == 0,
-                            d0 + d3 mod 2642 + (d3 + 2*d0) mod 1247 
+                            d0 + d3 mod 2642 + (d3 + 2*d0) mod 1247
                             mod 2038 mod 2390 mod 2039 floordiv 55 >= 0
-)
+)>
 
 // CHECK-LABEL: func @test_gaussian_elimination_empty_set0() {
 func @test_gaussian_elimination_empty_set0() {
   affine.for %arg0 = 1 to 10 {
     affine.for %arg1 = 1 to 100 {
       // CHECK: [[SET_EMPTY_2D]](%arg0, %arg1)
-      affine.if (d0, d1) : (2 == 0)(%arg0, %arg1) {
+      affine.if affine_set<(d0, d1) : (2 == 0)>(%arg0, %arg1) {
       }
     }
   }
   return
 }
 
 // CHECK-LABEL: func @test_gaussian_elimination_empty_set1() {
 func @test_gaussian_elimination_empty_set1() {
   affine.for %arg0 = 1 to 10 {
     affine.for %arg1 = 1 to 100 {
       // CHECK: [[SET_EMPTY_2D]](%arg0, %arg1)
-      affine.if (d0, d1) : (1 >= 0, -1 >= 0) (%arg0, %arg1) {
+      affine.if affine_set<(d0, d1) : (1 >= 0, -1 >= 0)> (%arg0, %arg1) {
       }
     }
   }
   return
 }
 
 // CHECK-LABEL: func @test_gaussian_elimination_non_empty_set2() {
 func @test_gaussian_elimination_non_empty_set2() {

 }
 
 
 // CHECK-LABEL: func @test_empty_set(%arg0: index) {
 func @test_empty_set(%N : index) {
   affine.for %i = 0 to 10 {
     affine.for %j = 0 to 10 {
       // CHECK: affine.if [[SET_EMPTY_2D]](%arg1, %arg2)
-      affine.if (d0, d1) : (d0 - d1 >= 0, d1 - d0 - 1 >= 0)(%i, %j) {
+      affine.if affine_set<(d0, d1) : (d0 - d1 >= 0, d1 - d0 - 1 >= 0)>(%i, %j) {
         "foo"() : () -> ()
       }
       // CHECK: affine.if [[SET_EMPTY_1D]](%arg1)
-      affine.if (d0) : (d0 >= 0, -d0 - 1 >= 0)(%i) {
+      affine.if affine_set<(d0) : (d0 >= 0, -d0 - 1 >= 0)>(%i) {
         "bar"() : () -> ()
       }
       // CHECK: affine.if [[SET_EMPTY_1D]](%arg1)
-      affine.if (d0) : (d0 >= 0, -d0 - 1 >= 0)(%i) {
+      affine.if affine_set<(d0) : (d0 >= 0, -d0 - 1 >= 0)>(%i) {
         "foo"() : () -> ()
       }
       // CHECK: affine.if [[SET_EMPTY_1D_2S]](%arg1)[%arg0, %arg0]
-      affine.if (d0)[s0, s1] : (d0 >= 0, -d0 + s0 - 1 >= 0, -s0 >= 0)(%i)[%N, %N] {
+      affine.if affine_set<(d0)[s0, s1] : (d0 >= 0, -d0 + s0 - 1 >= 0, -s0 >= 0)>(%i)[%N, %N] {
         "bar"() : () -> ()
       }
       // CHECK: affine.if [[SET_EMPTY_3D]](%arg1, %arg2, %arg0)
       // The set below implies d0 = d1; so d1 >= d0, but d0 >= d1 + 1.
-      affine.if (d0, d1, d2) : (d0 - d1 == 0, d2 - d0 >= 0, d0 - d1 - 1 >= 0)(%i, %j, %N) {
+      affine.if affine_set<(d0, d1, d2) : (d0 - d1 == 0, d2 - d0 >= 0, d0 - d1 - 1 >= 0)>(%i, %j, %N) {
         "foo"() : () -> ()
       }
       // CHECK: affine.if [[SET_EMPTY_2D]](%arg1, %arg2)
       // The set below has rational solutions but no integer solutions; GCD test catches it.
-      affine.if (d0, d1) : (d0*2 -d1*2 - 1 == 0, d0 >= 0, -d0 + 100 >= 0, d1 >= 0, -d1 + 100 >= 0)(%i, %j) {
+      affine.if affine_set<(d0, d1) : (d0*2 -d1*2 - 1 == 0, d0 >= 0, -d0 + 100 >= 0, d1 >= 0, -d1 + 100 >= 0)>(%i, %j) {
         "foo"() : () -> ()
       }
       // CHECK: affine.if [[SET_EMPTY_2D]](%arg1, %arg2)
-      affine.if (d0, d1) : (d1 == 0, d0 - 1 >= 0, - d0 - 1 >= 0)(%i, %j) {
+      affine.if affine_set<(d0, d1) : (d1 == 0, d0 - 1 >= 0, - d0 - 1 >= 0)>(%i, %j) {
         "foo"() : () -> ()
       }
     }
   }
   // The tests below test GCDTightenInequalities().
   affine.for %k = 0 to 10 {
     affine.for %l = 0 to 10 {
       // Empty because no multiple of 8 lies between 4 and 7.
       // CHECK: affine.if [[SET_EMPTY_1D]](%arg1)
-      affine.if (d0) : (8*d0 - 4 >= 0, -8*d0 + 7 >= 0)(%k) {
+      affine.if affine_set<(d0) : (8*d0 - 4 >= 0, -8*d0 + 7 >= 0)>(%k) {
         "foo"() : () -> ()
       }
       // Same as above but with equalities and inequalities.
       // CHECK: affine.if [[SET_EMPTY_2D]](%arg1, %arg2)
-      affine.if (d0, d1) : (d0 - 4*d1 == 0, 4*d1 - 5 >= 0, -4*d1 + 7 >= 0)(%k, %l) {
+      affine.if affine_set<(d0, d1) : (d0 - 4*d1 == 0, 4*d1 - 5 >= 0, -4*d1 + 7 >= 0)>(%k, %l) {
         "foo"() : () -> ()
       }
       // Same as above but with a combination of multiple identifiers. 4*d0 +
       // 8*d1 here is a multiple of 4, and so can't lie between 9 and 11. GCD
       // tightening will tighten constraints to 4*d0 + 8*d1 >= 12 and 4*d0 +
       // 8*d1 <= 8; hence infeasible.
       // CHECK: affine.if [[SET_EMPTY_2D]](%arg1, %arg2)
-      affine.if (d0, d1) : (4*d0 + 8*d1 - 9 >= 0, -4*d0 - 8*d1 + 11 >=  0)(%k, %l) {
+      affine.if affine_set<(d0, d1) : (4*d0 + 8*d1 - 9 >= 0, -4*d0 - 8*d1 + 11 >= 0)>(%k, %l) {
         "foo"() : () -> ()
       }
       // Same as above but with equalities added into the mix.
       // CHECK: affine.if [[SET_EMPTY_3D]](%arg1, %arg1, %arg2)
-      affine.if (d0, d1, d2) : (d0 - 4*d2 == 0, d0 + 8*d1 - 9 >= 0, -d0 - 8*d1 + 11 >=  0)(%k, %k, %l) {
+      affine.if affine_set<(d0, d1, d2) : (d0 - 4*d2 == 0, d0 + 8*d1 - 9 >= 0, -d0 - 8*d1 + 11 >= 0)>(%k, %k, %l) {
         "foo"() : () -> ()
       }
     }
   }
 
   affine.for %m = 0 to 10 {
     // CHECK: affine.if [[SET_EMPTY_1D]](%arg{{[0-9]+}})
-    affine.if (d0) : (d0 mod 2 - 3 == 0) (%m) {
+    affine.if affine_set<(d0) : (d0 mod 2 - 3 == 0)> (%m) {
       "foo"() : () -> ()
     }
   }
 
   return
 }

mlir/test/Transforms/slicing-utils.mlir

 // FWD-LABEL: slicing_test_2
 // BWD-LABEL: slicing_test_2
 // FWDBWD-LABEL: slicing_test_2
 func @slicing_test_2() {
   %c0 = constant 0 : index
   %c2 = constant 2 : index
   %c16 = constant 16 : index
   affine.for %i0 = %c0 to %c16 {
-    affine.for %i1 = (i)[] -> (i)(%i0) to 10 {
+    affine.for %i1 = affine_map<(i)[] -> (i)>(%i0) to 10 {
       // BWD: matched: %[[b:.*]] {{.*}} backward static slice:
       // BWD: affine.for {{.*}}
 
       // affine.for appears in the body of loop.for
       // BWD: affine.for {{.*}}
 
       // affine.for appears as a proper op in the backward slice
       // BWD: affine.for {{.*}}

mlir/test/Transforms/strip-debuginfo.mlir

 // RUN: mlir-opt %s -mlir-print-debuginfo -strip-debuginfo | FileCheck %s
 // This test verifies that debug locations are stripped.
 
-#set0 = (d0) : (1 == 0)
+#set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK-LABEL: func @inline_notation
 func @inline_notation() -> i32 {
   // CHECK: "foo"() : () -> i32 loc(unknown)
   %1 = "foo"() : () -> i32 loc("foo")
 
   // CHECK: } loc(unknown)
   affine.for %i0 = 0 to 8 {

mlir/test/Transforms/unroll-jam.mlir

 // RUN: mlir-opt %s -affine-loop-unroll-jam -unroll-jam-factor=2 | FileCheck %s
 // RUN: mlir-opt %s -affine-loop-unroll-jam -unroll-jam-factor=4 | FileCheck --check-prefix=UJAM-FOUR %s
 
-// CHECK-DAG: [[MAP_PLUS_1:#map[0-9]+]] = (d0) -> (d0 + 1)
-// CHECK-DAG: [[MAP_DIV_OFFSET:#map[0-9]+]] = ()[s0] -> (((s0 - 1) floordiv 2) * 2 + 1)
-// CHECK-DAG: [[MAP_MULTI_RES:#map[0-9]+]] = ()[s0, s1] -> ((s0 floordiv 2) * 2, (s1 floordiv 2) * 2, 1024)
-// CHECK-DAG: [[MAP_SYM_UB:#map[0-9]+]] = ()[s0, s1] -> (s0, s1, 1024)
-
-// UJAM-FOUR-DAG: [[UBMAP:#map[0-9]+]] = ()[s0] -> (s0 + 8)
-// UJAM-FOUR-DAG: [[MAP_PLUS_1:#map[0-9]+]] = (d0) -> (d0 + 1)
-// UJAM-FOUR-DAG: [[MAP_PLUS_2:#map[0-9]+]] = (d0) -> (d0 + 2)
-// UJAM-FOUR-DAG: [[MAP_PLUS_3:#map[0-9]+]] = (d0) -> (d0 + 3)
+// CHECK-DAG: [[MAP_PLUS_1:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
+// CHECK-DAG: [[MAP_DIV_OFFSET:#map[0-9]+]] = affine_map<()[s0] -> (((s0 - 1) floordiv 2) * 2 + 1)>
+// CHECK-DAG: [[MAP_MULTI_RES:#map[0-9]+]] = affine_map<()[s0, s1] -> ((s0 floordiv 2) * 2, (s1 floordiv 2) * 2, 1024)>
+// CHECK-DAG: [[MAP_SYM_UB:#map[0-9]+]] = affine_map<()[s0, s1] -> (s0, s1, 1024)>
+
+// UJAM-FOUR-DAG: [[UBMAP:#map[0-9]+]] = affine_map<()[s0] -> (s0 + 8)>
+// UJAM-FOUR-DAG: [[MAP_PLUS_1:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
+// UJAM-FOUR-DAG: [[MAP_PLUS_2:#map[0-9]+]] = affine_map<(d0) -> (d0 + 2)>
+// UJAM-FOUR-DAG: [[MAP_PLUS_3:#map[0-9]+]] = affine_map<(d0) -> (d0 + 3)>
 
 // CHECK-LABEL: func @unroll_jam_imperfect_nest() {
 func @unroll_jam_imperfect_nest() {
   affine.for %i = 0 to 101 {
     %x = "addi32"(%i, %i) : (index, index) -> i32
     affine.for %j = 0 to 17 {
       %y = "addi32"(%i, %i) : (index, index) -> i32
       %z = "addi32"(%y, %y) : (i32, i32) -> i32
func @loop_nest_unknown_count_2(%N : index) {
   // UJAM-FOUR-NEXT:     "foo"([[IV_PLUS_3]])
   // UJAM-FOUR-NEXT:   }
   // UJAM-FOUR-NEXT: }
   // The cleanup loop is a single iteration one and is promoted.
   // UJAM-FOUR-NEXT: [[RES:%[0-9]+]] = affine.apply [[UBMAP]]()[%[[N]]]
   // UJAM-FOUR-NEXT: affine.for [[IV0]] = 1 to 100 {
   // UJAM-FOUR-NEXT:   "foo"([[RES]])
   // UJAM-FOUR-NEXT: }
-  affine.for %i = %N to ()[s0] -> (s0+9) ()[%N] {
+  affine.for %i = %N to affine_map<()[s0] -> (s0+9)> ()[%N] {
     affine.for %j = 1 to 100 {
       "foo"(%i) : (index) -> ()
     }
   }
   return
 }
 
 // CHECK-LABEL: func @loop_nest_symbolic_and_min_upper_bound
 // CHECK-SAME: [[M:arg[0-9]+]]: index
 // CHECK-SAME: [[N:arg[0-9]+]]: index
 // CHECK-SAME: [[K:arg[0-9]+]]: index
 func @loop_nest_symbolic_and_min_upper_bound(%M : index, %N : index, %K : index) {
-  affine.for %i = 0 to min ()[s0, s1] -> (s0, s1, 1024)()[%M, %N] {
+  affine.for %i = 0 to min affine_map<()[s0, s1] -> (s0, s1, 1024)>()[%M, %N] {
     affine.for %j = 0 to %K {
       "foo"(%i, %j) : (index, index) -> ()
     }
   }
   return
 }
 // CHECK-NEXT:  affine.for [[IV0:%arg[0-9]+]] = 0 to min [[MAP_MULTI_RES]]()[%[[M]], %[[N]]] step 2 {
 // CHECK-NEXT:    affine.for [[IV1:%arg[0-9]+]] = 0 to %[[K]] {

mlir/test/Transforms/unroll.mlir

 // RUN: mlir-opt %s -affine-loop-unroll -unroll-full | FileCheck %s --check-prefix UNROLL-FULL
 // RUN: mlir-opt %s -affine-loop-unroll -unroll-full -unroll-full-threshold=2 | FileCheck %s --check-prefix SHORT
 // RUN: mlir-opt %s -affine-loop-unroll -unroll-factor=4 | FileCheck %s --check-prefix UNROLL-BY-4
 // RUN: mlir-opt %s -affine-loop-unroll -unroll-factor=1 | FileCheck %s --check-prefix UNROLL-BY-1
 
-// UNROLL-FULL-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0 + 1)
-// UNROLL-FULL-DAG: [[MAP1:#map[0-9]+]] = (d0) -> (d0 + 2)
-// UNROLL-FULL-DAG: [[MAP2:#map[0-9]+]] = (d0) -> (d0 + 3)
-// UNROLL-FULL-DAG: [[MAP3:#map[0-9]+]] = (d0) -> (d0 + 4)
-// UNROLL-FULL-DAG: [[MAP4:#map[0-9]+]] = (d0, d1) -> (d0 + 1)
-// UNROLL-FULL-DAG: [[MAP5:#map[0-9]+]] = (d0, d1) -> (d0 + 3)
-// UNROLL-FULL-DAG: [[MAP6:#map[0-9]+]] = (d0)[s0] -> (d0 + s0 + 1)
-
-// SHORT-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0 + 1)
-
-// UNROLL-BY-4-DAG: [[MAP0:#map[0-9]+]] = (d0) -> (d0 + 1)
-// UNROLL-BY-4-DAG: [[MAP1:#map[0-9]+]] = (d0) -> (d0 + 2)
-// UNROLL-BY-4-DAG: [[MAP2:#map[0-9]+]] = (d0) -> (d0 + 3)
-// UNROLL-BY-4-DAG: [[MAP3:#map[0-9]+]] = (d0, d1) -> (d0 + 1)
-// UNROLL-BY-4-DAG: [[MAP4:#map[0-9]+]] = (d0, d1) -> (d0 + 3)
-// UNROLL-BY-4-DAG: [[MAP5:#map[0-9]+]] = (d0)[s0] -> (d0 + s0 + 1)
-// UNROLL-BY-4-DAG: [[MAP6:#map[0-9]+]] = (d0, d1) -> (d0 * 16 + d1)
-// UNROLL-BY-4-DAG: [[MAP11:#map[0-9]+]] = (d0) -> (d0)
-// UNROLL-BY-4-DAG: [[MAP_TRIP_COUNT_MULTIPLE_FOUR:#map[0-9]+]] = ()[s0, s1, s2] -> (s0 + ((-s0 + s1) floordiv 4) * 4, s0 + ((-s0 + s2) floordiv 4) * 4, s0 + ((-s0) floordiv 4) * 4 + 1024)
+// UNROLL-FULL-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
+// UNROLL-FULL-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 + 2)>
+// UNROLL-FULL-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 + 3)>
+// UNROLL-FULL-DAG: [[MAP3:#map[0-9]+]] = affine_map<(d0) -> (d0 + 4)>
+// UNROLL-FULL-DAG: [[MAP4:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 1)>
+// UNROLL-FULL-DAG: [[MAP5:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3)>
+// UNROLL-FULL-DAG: [[MAP6:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 + s0 + 1)>
+
+// SHORT-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
+
+// UNROLL-BY-4-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
+// UNROLL-BY-4-DAG: [[MAP1:#map[0-9]+]] = affine_map<(d0) -> (d0 + 2)>
+// UNROLL-BY-4-DAG: [[MAP2:#map[0-9]+]] = affine_map<(d0) -> (d0 + 3)>
+// UNROLL-BY-4-DAG: [[MAP3:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 1)>
+// UNROLL-BY-4-DAG: [[MAP4:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3)>
+// UNROLL-BY-4-DAG: [[MAP5:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 + s0 + 1)>
+// UNROLL-BY-4-DAG: [[MAP6:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 16 + d1)>
+// UNROLL-BY-4-DAG: [[MAP11:#map[0-9]+]] = affine_map<(d0) -> (d0)>
+// UNROLL-BY-4-DAG: [[MAP_TRIP_COUNT_MULTIPLE_FOUR:#map[0-9]+]] = affine_map<()[s0, s1, s2] -> (s0 + ((-s0 + s1) floordiv 4) * 4, s0 + ((-s0 + s2) floordiv 4) * 4, s0 + ((-s0) floordiv 4) * 4 + 1024)>
 
 // UNROLL-FULL-LABEL: func @loop_nest_simplest() {
 func @loop_nest_simplest() {
   // UNROLL-FULL: affine.for %arg0 = 0 to 100 step 2 {
   affine.for %i = 0 to 100 step 2 {
     // UNROLL-FULL: %c1_i32 = constant 1 : i32
     // UNROLL-FULL-NEXT: %c1_i32_0 = constant 1 : i32
     // UNROLL-FULL-NEXT: %c1_i32_1 = constant 1 : i32
affine.for %i = 0 to 100 step 2 {
     // UNROLL-FULL-NEXT: %4 = "addi32"(%3, %c0_0) : (index, index) -> index
     // UNROLL-FULL-NEXT: %5 = affine.apply [[MAP1]](%c0)
     // UNROLL-FULL-NEXT: %6 = affine.apply [[MAP0]](%5)
     // UNROLL-FULL-NEXT: %7 = "addi32"(%6, %c0_0) : (index, index) -> index
     // UNROLL-FULL-NEXT: %8 = affine.apply [[MAP2]](%c0)
     // UNROLL-FULL-NEXT: %9 = affine.apply [[MAP0]](%8)
     // UNROLL-FULL-NEXT: %10 = "addi32"(%9, %c0_0) : (index, index) -> index
     affine.for %j = 0 to 4 {
-      %x = "affine.apply" (%j) { map = (d0) -> (d0 + 1) } :
+      %x = "affine.apply" (%j) { map = affine_map<(d0) -> (d0 + 1)> } :
         (index) -> (index)
       %y = "addi32"(%x, %c0) : (index, index) -> index
     }
   }       // UNROLL-FULL:  }
   return  // UNROLL-FULL:  return
 }         // UNROLL-FULL }
 
 // UNROLL-FULL-LABEL: func @loop_nest_strided() {
 func @loop_nest_strided() {
   // UNROLL-FULL: %c2 = constant 2 : index
   // UNROLL-FULL-NEXT: %c2_0 = constant 2 : index
   // UNROLL-FULL-NEXT: affine.for %arg0 = 0 to 100 {
   affine.for %i = 0 to 100 {
     // UNROLL-FULL:      %0 = affine.apply [[MAP0]](%c2_0)
     // UNROLL-FULL-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
     // UNROLL-FULL-NEXT: %2 = affine.apply [[MAP1]](%c2_0)
     // UNROLL-FULL-NEXT: %3 = affine.apply [[MAP0]](%2)
     // UNROLL-FULL-NEXT: %4 = "addi32"(%3, %3) : (index, index) -> index
     affine.for %j = 2 to 6 step 2 {
-      %x = "affine.apply" (%j) { map = (d0) -> (d0 + 1) } :
+      %x = "affine.apply" (%j) { map = affine_map<(d0) -> (d0 + 1)> } :
         (index) -> (index)
       %y = "addi32"(%x, %x) : (index, index) -> index
     }
     // UNROLL-FULL:      %5 = affine.apply [[MAP0]](%c2)
     // UNROLL-FULL-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> index
     // UNROLL-FULL-NEXT: %7 = affine.apply [[MAP1]](%c2)
     // UNROLL-FULL-NEXT: %8 = affine.apply [[MAP0]](%7)
     // UNROLL-FULL-NEXT: %9 = "addi32"(%8, %8) : (index, index) -> index
     // UNROLL-FULL-NEXT: %10 = affine.apply [[MAP3]](%c2)
     // UNROLL-FULL-NEXT: %11 = affine.apply [[MAP0]](%10)
     // UNROLL-FULL-NEXT: %12 = "addi32"(%11, %11) : (index, index) -> index
     affine.for %k = 2 to 7 step 2 {
-      %z = "affine.apply" (%k) { map = (d0) -> (d0 + 1) } :
+      %z = "affine.apply" (%k) { map = affine_map<(d0) -> (d0 + 1)> } :
         (index) -> (index)
       %w = "addi32"(%z, %z) : (index, index) -> index
     }
   }       // UNROLL-FULL:  }
   return  // UNROLL-FULL:  return
 }         // UNROLL-FULL }
 
 // UNROLL-FULL-LABEL: func @loop_nest_multiple_results() {
 func @loop_nest_multiple_results() {
   // UNROLL-FULL: %c0 = constant 0 : index
   // UNROLL-FULL-NEXT: affine.for %arg0 = 0 to 100 {
   affine.for %i = 0 to 100 {
     // UNROLL-FULL: %0 = affine.apply [[MAP4]](%arg0, %c0)
     // UNROLL-FULL-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
     // UNROLL-FULL-NEXT: %2 = affine.apply #map{{.*}}(%arg0, %c0)
     // UNROLL-FULL-NEXT: %3:2 = "fma"(%2, %0, %0) : (index, index, index) -> (index, index)
     // UNROLL-FULL-NEXT: %4 = affine.apply #map{{.*}}(%c0)
     // UNROLL-FULL-NEXT: %5 = affine.apply #map{{.*}}(%arg0, %4)
     // UNROLL-FULL-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> index
     // UNROLL-FULL-NEXT: %7 = affine.apply #map{{.*}}(%arg0, %4)
     // UNROLL-FULL-NEXT: %8:2 = "fma"(%7, %5, %5) : (index, index, index) -> (index, index)
     affine.for %j = 0 to 2 step 1 {
-      %x = affine.apply (d0, d1) -> (d0 + 1) (%i, %j)
+      %x = affine.apply affine_map<(d0, d1) -> (d0 + 1)> (%i, %j)
       %y = "addi32"(%x, %x) : (index, index) -> index
-      %z = affine.apply (d0, d1) -> (d0 + 3) (%i, %j)
+      %z = affine.apply affine_map<(d0, d1) -> (d0 + 3)> (%i, %j)
       %w:2 = "fma"(%z, %x, %x) : (index, index, index) -> (index, index)
     }
   }       // UNROLL-FULL:  }
   return  // UNROLL-FULL:  return
 }         // UNROLL-FULL }
 
 
 // Imperfect loop nest. Unrolling innermost here yields a perfect nest.
affine.for %i = 0 to 100 {
     // UNROLL-FULL-NEXT: %9 = affine.apply [[MAP0]](%8)
     // UNROLL-FULL-NEXT: %10 = "vmulf"(%8, %9) : (index, index) -> index
     // UNROLL-FULL-NEXT: %11 = "vaddf"(%10, %10) : (index, index) -> index
     // UNROLL-FULL-NEXT: %12 = affine.apply [[MAP2]](%c0)
     // UNROLL-FULL-NEXT: %13 = affine.apply [[MAP0]](%12)
     // UNROLL-FULL-NEXT: %14 = "vmulf"(%12, %13) : (index, index) -> index
     // UNROLL-FULL-NEXT: %15 = "vaddf"(%14, %14) : (index, index) -> index
     affine.for %j = 0 to 4 {
-      %x = "affine.apply" (%j) { map = (d0) -> (d0 + 1) } :
+      %x = "affine.apply" (%j) { map = affine_map<(d0) -> (d0 + 1)> } :
         (index) -> (index)
        %y = "vmulf"(%j, %x) : (index, index) -> index
        %z = "vaddf"(%y, %y) : (index, index) -> index
     }
     // UNROLL-FULL: %16 = "scale"(%c128, %arg1) : (index, index) -> index
     %addr = "scale"(%c128, %i) : (index, index) -> index
     // UNROLL-FULL: "vst"(%16, %arg1) : (index, index) -> ()
     "vst"(%addr, %i) : (index, index) -> ()
func @loop_nest_seq_multiple() {
   // UNROLL-FULL-NEXT: "mul"(%2, %2) : (index, index) -> ()
   // UNROLL-FULL-NEXT: %3 = affine.apply [[MAP1]](%c0_0)
   // UNROLL-FULL-NEXT: %4 = affine.apply [[MAP0]](%3)
   // UNROLL-FULL-NEXT: "mul"(%4, %4) : (index, index) -> ()
   // UNROLL-FULL-NEXT: %5 = affine.apply [[MAP2]](%c0_0)
   // UNROLL-FULL-NEXT: %6 = affine.apply [[MAP0]](%5)
   // UNROLL-FULL-NEXT: "mul"(%6, %6) : (index, index) -> ()
   affine.for %j = 0 to 4 {
-    %x = "affine.apply" (%j) { map = (d0) -> (d0 + 1) } :
+    %x = "affine.apply" (%j) { map = affine_map<(d0) -> (d0 + 1)> } :
       (index) -> (index)
     "mul"(%x, %x) : (index, index) -> ()
   }
 
   // UNROLL-FULL: %c99 = constant 99 : index
   %k = constant 99 : index
   // UNROLL-FULL: affine.for %arg0 = 0 to 100 step 2 {
   affine.for %m = 0 to 100 step 2 {
     // UNROLL-FULL: %7 = affine.apply [[MAP0]](%c0)
     // UNROLL-FULL-NEXT: %8 = affine.apply [[MAP6]](%c0)[%c99]
     // UNROLL-FULL-NEXT: %9 = affine.apply [[MAP0]](%c0)
     // UNROLL-FULL-NEXT: %10 = affine.apply [[MAP0]](%9)
     // UNROLL-FULL-NEXT: %11 = affine.apply [[MAP6]](%9)[%c99]
     // UNROLL-FULL-NEXT: %12 = affine.apply [[MAP1]](%c0)
     // UNROLL-FULL-NEXT: %13 = affine.apply [[MAP0]](%12)
     // UNROLL-FULL-NEXT: %14 = affine.apply [[MAP6]](%12)[%c99]
     // UNROLL-FULL-NEXT: %15 = affine.apply [[MAP2]](%c0)
     // UNROLL-FULL-NEXT: %16 = affine.apply [[MAP0]](%15)
     // UNROLL-FULL-NEXT: %17 = affine.apply [[MAP6]](%15)[%c99]
     affine.for %n = 0 to 4 {
-      %y = "affine.apply" (%n) { map = (d0) -> (d0 + 1) } :
+      %y = "affine.apply" (%n) { map = affine_map<(d0) -> (d0 + 1)> } :
         (index) -> (index)
-      %z = "affine.apply" (%n, %k) { map = (d0) [s0] -> (d0 + s0 + 1) } :
+      %z = "affine.apply" (%n, %k) { map = affine_map<(d0) [s0] -> (d0 + s0 + 1)> } :
         (index, index) -> (index)
     }     // UNROLL-FULL }
   }       // UNROLL-FULL }
   return  // UNROLL-FULL:  return
 }         // UNROLL-FULL }
 
 // UNROLL-FULL-LABEL: func @loop_nest_unroll_full() {
 func @loop_nest_unroll_full() {
func @loop_nest_outer_unroll() {
   // SHORT-NEXT:   %1 = "addi32"(%0, %0) : (index, index) -> index
   // SHORT-NEXT: }
   // SHORT-NEXT: affine.for %arg0 = 0 to 4 {
   // SHORT-NEXT:   %0 = affine.apply [[MAP0]](%arg0)
   // SHORT-NEXT:   %1 = "addi32"(%0, %0) : (index, index) -> index
   // SHORT-NEXT: }
   affine.for %i = 0 to 2 {
     affine.for %j = 0 to 4 {
-      %x = "affine.apply" (%j) { map = (d0) -> (d0 + 1) } :
+      %x = "affine.apply" (%j) { map = affine_map<(d0) -> (d0 + 1)> } :
         (index) -> (index)
       %y = "addi32"(%x, %x) : (index, index) -> index
     }
   }
   return  // SHORT:  return
 }         // SHORT }
 
 // We are doing a minimal FileCheck here. We just need this test case to
 // successfully run. Both %x and %y will get unrolled here as the min trip
 // count threshold set to 2.
 // SHORT-LABEL: func @loop_nest_seq_long() -> i32 {
 func @loop_nest_seq_long() -> i32 {
-  %A = alloc() : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
-  %B = alloc() : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
-  %C = alloc() : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
+  %A = alloc() : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+  %B = alloc() : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+  %C = alloc() : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
 
   %zero = constant 0 : i32
   %one = constant 1 : i32
   %two = constant 2 : i32
 
   %zero_idx = constant 0 : index
 
   // CHECK: affine.for %arg0 = 0 to 512
   affine.for %n0 = 0 to 512 {
     // CHECK: affine.for %arg1 = 0 to 8
     affine.for %n1 = 0 to 8 {
-      store %one,  %A[%n0, %n1] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
-      store %two,  %B[%n0, %n1] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
-      store %zero, %C[%n0, %n1] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
+      store %one,  %A[%n0, %n1] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+      store %two,  %B[%n0, %n1] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
+      store %zero, %C[%n0, %n1] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
     }
   }
 
   affine.for %x = 0 to 2 {
     affine.for %y = 0 to 2 {
       // CHECK: affine.for
       affine.for %arg2 = 0 to 8 {
         // CHECK-NOT: affine.for
         // CHECK: %{{[0-9]+}} = affine.apply
-        %b2 = "affine.apply" (%y, %arg2) {map = (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
-        %z = load %B[%x, %b2] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
+        %b2 = "affine.apply" (%y, %arg2) {map = affine_map<(d0, d1) -> (16*d0 + d1)>} : (index, index) -> index
+        %z = load %B[%x, %b2] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
         "op1"(%z) : (i32) -> ()
       }
       affine.for %j1 = 0 to 8 {
         affine.for %j2 = 0 to 8 {
-          %a2 = "affine.apply" (%y, %j2) {map = (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
-          %v203 = load %A[%j1, %a2] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
+          %a2 = "affine.apply" (%y, %j2) {map = affine_map<(d0, d1) -> (16*d0 + d1)>} : (index, index) -> index
+          %v203 = load %A[%j1, %a2] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
           "op2"(%v203) : (i32) -> ()
         }
         affine.for %k2 = 0 to 8 {
           %s0 = "op3"() : () -> i32
-          %c2 = "affine.apply" (%x, %k2) {map = (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
-          %s1 =  load %C[%j1, %c2] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
+          %c2 = "affine.apply" (%x, %k2) {map = affine_map<(d0, d1) -> (16*d0 + d1)>} : (index, index) -> index
+          %s1 =  load %C[%j1, %c2] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
           %s2 = "addi32"(%s0, %s1) : (i32, i32) -> i32
-          store %s2, %C[%j1, %c2] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
+          store %s2, %C[%j1, %c2] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
         }
       }
       "op4"() : () -> ()
     }
   }
-  %ret = load %C[%zero_idx, %zero_idx] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
+  %ret = load %C[%zero_idx, %zero_idx] : memref<512 x 512 x i32, affine_map<(d0, d1) -> (d0, d1)>, 2>
   return %ret : i32
 }
 
 // UNROLL-BY-4-LABEL: func @unroll_unit_stride_no_cleanup() {
 func @unroll_unit_stride_no_cleanup() {
   // UNROLL-BY-4: affine.for %arg0 = 0 to 100 {
   affine.for %i = 0 to 100 {
     // UNROLL-BY-4: for [[L1:%arg[0-9]+]] = 0 to 8 step 4 {

 // UNROLL-BY-4-NEXT:      %0 = "foo"() : () -> i32
 // UNROLL-BY-4-NEXT:      %1 = "foo"() : () -> i32
 // UNROLL-BY-4-NEXT:      %2 = "foo"() : () -> i32
 // UNROLL-BY-4-NEXT:      %3 = "foo"() : () -> i32
 // UNROLL-BY-4-NEXT:   }
 // UNROLL-BY-4-NEXT: }
 // UNROLL-BY-4-NEXT: return
   affine.for %i = 0 to 100 step 2 {
-    affine.for %j = 0 to (d0) -> (d0 - d0 mod 4) (%i) {
+    affine.for %j = 0 to affine_map<(d0) -> (d0 - d0 mod 4)> (%i) {
       %x = "foo"() : () -> i32
     }
   }
   return
 }
 
 // No cleanup will be generated here.
 // UNROLL-BY-4-LABEL: func @loop_nest_operand2() {
 func @loop_nest_operand2() {
 // UNROLL-BY-4:      affine.for %arg0 = 0 to 100 step 2 {
 // UNROLL-BY-4-NEXT:   affine.for %arg1 = [[MAP11]](%arg0) to #map{{[0-9]+}}(%arg0) step 4 {
 // UNROLL-BY-4-NEXT:     %0 = "foo"() : () -> i32
 // UNROLL-BY-4-NEXT:     %1 = "foo"() : () -> i32
 // UNROLL-BY-4-NEXT:     %2 = "foo"() : () -> i32
 // UNROLL-BY-4-NEXT:     %3 = "foo"() : () -> i32
 // UNROLL-BY-4-NEXT:   }
 // UNROLL-BY-4-NEXT: }
 // UNROLL-BY-4-NEXT: return
   affine.for %i = 0 to 100 step 2 {
-    affine.for %j = (d0) -> (d0) (%i) to (d0) -> (5*d0 + 4) (%i) {
+    affine.for %j = affine_map<(d0) -> (d0)> (%i) to affine_map<(d0) -> (5*d0 + 4)> (%i) {
       %x = "foo"() : () -> i32
     }
   }
   return
 }
 
 // Difference between loop bounds is constant, but not a multiple of unroll
 // factor. The cleanup loop happens to be a single iteration one and is promoted.
 // UNROLL-BY-4-LABEL: func @loop_nest_operand3() {
 func @loop_nest_operand3() {
   // UNROLL-BY-4: affine.for %arg0 = 0 to 100 step 2 {
   affine.for %i = 0 to 100 step 2 {
     // UNROLL-BY-4: affine.for %arg1 = [[MAP11]](%arg0) to #map{{[0-9]+}}(%arg0) step 4 {
     // UNROLL-BY-4-NEXT: %1 = "foo"() : () -> i32
     // UNROLL-BY-4-NEXT: %2 = "foo"() : () -> i32
     // UNROLL-BY-4-NEXT: %3 = "foo"() : () -> i32
     // UNROLL-BY-4-NEXT: %4 = "foo"() : () -> i32
     // UNROLL-BY-4-NEXT: }
     // UNROLL-BY-4-NEXT: %0 = "foo"() : () -> i32
-    affine.for %j = (d0) -> (d0) (%i) to (d0) -> (d0 + 9) (%i) {
+    affine.for %j = affine_map<(d0) -> (d0)> (%i) to affine_map<(d0) -> (d0 + 9)> (%i) {
       %x = "foo"() : () -> i32
     }
   } // UNROLL-BY-4: }
   return
 }
 
 // UNROLL-BY-4-LABEL: func @loop_nest_symbolic_bound(%arg0: index) {
 func @loop_nest_symbolic_bound(%N : index) {

 // UNROLL-BY-4-NEXT:   "foo"()
 // UNROLL-BY-4_NEXT: }
   }
   return
 }
 
 // UNROLL-BY-4-LABEL: func @loop_nest_symbolic_and_min_upper_bound
 func @loop_nest_symbolic_and_min_upper_bound(%M : index, %N : index, %K : index) {
-  affine.for %i = %M to min ()[s0, s1] -> (s0, s1, 1024)()[%N, %K] {
+  affine.for %i = %M to min affine_map<()[s0, s1] -> (s0, s1, 1024)>()[%N, %K] {
     "foo"() : () -> ()
   }
   return
 }
 // CHECK-NEXT:  affine.for %arg0 = %arg0 to min [[MAP_TRIP_COUNT_MULTIPLE_FOUR]]()[%arg0, %arg1, %arg2] step 4 {
 // CHECK-NEXT:    "foo"() : () -> ()
 // CHECK-NEXT:    "foo"() : () -> ()
 // CHECK-NEXT:    "foo"() : () -> ()
 // CHECK-NEXT:    "foo"() : () -> ()
 // CHECK-NEXT:  }
 // CHECK-NEXT:  affine.for %arg1 = max [[MAP_TRIP_COUNT_MULTIPLE_FOUR]]()[%arg0, %arg1, %arg2] to min #map28()[%arg1, %arg2] {
 // CHECK-NEXT:    "foo"() : () -> ()
 // CHECK-NEXT:  }
 // CHECK-NEXT:  return
 
 // The trip count here is a multiple of four, but this can be inferred only
 // through composition. Check for no cleanup loop.
 // UNROLL-BY-4-LABEL: func @loop_nest_non_trivial_multiple_upper_bound
 func @loop_nest_non_trivial_multiple_upper_bound(%M : index, %N : index) {
-  %T = affine.apply (d0) -> (4*d0 + 1)(%M)
-  %K = affine.apply (d0) -> (d0 - 1) (%T)
-  affine.for %i = 0 to min (d0, d1) -> (4 * d0, d1, 1024)(%N, %K) {
+  %T = affine.apply affine_map<(d0) -> (4*d0 + 1)>(%M)
+  %K = affine.apply affine_map<(d0) -> (d0 - 1)> (%T)
+  affine.for %i = 0 to min affine_map<(d0, d1) -> (4 * d0, d1, 1024)>(%N, %K) {
     "foo"() : () -> ()
   }
   return
 }
 // UNROLL-BY-4: affine.for %arg2 = 0 to min
 // UNROLL-BY-4-NOT: for
 // UNROLL-BY-4: return
 
 // UNROLL-BY-4-LABEL: func @loop_nest_non_trivial_multiple_upper_bound_alt
 func @loop_nest_non_trivial_multiple_upper_bound_alt(%M : index, %N : index) {
-  %K = affine.apply (d0) -> (4*d0) (%M)
-  affine.for %i = 0 to min ()[s0, s1] -> (4 * s0, s1, 1024)()[%N, %K] {
+  %K = affine.apply affine_map<(d0) -> (4*d0)> (%M)
+  affine.for %i = 0 to min affine_map<()[s0, s1] -> (4 * s0, s1, 1024)>()[%N, %K] {
     "foo"() : () -> ()
   }
   // UNROLL-BY-4: affine.for %arg2 = 0 to min
   // UNROLL-BY-4-NEXT: "foo"
   // UNROLL-BY-4-NEXT: "foo"
   // UNROLL-BY-4-NEXT: "foo"
   // UNROLL-BY-4-NEXT: "foo"
   // UNROLL-BY-4-NOT for

mlir/test/mlir-cpu-runner/linalg_integration_test.mlir

 // RUN: mlir-opt %s -convert-linalg-to-llvm | mlir-cpu-runner -e dot -entry-point-result=f32 -shared-libs=%linalg_test_lib_dir/libcblas%shlibext,%linalg_test_lib_dir/libcblas_interface%shlibext | FileCheck %s
 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-linalg-to-llvm | mlir-cpu-runner -e dot -entry-point-result=f32 -shared-libs=%linalg_test_lib_dir/libcblas%shlibext,%linalg_test_lib_dir/libcblas_interface%shlibext | FileCheck %s
 // RUN: mlir-opt %s -convert-linalg-to-llvm | mlir-cpu-runner -e matmul -entry-point-result=f32 -shared-libs=%linalg_test_lib_dir/libcblas%shlibext,%linalg_test_lib_dir/libcblas_interface%shlibext | FileCheck %s
 // RUN: mlir-opt %s -convert-linalg-to-loops -convert-linalg-to-llvm | mlir-cpu-runner -e matmul -entry-point-result=f32 -shared-libs=%linalg_test_lib_dir/libcblas%shlibext,%linalg_test_lib_dir/libcblas_interface%shlibext | FileCheck %s
 // RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=2,3,4 -linalg-promote-subviews -convert-linalg-to-loops -convert-linalg-to-llvm | mlir-cpu-runner -e matmul -entry-point-result=f32 -shared-libs=%linalg_test_lib_dir/libcblas%shlibext,%linalg_test_lib_dir/libcblas_interface%shlibext | FileCheck %s
 // RUN: mlir-opt %s -linalg-tile -linalg-tile-sizes=2,3,4 -linalg-promote-subviews -convert-linalg-to-llvm | mlir-cpu-runner -e matmul -entry-point-result=f32 -shared-libs=%linalg_test_lib_dir/libcblas%shlibext,%linalg_test_lib_dir/libcblas_interface%shlibext | FileCheck %s
 
-#strided1D = (d0) -> (d0)
-#strided2D = (d0, d1)[s0] -> (d0 * s0 + d1)
+#strided1D = affine_map<(d0) -> (d0)>
+#strided2D = affine_map<(d0, d1)[s0] -> (d0 * s0 + d1)>
 
 // Creates and returns a 1-D buffer of size %s filled with the value %f
 func @alloc_filled_f32(%s : index, %f : f32) -> memref<?xi8> {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c4 = constant 4 : index
   %s4 = muli %s, %c4: index
   %buf = alloc(%s4) {alignment = 256} : memref<?xi8>