NFC: Rename affine_apply to affine.apply. This is the first step to adding a namespace to the affine dialect.

PiperOrigin-RevId: 232707862

6 files changed, 179 insertions, 179 deletions

diff --git a/mlir/test/Transforms/Vectorize/lower_vector_transfers.mlir b/mlir/test/Transforms/Vectorize/lower_vector_transfers.mlir
index 3e78ae833e6..b82ac08fe59 100644
--- a/mlir/test/Transforms/Vectorize/lower_vector_transfers.mlir
+++ b/mlir/test/Transforms/Vectorize/lower_vector_transfers.mlir
@@ -9,11 +9,11 @@ func @materialize_read_1d() {
   for %i0 = 0 to 7 step 4 {
     for %i1 = 0 to 42 step 4 {
       %f1 = vector_transfer_read %A, %i0, %i1 {permutation_map: (d0, d1) -> (d0)} : (memref<7x42xf32>, index, index) -> vector<4xf32>
-      %ip1 = affine_apply (d0) -> (d0 + 1) (%i1)
+      %ip1 = affine.apply (d0) -> (d0 + 1) (%i1)
       %f2 = vector_transfer_read %A, %i0, %ip1 {permutation_map: (d0, d1) -> (d0)} : (memref<7x42xf32>, index, index) -> vector<4xf32>
-      %ip2 = affine_apply (d0) -> (d0 + 2) (%i1)
+      %ip2 = affine.apply (d0) -> (d0 + 2) (%i1)
       %f3 = vector_transfer_read %A, %i0, %ip2 {permutation_map: (d0, d1) -> (d0)} : (memref<7x42xf32>, index, index) -> vector<4xf32>
-      %ip3 = affine_apply (d0) -> (d0 + 3) (%i1)
+      %ip3 = affine.apply (d0) -> (d0 + 3) (%i1)
       %f4 = vector_transfer_read %A, %i0, %ip3 {permutation_map: (d0, d1) -> (d0)} : (memref<7x42xf32>, index, index) -> vector<4xf32>
       // Both accesses in the load must be clipped otherwise %i1 + 2 and %i1 + 3 will go out of bounds.
       // CHECK: {{.*}} = select
@@ -35,7 +35,7 @@ func @materialize_read_1d_partially_specialized(%dyn1 : index, %dyn2 : index, %d
         for %i3 = 0 to 42 step 2 {
           for %i4 = 0 to %dyn4 {
             %f1 = vector_transfer_read %A, %i0, %i1, %i2, %i3, %i4 {permutation_map: (d0, d1, d2, d3, d4) -> (d3)} : ( memref<7x?x?x42x?xf32>, index, index, index, index, index) -> vector<4xf32>
-            %i3p1 = affine_apply (d0) -> (d0 + 1) (%i3)
+            %i3p1 = affine.apply (d0) -> (d0 + 1) (%i3)
             %f2 = vector_transfer_read %A, %i0, %i1, %i2, %i3p1, %i4 {permutation_map: (d0, d1, d2, d3, d4) -> (d3)} : ( memref<7x?x?x42x?xf32>, index, index, index, index, index) -> vector<4xf32>
           }
         }
@@ -69,30 +69,30 @@ func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
   // CHECK-NEXT:          for %[[I4:.*]] = 0 to 3 {
   // CHECK-NEXT:            for %[[I5:.*]] = 0 to 4 {
   // CHECK-NEXT:              for %[[I6:.*]] = 0 to 5 {
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]]
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]]
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]]
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]]
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}} : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]]
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[SUB]]
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]]
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[SUB]]
   // CHECK-NEXT:                {{.*}} = select
   // CHECK-NEXT:                {{.*}} = select
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}} : index
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}} : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[SUB]]
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[SUB]]
   // CHECK-NEXT:                {{.*}} = select
   // CHECK-NEXT:                {{.*}} = select
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}} : index
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}} : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[SUB]]
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[SUB]]
   // CHECK-NEXT:                {{.*}} = select
   // CHECK-NEXT:                {{.*}} = select
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]]
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]]
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]]
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]]
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}}, {{.*}} : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]]
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[SUB]]
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]]
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[SUB]]
   // CHECK-NEXT:                {{.*}} = select {{.*}} : index
   // CHECK-NEXT:                {{.*}} = select {{.*}} : index
   // CHECK-NEXT:                {{.*}} = load %0[{{.*}}] : memref<?x?x?x?xf32>
@@ -142,33 +142,33 @@ func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
   // CHECK-NEXT:            for %[[I5:.*]] = 0 to 4 {
   // CHECK-NEXT:              for %[[I6:.*]] = 0 to 5 {
   // CHECK-NEXT:                {{.*}} = load {{.*}}[%[[I6]], %[[I5]], %[[I4]]] : memref<5x4x3xf32>
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]](%[[I0]], %[[I4]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]](%[[I0]], %[[I4]])
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]](%[[I0]], %[[I4]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]](%[[I0]], %[[I4]])
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}}, {{.*}} : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]](%[[I0]], %[[I4]])
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[SUB]]({{.*}}, %[[C1]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]](%[[I0]], %[[I4]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[SUB]]({{.*}}, %[[C1]])
   // CHECK-NEXT:                {{.*}} = select {{.*}}, {{.*}}, {{.*}} : index
   // CHECK-NEXT:                {{.*}} = select {{.*}}, %[[C0]], {{.*}} : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]](%[[I1]], %[[I5]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]](%[[I1]], %[[I5]])
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]](%[[I1]], %[[I5]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]](%[[I1]], %[[I5]])
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}}, {{.*}} : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]](%[[I1]], %[[I5]])
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[SUB]]({{.*}}, %[[C1]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]](%[[I1]], %[[I5]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[SUB]]({{.*}}, %[[C1]])
   // CHECK-NEXT:                {{.*}} = select {{.*}}, {{.*}}, {{.*}} : index
   // CHECK-NEXT:                {{.*}} = select {{.*}}, %[[C0]], {{.*}} : index
   // CHECK-NEXT:                {{.*}} = cmpi "slt", %[[I2]], %[[C0]] : index
   // CHECK-NEXT:                {{.*}} = cmpi "slt", %[[I2]], %3 : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #map{{.*}}(%3, %[[C1]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #map{{.*}}(%3, %[[C1]])
   // CHECK-NEXT:                {{.*}} = select {{.*}}, %[[I2]], {{.*}} : index
   // CHECK-NEXT:                {{.*}} = select {{.*}}, %[[C0]], {{.*}} : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]](%[[I3]], %[[I6]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]](%[[I3]], %[[I6]])
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]](%[[I3]], %[[I6]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]](%[[I3]], %[[I6]])
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}}, {{.*}} : index
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[ADD]](%[[I3]], %[[I6]])
-  // CHECK-NEXT:                {{.*}} = affine_apply #[[SUB]]({{.*}}, %[[C1]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[ADD]](%[[I3]], %[[I6]])
+  // CHECK-NEXT:                {{.*}} = affine.apply #[[SUB]]({{.*}}, %[[C1]])
   // CHECK-NEXT:                {{.*}} = select {{.*}}, {{.*}}, {{.*}} : index
   // CHECK-NEXT:                {{.*}} = select {{.*}}, %[[C0]], {{.*}} : index
   // CHECK-NEXT:                store {{.*}}, {{.*}}[{{.*}}, {{.*}}, {{.*}}, {{.*}}] : memref<?x?x?x?xf32>
diff --git a/mlir/test/Transforms/Vectorize/materialize_vectors_1d_to_1d.mlir b/mlir/test/Transforms/Vectorize/materialize_vectors_1d_to_1d.mlir
index 100822ea455..b5f771d7e62 100644
--- a/mlir/test/Transforms/Vectorize/materialize_vectors_1d_to_1d.mlir
+++ b/mlir/test/Transforms/Vectorize/materialize_vectors_1d_to_1d.mlir
@@ -21,17 +21,17 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   // CHECK-NEXT:     [[CST1:%.*]] = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     [[CST2:%.*]] = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     [[CST3:%.*]] = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
-  // CHECK-NEXT:     [[VAL00:%.*]] = affine_apply [[ID1]]{{.*}}
-  // CHECK-NEXT:     [[VAL01:%.*]] = affine_apply [[ID1]]{{.*}}
+  // CHECK-NEXT:     [[VAL00:%.*]] = affine.apply [[ID1]]{{.*}}
+  // CHECK-NEXT:     [[VAL01:%.*]] = affine.apply [[ID1]]{{.*}}
   // CHECK-NEXT:     vector_transfer_write [[CST0]], {{.*}}, [[VAL00]], [[VAL01]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL10:%.*]] = affine_apply [[ID1]]{{.*}}
-  // CHECK-NEXT:     [[VAL11:%.*]] = affine_apply [[D0P8]]{{.*}}
+  // CHECK-NEXT:     [[VAL10:%.*]] = affine.apply [[ID1]]{{.*}}
+  // CHECK-NEXT:     [[VAL11:%.*]] = affine.apply [[D0P8]]{{.*}}
   // CHECK-NEXT:     vector_transfer_write [[CST1]], {{.*}}, [[VAL10]], [[VAL11]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL20:%.*]] = affine_apply [[ID1]]{{.*}}
-  // CHECK-NEXT:     [[VAL21:%.*]] = affine_apply [[D0P16]]{{.*}}
+  // CHECK-NEXT:     [[VAL20:%.*]] = affine.apply [[ID1]]{{.*}}
+  // CHECK-NEXT:     [[VAL21:%.*]] = affine.apply [[D0P16]]{{.*}}
   // CHECK-NEXT:     vector_transfer_write [[CST2]], {{.*}}, [[VAL20]], [[VAL21]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL30:%.*]] = affine_apply [[ID1]]{{.*}}
-  // CHECK-NEXT:     [[VAL31:%.*]] = affine_apply [[D0P24]]{{.*}}
+  // CHECK-NEXT:     [[VAL30:%.*]] = affine.apply [[ID1]]{{.*}}
+  // CHECK-NEXT:     [[VAL31:%.*]] = affine.apply [[D0P24]]{{.*}}
   // CHECK-NEXT:     vector_transfer_write [[CST3]], {{.*}}, [[VAL30]], [[VAL31]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
   //
   for %i0 = 0 to %M {
@@ -47,17 +47,17 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   // CHECK-NEXT:     [[CST1:%.*]] = constant splat<vector<8xf32>, 2.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     [[CST2:%.*]] = constant splat<vector<8xf32>, 2.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     [[CST3:%.*]] = constant splat<vector<8xf32>, 2.000000e+00> : vector<8xf32>
-  // CHECK-NEXT:     [[VAL00:%.*]] = affine_apply [[ID1]]{{.*}}
-  // CHECK-NEXT:     [[VAL01:%.*]] = affine_apply [[ID1]]{{.*}}
+  // CHECK-NEXT:     [[VAL00:%.*]] = affine.apply [[ID1]]{{.*}}
+  // CHECK-NEXT:     [[VAL01:%.*]] = affine.apply [[ID1]]{{.*}}
   // CHECK-NEXT:     vector_transfer_write [[CST0]], {{.*}}, [[VAL00]], [[VAL01]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL10:%.*]] = affine_apply [[ID1]]{{.*}}
-  // CHECK-NEXT:     [[VAL11:%.*]] = affine_apply [[D0P8]]{{.*}}
+  // CHECK-NEXT:     [[VAL10:%.*]] = affine.apply [[ID1]]{{.*}}
+  // CHECK-NEXT:     [[VAL11:%.*]] = affine.apply [[D0P8]]{{.*}}
   // CHECK-NEXT:     vector_transfer_write [[CST1]], {{.*}}, [[VAL10]], [[VAL11]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL20:%.*]] = affine_apply [[ID1]]{{.*}}
-  // CHECK-NEXT:     [[VAL21:%.*]] = affine_apply [[D0P16]]{{.*}}
+  // CHECK-NEXT:     [[VAL20:%.*]] = affine.apply [[ID1]]{{.*}}
+  // CHECK-NEXT:     [[VAL21:%.*]] = affine.apply [[D0P16]]{{.*}}
   // CHECK-NEXT:     vector_transfer_write [[CST2]], {{.*}}, [[VAL20]], [[VAL21]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL30:%.*]] = affine_apply [[ID1]]{{.*}}
-  // CHECK-NEXT:     [[VAL31:%.*]] = affine_apply [[D0P24]]{{.*}}
+  // CHECK-NEXT:     [[VAL30:%.*]] = affine.apply [[ID1]]{{.*}}
+  // CHECK-NEXT:     [[VAL31:%.*]] = affine.apply [[D0P24]]{{.*}}
   // CHECK-NEXT:     vector_transfer_write [[CST3]], {{.*}}, [[VAL30]], [[VAL31]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
   //
   for %i2 = 0 to %M {
@@ -69,45 +69,45 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   // 4x unroll (jammed by construction).
   // CHECK: for %i4 = 0 to %arg0 {
   // CHECK-NEXT:   for %i5 = 0 to %arg1 step 32 {
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<8xf32>
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
   //
   for %i4 = 0 to %M {
diff --git a/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_1d.mlir b/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_1d.mlir
index cfabd5bd025..92df49fa8fa 100644
--- a/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_1d.mlir
+++ b/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_1d.mlir
@@ -23,23 +23,23 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   // CHECK-NEXT:     {{.*}} = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = constant splat<vector<8xf32>, 1.000000e+00> : vector<8xf32>
-  // CHECK-NEXT:     [[VAL00:%.*]] = affine_apply [[ID1]](%i0)
-  // CHECK-NEXT:     [[VAL01:%.*]] = affine_apply [[ID1]](%i1)
+  // CHECK-NEXT:     [[VAL00:%.*]] = affine.apply [[ID1]](%i0)
+  // CHECK-NEXT:     [[VAL01:%.*]] = affine.apply [[ID1]](%i1)
   // CHECK-NEXT:     vector_transfer_write {{.*}}, {{.*}}, [[VAL00]], [[VAL01]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL10:%.*]] = affine_apply [[ID1]](%i0)
-  // CHECK-NEXT:     [[VAL11:%.*]] = affine_apply [[D0P8]](%i1)
+  // CHECK-NEXT:     [[VAL10:%.*]] = affine.apply [[ID1]](%i0)
+  // CHECK-NEXT:     [[VAL11:%.*]] = affine.apply [[D0P8]](%i1)
   // CHECK-NEXT:     vector_transfer_write {{.*}}, {{.*}}, [[VAL10]], [[VAL11]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL20:%.*]] = affine_apply [[D0P1]](%i0)
-  // CHECK-NEXT:     [[VAL21:%.*]] = affine_apply [[ID1]](%i1)
+  // CHECK-NEXT:     [[VAL20:%.*]] = affine.apply [[D0P1]](%i0)
+  // CHECK-NEXT:     [[VAL21:%.*]] = affine.apply [[ID1]](%i1)
   // CHECK-NEXT:     vector_transfer_write {{.*}}, {{.*}}, [[VAL20]], [[VAL21]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL30:%.*]] = affine_apply [[D0P1]](%i0)
-  // CHECK-NEXT:     [[VAL31:%.*]] = affine_apply [[D0P8]](%i1)
+  // CHECK-NEXT:     [[VAL30:%.*]] = affine.apply [[D0P1]](%i0)
+  // CHECK-NEXT:     [[VAL31:%.*]] = affine.apply [[D0P8]](%i1)
   // CHECK-NEXT:     vector_transfer_write {{.*}}, {{.*}}, [[VAL30]], [[VAL31]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL40:%.*]] = affine_apply [[D0P2]](%i0)
-  // CHECK-NEXT:     [[VAL41:%.*]] = affine_apply [[ID1]](%i1)
+  // CHECK-NEXT:     [[VAL40:%.*]] = affine.apply [[D0P2]](%i0)
+  // CHECK-NEXT:     [[VAL41:%.*]] = affine.apply [[ID1]](%i1)
   // CHECK-NEXT:     vector_transfer_write {{.*}}, {{.*}}, [[VAL40]], [[VAL41]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
-  // CHECK-NEXT:     [[VAL50:%.*]] = affine_apply [[D0P2]](%i0)
-  // CHECK-NEXT:     [[VAL51:%.*]] = affine_apply [[D0P8]](%i1)
+  // CHECK-NEXT:     [[VAL50:%.*]] = affine.apply [[D0P2]](%i0)
+  // CHECK-NEXT:     [[VAL51:%.*]] = affine.apply [[D0P8]](%i1)
   // CHECK-NEXT:     vector_transfer_write {{.*}}, {{.*}}, [[VAL50]], [[VAL51]] {permutation_map: [[D0D1TOD1]]} : vector<8xf32>
   for %i0 = 0 to %M {
     for %i1 = 0 to %N {
@@ -61,41 +61,41 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   // (3x2)x unroll (jammed by construction).
   // CHECK: for %i4 = 0 to %arg0 step 3 {
   // CHECK-NEXT:   for %i5 = 0 to %arg1 step 16 {
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<8xf32>
@@ -103,23 +103,23 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<8xf32>
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
   //
   for %i4 = 0 to %M {
diff --git a/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_2d.mlir b/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_2d.mlir
index 82cfd85d2dc..36ec96e30b4 100644
--- a/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_2d.mlir
+++ b/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_2d.mlir
@@ -17,11 +17,11 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   // CHECK-NEXT:   for %i1 = 0 to %arg1 step 32 {
   // CHECK-NEXT:     {{.*}} = constant splat<vector<3x16xf32>, 1.000000e+00> : vector<3x16xf32>
   // CHECK-NEXT:     {{.*}} = constant splat<vector<3x16xf32>, 1.000000e+00> : vector<3x16xf32>
-  // CHECK-NEXT:     [[VAL00:%.*]] = affine_apply [[ID1]](%i0)
-  // CHECK-NEXT:     [[VAL01:%.*]] = affine_apply [[ID1]](%i1)
+  // CHECK-NEXT:     [[VAL00:%.*]] = affine.apply [[ID1]](%i0)
+  // CHECK-NEXT:     [[VAL01:%.*]] = affine.apply [[ID1]](%i1)
   // CHECK-NEXT:     vector_transfer_write {{.*}}, {{.*}}, [[VAL00]], [[VAL01]] {permutation_map: [[ID2]]} : vector<3x16xf32>
-  // CHECK-NEXT:     [[VAL10:%.*]] = affine_apply [[ID1]](%i0)
-  // CHECK-NEXT:     [[VAL11:%.*]] = affine_apply [[D0P16]](%i1)
+  // CHECK-NEXT:     [[VAL10:%.*]] = affine.apply [[ID1]](%i0)
+  // CHECK-NEXT:     [[VAL11:%.*]] = affine.apply [[D0P16]](%i1)
   // CHECK-NEXT:     vector_transfer_write {{.*}}, {{.*}}, [[VAL10]], [[VAL11]] {permutation_map: [[ID2]]} : vector<3x16xf32>
   //
   for %i0 = 0 to %M {
@@ -35,11 +35,11 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   // CHECK-NEXT:   for %i3 = 0 to %arg1 step 32 {
   // CHECK-NEXT:     {{.*}} = constant splat<vector<3x16xf32>, 2.000000e+00> : vector<3x16xf32>
   // CHECK-NEXT:     {{.*}} = constant splat<vector<3x16xf32>, 2.000000e+00> : vector<3x16xf32>
-  // CHECK-NEXT:     [[VAL00:%.*]] = affine_apply [[ID1]](%i2)
-  // CHECK-NEXT:     [[VAL01:%.*]] = affine_apply [[ID1]](%i3)
+  // CHECK-NEXT:     [[VAL00:%.*]] = affine.apply [[ID1]](%i2)
+  // CHECK-NEXT:     [[VAL01:%.*]] = affine.apply [[ID1]](%i3)
   // CHECK-NEXT:     vector_transfer_write {{.*}}, {{.*}}, [[VAL00]], [[VAL01]] {permutation_map: [[ID2]]} : vector<3x16xf32>
-  // CHECK-NEXT:     [[VAL10:%.*]] = affine_apply [[ID1]](%i2)
-  // CHECK-NEXT:     [[VAL11:%.*]] = affine_apply [[D0P16]](%i3)
+  // CHECK-NEXT:     [[VAL10:%.*]] = affine.apply [[ID1]](%i2)
+  // CHECK-NEXT:     [[VAL11:%.*]] = affine.apply [[D0P16]](%i3)
   // CHECK-NEXT:     vector_transfer_write {{.*}}, {{.*}}, [[VAL10]], [[VAL11]] {permutation_map: [[ID2]]} : vector<3x16xf32>
   //
   for %i2 = 0 to %M {
@@ -51,25 +51,25 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   // 2x unroll (jammed by construction).
   // CHECK: for %i4 = 0 to %arg0 step 3 {
   // CHECK-NEXT:   for %i5 = 0 to %arg1 step 32 {
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector_transfer_read
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<3x16xf32>
   // CHECK-NEXT:     {{.*}} = addf {{.*}} : vector<3x16xf32>
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
-  // CHECK-NEXT:     {{.*}} = affine_apply
-  // CHECK-NEXT:     {{.*}} = affine_apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
+  // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     vector_transfer_write
   //
   for %i4 = 0 to %M {
diff --git a/mlir/test/Transforms/Vectorize/normalize_maps.mlir b/mlir/test/Transforms/Vectorize/normalize_maps.mlir
index b5af6ab6ef1..9569dbe07fe 100644
--- a/mlir/test/Transforms/Vectorize/normalize_maps.mlir
+++ b/mlir/test/Transforms/Vectorize/normalize_maps.mlir
@@ -10,49 +10,49 @@
 // CHECK-LABEL: func @simple()
 func @simple() {
   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 (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)
   }
   // CHECK-NEXT: for %i0 = 0 to 7
-  // CHECK-NEXT:   {{.*}} affine_apply #[[ID1]](%i0)
-  // CHECK-NEXT:   {{.*}} affine_apply #[[D0TIMES2]](%i0)
-  // CHECK-NEXT:   {{.*}} affine_apply #[[ZERO]]()
+  // CHECK-NEXT:   {{.*}} affine.apply #[[ID1]](%i0)
+  // CHECK-NEXT:   {{.*}} affine.apply #[[D0TIMES2]](%i0)
+  // CHECK-NEXT:   {{.*}} affine.apply #[[ZERO]]()
 
   for %i1 = 0 to 7 {
     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 (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)
     }
   }
   //      CHECK: for %i1 = 0 to 7
   // CHECK-NEXT:   for %i2 = 0 to 42
-  // CHECK-NEXT:     {{.*}} affine_apply #[[D0PLUSD1]](%i1, %i2)
-  // CHECK-NEXT:     {{.*}} affine_apply #[[MINSD0PLUSD1]](%i1, %i2)
-  // CHECK-NEXT:     {{.*}} affine_apply #[[D0MINUSD1]](%i1, %i2)
+  // CHECK-NEXT:     {{.*}} affine.apply #[[D0PLUSD1]](%i1, %i2)
+  // CHECK-NEXT:     {{.*}} affine.apply #[[MINSD0PLUSD1]](%i1, %i2)
+  // CHECK-NEXT:     {{.*}} affine.apply #[[D0MINUSD1]](%i1, %i2)
 
   for %i3 = 0 to 16 {
     for %i4 = 0 to 47 step 2 {
       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 (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)
       }
     }
   }
   // CHECK:      for %i3 = 0 to 16
   // CHECK-NEXT:   for %i4 = 0 to 47 step 2
   // CHECK-NEXT:     for %i5 = 0 to 78 step 16
-  // CHECK-NEXT:       {{.*}} affine_apply #[[ID1]](%i3)
-  // CHECK-NEXT:       {{.*}} affine_apply #[[ID1]](%i4)
-  // CHECK-NEXT:       {{.*}} affine_apply #[[ID1]](%i5)
+  // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%i3)
+  // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%i4)
+  // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%i5)
 
   return
 }
diff --git a/mlir/test/Transforms/Vectorize/vectorize_1d.mlir b/mlir/test/Transforms/Vectorize/vectorize_1d.mlir
index 478200edf7a..da69e8dd26d 100644
--- a/mlir/test/Transforms/Vectorize/vectorize_1d.mlir
+++ b/mlir/test/Transforms/Vectorize/vectorize_1d.mlir
@@ -34,27 +34,27 @@ func @vec1d(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 //
 // CHECK:   for %i{{[0-9]*}} = 0 to [[ARG_M]] {
    for %i2 = 0 to %M { // not vectorized, would vectorize with --test-fastest-varying=1
-     %r2 = affine_apply (d0) -> (d0) (%i2)
+     %r2 = affine.apply (d0) -> (d0) (%i2)
      %a2 = load %A[%r2#0, %cst0] : memref<?x?xf32>
    }
 //
 // CHECK:for [[IV3:%[a-zA-Z0-9]+]] = 0 to [[ARG_M]] step 128
-// CHECK-NEXT:   [[APP3:%[a-zA-Z0-9]+]] = affine_apply {{.*}}[[IV3]]
+// CHECK-NEXT:   [[APP3:%[a-zA-Z0-9]+]] = affine.apply {{.*}}[[IV3]]
 // CHECK-NEXT:   {{.*}} = vector_transfer_read %arg0, [[C0]], [[APP3]] {permutation_map: #[[map_proj_d0d1_d1]]} : {{.*}} -> vector<128xf32>
    for %i3 = 0 to %M { // vectorized
-     %r3 = affine_apply (d0) -> (d0) (%i3)
+     %r3 = affine.apply (d0) -> (d0) (%i3)
      %a3 = load %A[%cst0, %r3#0] : memref<?x?xf32>
    }
 //
 // CHECK:for [[IV4:%[i0-9]+]] = 0 to [[ARG_M]] step 128 {
 // CHECK-NEXT:   for [[IV5:%[i0-9]*]] = 0 to [[ARG_N]] {
-// CHECK-NEXT:   [[APP50:%[0-9]+]] = affine_apply {{.*}}([[IV4]], [[IV5]])
-// CHECK-NEXT:   [[APP51:%[0-9]+]] = affine_apply {{.*}}([[IV4]], [[IV5]])
+// CHECK-NEXT:   [[APP50:%[0-9]+]] = affine.apply {{.*}}([[IV4]], [[IV5]])
+// CHECK-NEXT:   [[APP51:%[0-9]+]] = affine.apply {{.*}}([[IV4]], [[IV5]])
 // CHECK-NEXT:   {{.*}} = vector_transfer_read %arg0, [[APP50]], [[APP51]] {permutation_map: #[[map_proj_d0d1_d1]]} : {{.*}} -> vector<128xf32>
    for %i4 = 0 to %M { // vectorized
      for %i5 = 0 to %N { // not vectorized, would vectorize with --test-fastest-varying=1
-       %r50 = affine_apply (d0, d1) -> (d1) (%i4, %i5)
-       %r51 = affine_apply (d0, d1) -> (d0) (%i4, %i5)
+       %r50 = affine.apply (d0, d1) -> (d1) (%i4, %i5)
+       %r51 = affine.apply (d0, d1) -> (d0) (%i4, %i5)
        %a5 = load %A[%r50, %r51] : memref<?x?xf32>
      }
    }
@@ -63,21 +63,21 @@ func @vec1d(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-NEXT:   for [[IV7:%[i0-9]*]] = 0 to [[ARG_N]] {
    for %i6 = 0 to %M { // not vectorized, would vectorize with --test-fastest-varying=1
      for %i7 = 0 to %N { // not vectorized, can never vectorize
-       %r70 = affine_apply (d0, d1) -> (d1 + d0) (%i6, %i7)
-       %r71 = affine_apply (d0, d1) -> (d0) (%i6, %i7)
+       %r70 = affine.apply (d0, d1) -> (d1 + d0) (%i6, %i7)
+       %r71 = affine.apply (d0, d1) -> (d0) (%i6, %i7)
        %a7 = load %A[%r70, %r71] : memref<?x?xf32>
      }
    }
 //
 // CHECK:for [[IV8:%[i0-9]+]] = 0 to [[ARG_M]] step 128
 // CHECK-NEXT:   for [[IV9:%[i0-9]*]] = 0 to [[ARG_N]] {
-// CHECK-NEXT:   [[APP9_0:%[0-9]+]] = affine_apply {{.*}}([[IV8]], [[IV9]])
-// CHECK-NEXT:   [[APP9_1:%[0-9]+]] = affine_apply {{.*}}([[IV8]], [[IV9]])
+// CHECK-NEXT:   [[APP9_0:%[0-9]+]] = affine.apply {{.*}}([[IV8]], [[IV9]])
+// CHECK-NEXT:   [[APP9_1:%[0-9]+]] = affine.apply {{.*}}([[IV8]], [[IV9]])
 // CHECK-NEXT:   {{.*}} = vector_transfer_read %arg0, [[APP9_0]], [[APP9_1]] {permutation_map: #[[map_proj_d0d1_d1]]} : {{.*}} -> vector<128xf32>
    for %i8 = 0 to %M { // vectorized
      for %i9 = 0 to %N {
-       %r90 = affine_apply (d0, d1) -> (d1) (%i8, %i9)
-       %r91 = affine_apply (d0, d1) -> (d0 + d1) (%i8, %i9)
+       %r90 = affine.apply (d0, d1) -> (d1) (%i8, %i9)
+       %r91 = affine.apply (d0, d1) -> (d0 + d1) (%i8, %i9)
        %a9 = load %A[%r90, %r91] : memref<?x?xf32>
      }
    }
@@ -86,11 +86,11 @@ func @vec1d(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK:   for [[IV11:%[i0-9]*]] = 0 to %{{[0-9]*}} {
    for %i10 = 0 to %M { // not vectorized, need per load transposes
      for %i11 = 0 to %N { // not vectorized, need per load transposes
-       %r11_0 = affine_apply (d0, d1) -> (d0) (%i10, %i11)
-       %r11_1 = affine_apply (d0, d1) -> (d1) (%i10, %i11)
+       %r11_0 = affine.apply (d0, d1) -> (d0) (%i10, %i11)
+       %r11_1 = affine.apply (d0, d1) -> (d1) (%i10, %i11)
        %a11 = load %A[%r11_0, %r11_1] : memref<?x?xf32>
-       %r12_0 = affine_apply (d0, d1) -> (d1) (%i10, %i11)
-       %r12_1 = affine_apply (d0, d1) -> (d0) (%i10, %i11)
+       %r12_0 = affine.apply (d0, d1) -> (d1) (%i10, %i11)
+       %r12_1 = affine.apply (d0, d1) -> (d0) (%i10, %i11)
        store %a11, %A[%r12_0, %r12_1] : memref<?x?xf32>
      }
    }
@@ -101,9 +101,9 @@ func @vec1d(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
    for %i12 = 0 to %M { // not vectorized, can never vectorize
      for %i13 = 0 to %N { // not vectorized, can never vectorize
        for %i14 = 0 to %P { // vectorized
-         %r14_0 = affine_apply (d0, d1, d2) -> (d1) (%i12, %i13, %i14)
-         %r14_1 = affine_apply (d0, d1, d2) -> (d0 + d1) (%i12, %i13, %i14)
-         %r14_2 = affine_apply (d0, d1, d2) -> (d0 + d2) (%i12, %i13, %i14)
+         %r14_0 = affine.apply (d0, d1, d2) -> (d1) (%i12, %i13, %i14)
+         %r14_1 = affine.apply (d0, d1, d2) -> (d0 + d1) (%i12, %i13, %i14)
+         %r14_2 = affine.apply (d0, d1, d2) -> (d0 + d2) (%i12, %i13, %i14)
          %a14 = load %B[%r14_0, %r14_1, %r14_2] : memref<?x?x?xf32>
        }
      }