Add support for basic remark diagnostics. This is the minimal functionality needed to separate notes from remarks. It also provides a starting point to start building out better remark infrastructure.

--

PiperOrigin-RevId: 246175216

21 files changed, 354 insertions, 317 deletions

diff --git a/mlir/include/mlir/IR/Diagnostics.h b/mlir/include/mlir/IR/Diagnostics.h
index b4f002f2e35..45cb66a7126 100644
--- a/mlir/include/mlir/IR/Diagnostics.h
+++ b/mlir/include/mlir/IR/Diagnostics.h
@@ -37,6 +37,7 @@ enum class DiagnosticSeverity {
   Note,
   Warning,
   Error,
+  Remark,
 };
 
 //===----------------------------------------------------------------------===//
diff --git a/mlir/include/mlir/IR/Function.h b/mlir/include/mlir/IR/Function.h
index a2fb2b0df66..4c57ff6b3fc 100644
--- a/mlir/include/mlir/IR/Function.h
+++ b/mlir/include/mlir/IR/Function.h
@@ -249,19 +249,19 @@ public:
   void print(raw_ostream &os);
   void dump();
 
-  /// Emit an error about fatal conditions with this operation, reporting up to
+  /// Emit an error about fatal conditions with this function, reporting up to
   /// any diagnostic handlers that may be listening.  This function always
   /// returns failure.  NOTE: This may terminate the containing application,
   /// only use when the IR is in an inconsistent state.
   LogicalResult emitError(const Twine &message);
 
-  /// Emit a warning about this operation, reporting up to any diagnostic
+  /// Emit a warning about this function, reporting up to any diagnostic
   /// handlers that may be listening.
   void emitWarning(const Twine &message);
 
-  /// Emit a note about this operation, reporting up to any diagnostic
+  /// Emit a remark about this function, reporting up to any diagnostic
   /// handlers that may be listening.
-  void emitNote(const Twine &message);
+  void emitRemark(const Twine &message);
 
   /// Displays the CFG in a window. This is for use from the debugger and
   /// depends on Graphviz to generate the graph.
diff --git a/mlir/include/mlir/IR/MLIRContext.h b/mlir/include/mlir/IR/MLIRContext.h
index 553c17c8962..d90035bc823 100644
--- a/mlir/include/mlir/IR/MLIRContext.h
+++ b/mlir/include/mlir/IR/MLIRContext.h
@@ -63,6 +63,9 @@ public:
   /// Emit an error message using the diagnostic engine and return true.
   bool emitError(Location location, const Twine &message);
 
+  /// Emit a remark message using the diagnostic engine.
+  void emitRemark(Location location, const Twine &message);
+
   /// Returns the diagnostic engine for this context.
   DiagnosticEngine &getDiagEngine();
 
diff --git a/mlir/include/mlir/IR/OpDefinition.h b/mlir/include/mlir/IR/OpDefinition.h
index d57f8da1b24..4430e242e76 100644
--- a/mlir/include/mlir/IR/OpDefinition.h
+++ b/mlir/include/mlir/IR/OpDefinition.h
@@ -121,6 +121,10 @@ public:
   /// handlers that may be listening.
   void emitNote(const Twine &message);
 
+  /// Emit a remark about this operation, reporting up to any diagnostic
+  /// handlers that may be listening.
+  void emitRemark(const Twine &message);
+
   // These are default implementations of customization hooks.
 public:
   /// This hook returns any canonicalization pattern rewrites that the operation
diff --git a/mlir/include/mlir/IR/Operation.h b/mlir/include/mlir/IR/Operation.h
index 7203d32a3af..23f1abd579b 100644
--- a/mlir/include/mlir/IR/Operation.h
+++ b/mlir/include/mlir/IR/Operation.h
@@ -446,6 +446,10 @@ public:
   /// handlers that may be listening.
   void emitNote(const Twine &message);
 
+  /// Emit a remark about this operation, reporting up to any diagnostic
+  /// handlers that may be listening.
+  void emitRemark(const Twine &message);
+
 private:
   Operation(Location location, OperationName name, unsigned numResults,
             unsigned numSuccessors, unsigned numRegions,
diff --git a/mlir/lib/Analysis/LoopAnalysis.cpp b/mlir/lib/Analysis/LoopAnalysis.cpp
index 5254f14bb8c..78caa4c2625 100644
--- a/mlir/lib/Analysis/LoopAnalysis.cpp
+++ b/mlir/lib/Analysis/LoopAnalysis.cpp
@@ -186,7 +186,7 @@ bool mlir::isAccessInvariant(Value *iv, Value *index) {
   }
 
   if (affineApplyOps.size() > 1) {
-    affineApplyOps[0]->emitNote(
+    affineApplyOps[0]->emitRemark(
         "CompositionAffineMapsPass must have been run: there should be at most "
         "one AffineApplyOp, returning false conservatively.");
     return false;
diff --git a/mlir/lib/Analysis/MemRefDependenceCheck.cpp b/mlir/lib/Analysis/MemRefDependenceCheck.cpp
index 2872c4cf256..79017100fd7 100644
--- a/mlir/lib/Analysis/MemRefDependenceCheck.cpp
+++ b/mlir/lib/Analysis/MemRefDependenceCheck.cpp
@@ -98,7 +98,7 @@ static void checkDependences(ArrayRef<Operation *> loadsAndStores) {
         // TODO(andydavis) Print dependence type (i.e. RAW, etc) and print
         // distance vectors as: ([2, 3], [0, 10]). Also, shorten distance
         // vectors from ([1, 1], [3, 3]) to (1, 3).
-        srcOpInst->emitNote(
+        srcOpInst->emitRemark(
             "dependence from " + Twine(i) + " to " + Twine(j) + " at depth " +
             Twine(d) + " = " +
             getDirectionVectorStr(ret, numCommonLoops, d, dependenceComponents)
diff --git a/mlir/lib/Analysis/TestParallelismDetection.cpp b/mlir/lib/Analysis/TestParallelismDetection.cpp
index 701ef6ab348..ae5551db215 100644
--- a/mlir/lib/Analysis/TestParallelismDetection.cpp
+++ b/mlir/lib/Analysis/TestParallelismDetection.cpp
@@ -47,7 +47,7 @@ void TestParallelismDetection::runOnFunction() {
   FuncBuilder b(f);
   f.walk<AffineForOp>([&](AffineForOp forOp) {
     if (isLoopParallel(forOp))
-      forOp.emitNote("parallel loop");
+      forOp.emitRemark("parallel loop");
   });
 }
 
diff --git a/mlir/lib/IR/Function.cpp b/mlir/lib/IR/Function.cpp
index 98bafa2af82..e655e2ed774 100644
--- a/mlir/lib/IR/Function.cpp
+++ b/mlir/lib/IR/Function.cpp
@@ -116,21 +116,20 @@ void Function::erase() {
   getModule()->getFunctions().erase(this);
 }
 
-/// Emit a note about this operation, reporting up to any diagnostic
+/// Emit a remark about this function, reporting up to any diagnostic
 /// handlers that may be listening.
-void Function::emitNote(const Twine &message) {
-  getContext()->getDiagEngine().emit(getLoc(), message,
-                                     DiagnosticSeverity::Note);
+void Function::emitRemark(const Twine &message) {
+  getContext()->emitRemark(getLoc(), message);
 }
 
-/// Emit a warning about this operation, reporting up to any diagnostic
+/// Emit a warning about this function, reporting up to any diagnostic
 /// handlers that may be listening.
 void Function::emitWarning(const Twine &message) {
   getContext()->getDiagEngine().emit(getLoc(), message,
                                      DiagnosticSeverity::Warning);
 }
 
-/// Emit an error about fatal conditions with this operation, reporting up to
+/// Emit an error about fatal conditions with this function, reporting up to
 /// any diagnostic handlers that may be listening.  This function always
 /// returns failure.  NOTE: This may terminate the containing application, only
 /// use when the IR is in an inconsistent state.
diff --git a/mlir/lib/IR/MLIRContext.cpp b/mlir/lib/IR/MLIRContext.cpp
index ca39983f3a9..5161c27368c 100644
--- a/mlir/lib/IR/MLIRContext.cpp
+++ b/mlir/lib/IR/MLIRContext.cpp
@@ -427,6 +427,11 @@ bool MLIRContext::emitError(Location location, const llvm::Twine &message) {
   return true;
 }
 
+/// Emit a remark message using the diagnostic engine.
+void MLIRContext::emitRemark(Location location, const Twine &message) {
+  getImpl().diagEngine.emit(location, message, DiagnosticSeverity::Remark);
+}
+
 /// Returns the diagnostic engine for this context.
 DiagnosticEngine &MLIRContext::getDiagEngine() { return getImpl().diagEngine; }
 
diff --git a/mlir/lib/IR/Operation.cpp b/mlir/lib/IR/Operation.cpp
index 2a659715452..1a0aaa526c1 100644
--- a/mlir/lib/IR/Operation.cpp
+++ b/mlir/lib/IR/Operation.cpp
@@ -305,6 +305,12 @@ void Operation::walk(const std::function<void(Operation *)> &callback) {
 // Other
 //===----------------------------------------------------------------------===//
 
+/// Emit a remark about this operation, reporting up to any diagnostic
+/// handlers that may be listening.
+void Operation::emitRemark(const Twine &message) {
+  getContext()->emitRemark(getLoc(), message);
+}
+
 /// Emit a note about this operation, reporting up to any diagnostic
 /// handlers that may be listening.
 void Operation::emitNote(const Twine &message) {
@@ -671,6 +677,12 @@ void OpState::emitNote(const Twine &message) {
   getOperation()->emitNote(message);
 }
 
+/// Emit a remark about this operation, reporting up to any diagnostic
+/// handlers that may be listening.
+void OpState::emitRemark(const Twine &message) {
+  getOperation()->emitRemark(message);
+}
+
 //===----------------------------------------------------------------------===//
 // Op Trait implementations
 //===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Pass/Pass.cpp b/mlir/lib/Pass/Pass.cpp
index 2d79f56ec11..b7d7ca74dba 100644
--- a/mlir/lib/Pass/Pass.cpp
+++ b/mlir/lib/Pass/Pass.cpp
@@ -294,6 +294,9 @@ struct PrettyStackTraceParallelDiagnosticEntry
           case DiagnosticSeverity::Note:
             os << "note: ";
             break;
+          case DiagnosticSeverity::Remark:
+            os << "remark: ";
+            break;
           }
           os << message << '\n';
         });
diff --git a/mlir/lib/Transforms/DmaGeneration.cpp b/mlir/lib/Transforms/DmaGeneration.cpp
index 83ba858447b..c70b218e36d 100644
--- a/mlir/lib/Transforms/DmaGeneration.cpp
+++ b/mlir/lib/Transforms/DmaGeneration.cpp
@@ -211,12 +211,12 @@ static bool getFullMemRefAsRegion(Operation *opInst, unsigned numParamLoopIVs,
   return true;
 }
 
-static void emitNoteForBlock(Block &block, const Twine &message) {
+static void emitRemarkForBlock(Block &block, const Twine &message) {
   auto *op = block.getContainingOp();
   if (!op) {
-    block.getFunction()->emitNote(message);
+    block.getFunction()->emitRemark(message);
   } else {
-    op->emitNote(message);
+    op->emitRemark(message);
   }
 }
 
@@ -360,7 +360,7 @@ bool DmaGeneration::generateDma(const MemRefRegion &region, Block *block,
                oss << "Creating DMA buffer of type " << fastMemRefType;
                oss << " and size " << llvm::divideCeil(*sizeInBytes, 1024)
                    << " KiB\n";
-               emitNoteForBlock(*block, oss.str()));
+               emitRemarkForBlock(*block, oss.str()));
   } else {
     // Reuse the one already created.
     fastMemRef = fastBufferMap[memref];
@@ -741,8 +741,9 @@ uint64_t DmaGeneration::runOnBlock(Block::iterator begin, Block::iterator end) {
   AffineForOp forOp;
   uint64_t sizeInKib = llvm::divideCeil(totalDmaBuffersSizeInBytes, 1024);
   if (llvm::DebugFlag && (forOp = begin->dyn_cast<AffineForOp>())) {
-    forOp.emitNote(Twine(sizeInKib) +
-                   " KiB of DMA buffers in fast memory space for this block\n");
+    forOp.emitRemark(
+        Twine(sizeInKib) +
+        " KiB of DMA buffers in fast memory space for this block\n");
   }
 
   if (totalDmaBuffersSizeInBytes > fastMemCapacityBytes) {
diff --git a/mlir/lib/Transforms/LoopTiling.cpp b/mlir/lib/Transforms/LoopTiling.cpp
index c215fa34172..64d1839fd66 100644
--- a/mlir/lib/Transforms/LoopTiling.cpp
+++ b/mlir/lib/Transforms/LoopTiling.cpp
@@ -403,7 +403,7 @@ void LoopTiling::runOnFunction() {
         msg << tSize << " ";
       msg << "]\n";
       auto rootForOp = band[0];
-      rootForOp.emitNote(msg.str());
+      rootForOp.emitRemark(msg.str());
     }
     if (failed(tileCodeGen(band, tileSizes)))
       return signalPassFailure();
diff --git a/mlir/lib/Transforms/PipelineDataTransfer.cpp b/mlir/lib/Transforms/PipelineDataTransfer.cpp
index 8a4026340e7..0ad24e6a711 100644
--- a/mlir/lib/Transforms/PipelineDataTransfer.cpp
+++ b/mlir/lib/Transforms/PipelineDataTransfer.cpp
@@ -249,7 +249,8 @@ static void findMatchingStartFinishInsts(
 void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) {
   auto mayBeConstTripCount = getConstantTripCount(forOp);
   if (!mayBeConstTripCount.hasValue()) {
-    LLVM_DEBUG(forOp.emitNote("won't pipeline due to unknown trip count loop"));
+    LLVM_DEBUG(
+        forOp.emitRemark("won't pipeline due to unknown trip count loop"));
     return;
   }
 
@@ -257,7 +258,7 @@ void PipelineDataTransfer::runOnAffineForOp(AffineForOp forOp) {
   findMatchingStartFinishInsts(forOp, startWaitPairs);
 
   if (startWaitPairs.empty()) {
-    LLVM_DEBUG(forOp.emitNote("No dma start/finish pairs\n"));
+    LLVM_DEBUG(forOp.emitRemark("No dma start/finish pairs\n"));
     return;
   }
 
diff --git a/mlir/lib/Transforms/Utils/LoopUtils.cpp b/mlir/lib/Transforms/Utils/LoopUtils.cpp
index 1e9697a9ad5..a10e4a1ae49 100644
--- a/mlir/lib/Transforms/Utils/LoopUtils.cpp
+++ b/mlir/lib/Transforms/Utils/LoopUtils.cpp
@@ -244,7 +244,7 @@ LogicalResult mlir::instBodySkew(AffineForOp forOp, ArrayRef<uint64_t> shifts,
   // constant trip count "full tiles" before applying this.
   auto mayBeConstTripCount = getConstantTripCount(forOp);
   if (!mayBeConstTripCount.hasValue()) {
-    LLVM_DEBUG(forOp.emitNote("non-constant trip count loop not handled"));
+    LLVM_DEBUG(forOp.emitRemark("non-constant trip count loop not handled"));
     return success();
   }
   uint64_t tripCount = mayBeConstTripCount.getValue();
diff --git a/mlir/lib/Transforms/Vectorization/VectorizerTestPass.cpp b/mlir/lib/Transforms/Vectorization/VectorizerTestPass.cpp
index d080d65c756..b8640f05590 100644
--- a/mlir/lib/Transforms/Vectorization/VectorizerTestPass.cpp
+++ b/mlir/lib/Transforms/Vectorization/VectorizerTestPass.cpp
@@ -129,7 +129,7 @@ void VectorizerTestPass::testVectorShapeRatio(llvm::raw_ostream &outs) {
     auto superVectorType = opInst->getResult(0)->getType().cast<VectorType>();
     auto ratio = shapeRatio(superVectorType, subVectorType);
     if (!ratio.hasValue()) {
-      opInst->emitNote("NOT MATCHED");
+      opInst->emitRemark("NOT MATCHED");
     } else {
       outs << "\nmatched: " << *opInst << " with shape ratio: ";
       interleaveComma(MutableArrayRef<unsigned>(*ratio), outs);
@@ -297,8 +297,7 @@ void VectorizerTestPass::runOnFunction() {
     testNormalizeMaps();
 
   if (!outs.str().empty()) {
-    getContext().getDiagEngine().emit(UnknownLoc::get(&getContext()),
-                                      outs.str(), DiagnosticSeverity::Note);
+    getContext().emitRemark(UnknownLoc::get(&getContext()), outs.str());
   }
 }
 
diff --git a/mlir/lib/Transforms/Vectorize.cpp b/mlir/lib/Transforms/Vectorize.cpp
index 4d96cf725c6..d36dca8eca9 100644
--- a/mlir/lib/Transforms/Vectorize.cpp
+++ b/mlir/lib/Transforms/Vectorize.cpp
@@ -1211,10 +1211,9 @@ void Vectorize::runOnFunction() {
   Function &f = getFunction();
   if (!fastestVaryingPattern.empty() &&
       fastestVaryingPattern.size() != vectorSizes.size()) {
-    f.emitNote("Fastest varying pattern specified with different size than the "
-               "vector size.");
-    this->signalPassFailure();
-    return;
+    f.emitRemark("Fastest varying pattern specified with different size than "
+                 "the vector size.");
+    return signalPassFailure();
   }
 
   // Thread-safe RAII local context, BumpPtrAllocator freed on exit.
diff --git a/mlir/test/Transforms/memref-dependence-check.mlir b/mlir/test/Transforms/memref-dependence-check.mlir
index e287af9e079..0322059dba3 100644
--- a/mlir/test/Transforms/memref-dependence-check.mlir
+++ b/mlir/test/Transforms/memref-dependence-check.mlir
@@ -15,16 +15,16 @@ func @store_may_execute_before_load() {
   affine.if #set0(%c0) {
     affine.for %i0 = 0 to 10 {
       store %cf7, %m[%i0] : memref<10xf32>
-      // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 0 to 1 at depth 1 = true}}
+      // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = true}}
     }
   }
   affine.for %i1 = 0 to 10 {
     %v0 = load %m[%i1] : memref<10xf32>
-    // expected-note@-1 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 1 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-1 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 0 at depth 1 = false}}
   }
   return
 }
@@ -39,15 +39,15 @@ func @dependent_loops() {
   // because the first loop with the store dominates the second loop.
   affine.for %i0 = 0 to 10 {
     store %cst, %0[%i0] : memref<10xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = true}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = true}}
   }
   affine.for %i1 = 0 to 10 {
     %1 = load %0[%i1] : memref<10xf32>
-    // expected-note@-1 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 1 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-1 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 0 at depth 1 = false}}
   }
   return
 }
@@ -60,11 +60,11 @@ func @different_memrefs() {
   %c0 = constant 0 : index
   %c1 = constant 1.0 : f32
   store %c1, %m.a[%c0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = false}}
   %v0 = load %m.b[%c0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -76,11 +76,11 @@ func @store_load_different_elements() {
   %c1 = constant 1 : index
   %c7 = constant 7.0 : f32
   store %c7, %m[%c0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = false}}
   %v0 = load %m[%c1] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -92,11 +92,11 @@ func @load_store_different_elements() {
   %c1 = constant 1 : index
   %c7 = constant 7.0 : f32
   %v0 = load %m[%c1] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = false}}
   store %c7, %m[%c0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -107,11 +107,11 @@ func @store_load_same_element() {
   %c11 = constant 11 : index
   %c7 = constant 7.0 : f32
   store %c7, %m[%c11] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = true}}
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = true}}
   %v0 = load %m[%c11] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -122,11 +122,11 @@ func @load_load_same_element() {
   %c11 = constant 11 : index
   %c7 = constant 7.0 : f32
   %v0 = load %m[%c11] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = false}}
   %v1 = load %m[%c11] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -136,11 +136,11 @@ func @store_load_same_symbol(%arg0: index) {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   store %c7, %m[%arg0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = true}}
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = true}}
   %v0 = load %m[%arg0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -150,11 +150,11 @@ func @store_load_different_symbols(%arg0: index, %arg1: index) {
   %m = alloc() : memref<100xf32>
   %c7 = constant 7.0 : f32
   store %c7, %m[%arg0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = true}}
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = true}}
   %v0 = load %m[%arg1] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -166,12 +166,12 @@ func @store_load_diff_element_affine_apply_const() {
   %c8 = constant 8.0 : f32
   %a0 = affine.apply (d0) -> (d0) (%c1)
   store %c8, %m[%a0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = false}}
   %a1 = affine.apply (d0) -> (d0 + 1) (%c1)
   %v0 = load %m[%a1] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -181,15 +181,15 @@ 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  
+  %c11 = constant 11 : index
   %a0 = affine.apply (d0) -> (d0 + 1) (%c9)
   store %c7, %m[%a0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = true}} 
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = true}}
   %a1 = affine.apply (d0) -> (d0 - 1) (%c11)
   %v0 = load %m[%a1] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -200,12 +200,12 @@ func @store_load_affine_apply_symbol(%arg0: index) {
   %c7 = constant 7.0 : f32
   %a0 = affine.apply (d0) -> (d0) (%arg0)
   store %c7, %m[%a0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = true}}
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = true}}
   %a1 = affine.apply (d0) -> (d0) (%arg0)
   %v0 = load %m[%a1] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -216,12 +216,12 @@ func @store_load_affine_apply_symbol_offset(%arg0: index) {
   %c7 = constant 7.0 : f32
   %a0 = affine.apply (d0) -> (d0) (%arg0)
   store %c7, %m[%a0] : memref<100xf32>
-  // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 0 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 0 to 1 at depth 1 = false}}
   %a1 = affine.apply (d0) -> (d0 + 1) (%arg0)
   %v0 = load %m[%a1] : memref<100xf32>
-  // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-  // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
+  // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+  // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
   return
 }
 
@@ -234,16 +234,16 @@ func @store_range_load_after_range() {
   affine.for %i0 = 0 to 10 {
     %a0 = affine.apply (d0) -> (d0) (%i0)
     store %c7, %m[%a0] : memref<100xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = false}}
     %a1 = affine.apply (d0) -> (d0) (%c10)
     %v0 = load %m[%a1] : memref<100xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
@@ -257,16 +257,16 @@ func @store_load_func_symbol(%arg0: index, %arg1: index) {
   affine.for %i0 = 0 to %arg1 {
     %a0 = affine.apply (d0) -> (d0) (%arg0)
     store %c7, %m[%a0] : memref<100xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = [1, +inf]}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = [1, +inf]}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = true}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = [1, +inf]}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = [1, +inf]}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = true}}
     %a1 = affine.apply (d0) -> (d0) (%arg0)
     %v0 = load %m[%a1] : memref<100xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = [1, +inf]}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = [1, +inf]}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
@@ -283,18 +283,18 @@ func @store_range_load_last_in_range() {
     // 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).
     store %c7, %m[%a0] : memref<100xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = true}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = true}}
     %a1 = affine.apply (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 = load %m[%a1] : memref<100xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = [1, 9]}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = [1, 9]}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
@@ -308,16 +308,16 @@ func @store_range_load_before_range() {
   affine.for %i0 = 1 to 11 {
     %a0 = affine.apply (d0) -> (d0) (%i0)
     store %c7, %m[%a0] : memref<100xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = false}}
     %a1 = affine.apply (d0) -> (d0) (%c0)
     %v0 = load %m[%a1] : memref<100xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
@@ -334,16 +334,16 @@ func @store_range_load_first_in_range() {
     // constant index zero are reads after first store at index zero during
     // first iteration of the loop.
     store %c7, %m[%a0] : memref<100xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = [1, 9]}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = true}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = [1, 9]}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = true}}
     %a1 = affine.apply (d0) -> (d0 + 1) (%c0)
     %v0 = load %m[%a1] : memref<100xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
@@ -356,16 +356,16 @@ func @store_plus_3() {
   affine.for %i0 = 1 to 11 {
     %a0 = affine.apply (d0) -> (d0 + 3) (%i0)
     store %c7, %m[%a0] : memref<100xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = [3, 3]}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = [3, 3]}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = false}}
     %a1 = affine.apply (d0) -> (d0) (%i0)
     %v0 = load %m[%a1] : memref<100xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
@@ -378,16 +378,16 @@ func @load_minus_2() {
   affine.for %i0 = 2 to 11 {
     %a0 = affine.apply (d0) -> (d0) (%i0)
     store %c7, %m[%a0] : memref<100xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = [2, 2]}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = [2, 2]}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = false}}
     %a1 = affine.apply (d0) -> (d0 - 2) (%i0)
     %v0 = load %m[%a1] : memref<100xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
@@ -403,21 +403,21 @@ func @perfectly_nested_loops_loop_independent() {
       %a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
       %a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
       store %c7, %m[%a00, %a01] : memref<10x10xf32>
-      // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 0 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 0 to 1 at depth 1 = false}}
-      // expected-note@-5 {{dependence from 0 to 1 at depth 2 = false}}
-      // expected-note@-6 {{dependence from 0 to 1 at depth 3 = true}}
+      // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 0 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 0 to 1 at depth 1 = false}}
+      // expected-remark@-5 {{dependence from 0 to 1 at depth 2 = false}}
+      // expected-remark@-6 {{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)
       %v0 = load %m[%a10, %a11] : memref<10x10xf32>
-      // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 1 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 1 to 1 at depth 1 = false}}
-      // expected-note@-5 {{dependence from 1 to 1 at depth 2 = false}}
-      // expected-note@-6 {{dependence from 1 to 1 at depth 3 = false}}
+      // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 1 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 1 to 1 at depth 1 = false}}
+      // expected-remark@-5 {{dependence from 1 to 1 at depth 2 = false}}
+      // expected-remark@-6 {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
@@ -434,21 +434,21 @@ func @perfectly_nested_loops_loop_carried_at_depth1() {
       %a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
       %a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
       store %c7, %m[%a00, %a01] : memref<10x10xf32>
-      // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 0 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 0 to 1 at depth 1 = [2, 2][0, 0]}}
-      // expected-note@-5 {{dependence from 0 to 1 at depth 2 = false}}
-      // expected-note@-6 {{dependence from 0 to 1 at depth 3 = false}}
+      // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 0 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 0 to 1 at depth 1 = [2, 2][0, 0]}}
+      // expected-remark@-5 {{dependence from 0 to 1 at depth 2 = false}}
+      // expected-remark@-6 {{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)
       %v0 = load %m[%a10, %a11] : memref<10x10xf32>
-      // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 1 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 1 to 1 at depth 1 = false}}
-      // expected-note@-5 {{dependence from 1 to 1 at depth 2 = false}}
-      // expected-note@-6 {{dependence from 1 to 1 at depth 3 = false}}
+      // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 1 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 1 to 1 at depth 1 = false}}
+      // expected-remark@-5 {{dependence from 1 to 1 at depth 2 = false}}
+      // expected-remark@-6 {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
@@ -465,21 +465,21 @@ func @perfectly_nested_loops_loop_carried_at_depth2() {
       %a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
       %a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
       store %c7, %m[%a00, %a01] : memref<10x10xf32>
-      // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 0 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 0 to 1 at depth 1 = false}}
-      // expected-note@-5 {{dependence from 0 to 1 at depth 2 = [0, 0][3, 3]}}
-      // expected-note@-6 {{dependence from 0 to 1 at depth 3 = false}}
+      // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 0 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 0 to 1 at depth 1 = false}}
+      // expected-remark@-5 {{dependence from 0 to 1 at depth 2 = [0, 0][3, 3]}}
+      // expected-remark@-6 {{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)
       %v0 = load %m[%a10, %a11] : memref<10x10xf32>
-      // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 1 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 1 to 1 at depth 1 = false}}
-      // expected-note@-5 {{dependence from 1 to 1 at depth 2 = false}}
-      // expected-note@-6 {{dependence from 1 to 1 at depth 3 = false}}
+      // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 1 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 1 to 1 at depth 1 = false}}
+      // expected-remark@-5 {{dependence from 1 to 1 at depth 2 = false}}
+      // expected-remark@-6 {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
@@ -496,21 +496,21 @@ func @one_common_loop() {
       %a00 = affine.apply (d0, d1) -> (d0) (%i0, %i1)
       %a01 = affine.apply (d0, d1) -> (d1) (%i0, %i1)
       store %c7, %m[%a00, %a01] : memref<10x10xf32>
-      // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 0 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 0 to 1 at depth 1 = false}}
-      // expected-note@-5 {{dependence from 0 to 1 at depth 2 = true}}
+      // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 0 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 0 to 1 at depth 1 = false}}
+      // expected-remark@-5 {{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)
       %v0 = load %m[%a10, %a11] : memref<10x10xf32>
-      // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-      // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
-      // expected-note@-5 {{dependence from 1 to 1 at depth 3 = false}}
+      // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+      // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
+      // expected-remark@-5 {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
@@ -528,44 +528,44 @@ func @dependence_cycle() {
   affine.for %i0 = 0 to 9 {
     %a0 = affine.apply (d0) -> (d0) (%i0)
     %v0 = load %m.a[%a0] : memref<100xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
-    // expected-note@-5 {{dependence from 0 to 2 at depth 1 = false}}
-    // expected-note@-6 {{dependence from 0 to 2 at depth 2 = false}}
-    // expected-note@-7 {{dependence from 0 to 3 at depth 1 = false}}
-    // expected-note@-8 {{dependence from 0 to 3 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = false}}
+    // expected-remark@-5 {{dependence from 0 to 2 at depth 1 = false}}
+    // expected-remark@-6 {{dependence from 0 to 2 at depth 2 = false}}
+    // expected-remark@-7 {{dependence from 0 to 3 at depth 1 = false}}
+    // expected-remark@-8 {{dependence from 0 to 3 at depth 2 = false}}
     %a1 = affine.apply (d0) -> (d0) (%i0)
     store %v0, %m.b[%a1] : memref<100xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
-    // expected-note@-5 {{dependence from 1 to 2 at depth 1 = false}}
-    // expected-note@-6 {{dependence from 1 to 2 at depth 2 = true}}
-    // expected-note@-7 {{dependence from 1 to 3 at depth 1 = false}}
-    // expected-note@-8 {{dependence from 1 to 3 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-5 {{dependence from 1 to 2 at depth 1 = false}}
+    // expected-remark@-6 {{dependence from 1 to 2 at depth 2 = true}}
+    // expected-remark@-7 {{dependence from 1 to 3 at depth 1 = false}}
+    // expected-remark@-8 {{dependence from 1 to 3 at depth 2 = false}}
     %a2 = affine.apply (d0) -> (d0) (%i0)
     %v1 = load %m.b[%a2] : memref<100xf32>
-    // expected-note@-1 {{dependence from 2 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 2 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 2 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 2 to 1 at depth 2 = false}}
-    // expected-note@-5 {{dependence from 2 to 2 at depth 1 = false}}
-    // expected-note@-6 {{dependence from 2 to 2 at depth 2 = false}}
-    // expected-note@-7 {{dependence from 2 to 3 at depth 1 = false}}
-    // expected-note@-8 {{dependence from 2 to 3 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 2 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 2 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 2 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 2 to 1 at depth 2 = false}}
+    // expected-remark@-5 {{dependence from 2 to 2 at depth 1 = false}}
+    // expected-remark@-6 {{dependence from 2 to 2 at depth 2 = false}}
+    // expected-remark@-7 {{dependence from 2 to 3 at depth 1 = false}}
+    // expected-remark@-8 {{dependence from 2 to 3 at depth 2 = false}}
     %a3 = affine.apply (d0) -> (d0 + 1) (%i0)
     store %v1, %m.a[%a3] : memref<100xf32>
-    // expected-note@-1 {{dependence from 3 to 0 at depth 1 = [1, 1]}}
-    // expected-note@-2 {{dependence from 3 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 3 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 3 to 1 at depth 2 = false}}
-    // expected-note@-5 {{dependence from 3 to 2 at depth 1 = false}}
-    // expected-note@-6 {{dependence from 3 to 2 at depth 2 = false}}
-    // expected-note@-7 {{dependence from 3 to 3 at depth 1 = false}}
-    // expected-note@-8 {{dependence from 3 to 3 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 3 to 0 at depth 1 = [1, 1]}}
+    // expected-remark@-2 {{dependence from 3 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 3 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 3 to 1 at depth 2 = false}}
+    // expected-remark@-5 {{dependence from 3 to 2 at depth 1 = false}}
+    // expected-remark@-6 {{dependence from 3 to 2 at depth 2 = false}}
+    // expected-remark@-7 {{dependence from 3 to 3 at depth 1 = false}}
+    // expected-remark@-8 {{dependence from 3 to 3 at depth 2 = false}}
   }
   return
 }
@@ -580,21 +580,21 @@ func @negative_and_positive_direction_vectors(%arg0: index, %arg1: index) {
       %a00 = affine.apply (d0, d1) -> (d0 - 1) (%i0, %i1)
       %a01 = affine.apply (d0, d1) -> (d1 + 1) (%i0, %i1)
       %v0 = load %m[%a00, %a01] : memref<10x10xf32>
-      // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 0 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 0 to 1 at depth 1 = false}}
-      // expected-note@-5 {{dependence from 0 to 1 at depth 2 = false}}
-      // expected-note@-6 {{dependence from 0 to 1 at depth 3 = false}}
+      // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 0 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 0 to 1 at depth 1 = false}}
+      // expected-remark@-5 {{dependence from 0 to 1 at depth 2 = false}}
+      // expected-remark@-6 {{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)
       store %c7, %m[%a10, %a11] : memref<10x10xf32>
-      // expected-note@-1 {{dependence from 1 to 0 at depth 1 = [1, 1][-1, -1]}}
-      // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 1 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 1 to 1 at depth 1 = false}}
-      // expected-note@-5 {{dependence from 1 to 1 at depth 2 = false}}
-      // expected-note@-6 {{dependence from 1 to 1 at depth 3 = false}}
+      // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = [1, 1][-1, -1]}}
+      // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 1 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 1 to 1 at depth 1 = false}}
+      // expected-remark@-5 {{dependence from 1 to 1 at depth 2 = false}}
+      // expected-remark@-6 {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
@@ -609,20 +609,20 @@ func @war_raw_waw_deps() {
     affine.for %i1 = 0 to 10 {
       %a0 = affine.apply (d0) -> (d0 + 1) (%i1)
       %v0 = load %m[%a0] : memref<100xf32>
-      // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 0 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 0 to 1 at depth 1 = [1, 9][1, 1]}}
-      // expected-note@-5 {{dependence from 0 to 1 at depth 2 = [0, 0][1, 1]}}
-      // expected-note@-6 {{dependence from 0 to 1 at depth 3 = false}}
+      // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 0 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 0 to 1 at depth 1 = [1, 9][1, 1]}}
+      // expected-remark@-5 {{dependence from 0 to 1 at depth 2 = [0, 0][1, 1]}}
+      // expected-remark@-6 {{dependence from 0 to 1 at depth 3 = false}}
       %a1 = affine.apply (d0) -> (d0) (%i1)
       store %c7, %m[%a1] : memref<100xf32>
-      // expected-note@-1 {{dependence from 1 to 0 at depth 1 = [1, 9][-1, -1]}}
-      // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 1 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 1 to 1 at depth 1 = [1, 9][0, 0]}}
-      // expected-note@-5 {{dependence from 1 to 1 at depth 2 = false}}
-      // expected-note@-6 {{dependence from 1 to 1 at depth 3 = false}}
+      // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = [1, 9][-1, -1]}}
+      // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 1 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 1 to 1 at depth 1 = [1, 9][0, 0]}}
+      // expected-remark@-5 {{dependence from 1 to 1 at depth 2 = false}}
+      // expected-remark@-6 {{dependence from 1 to 1 at depth 3 = false}}
     }
   }
   return
@@ -638,16 +638,16 @@ func @mod_deps() {
     // Results are conservative here since we currently don't have a way to
     // represent strided sets in FlatAffineConstraints.
     %v0 = load %m[%a0] : memref<100xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = [1, 9]}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = [1, 9]}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = false}}
     %a1 = affine.apply (d0) -> ( (d0 + 1) mod 2) (%i0)
     store %c7, %m[%a1] : memref<100xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = [1, 9]}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = [2, 9]}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = [1, 9]}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = [2, 9]}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
@@ -661,10 +661,10 @@ func @loop_nest_depth() {
   affine.for %i0 = 0 to 128 {
     affine.for %i1 = 0 to 8 {
       store %c7, %0[%i0, %i1] : memref<100x100xf32>
-      // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-      // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-      // expected-note@-3 {{dependence from 0 to 0 at depth 3 = false}}
-      // expected-note@-4 {{dependence from 0 to 1 at depth 1 = true}}
+      // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+      // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+      // expected-remark@-3 {{dependence from 0 to 0 at depth 3 = false}}
+      // expected-remark@-4 {{dependence from 0 to 1 at depth 1 = true}}
     }
   }
   affine.for %i2 = 0 to 8 {
@@ -673,12 +673,12 @@ func @loop_nest_depth() {
         affine.for %i5 = 0 to 16 {
           %8 = affine.apply (d0, d1) -> (d0 * 16 + d1)(%i4, %i5)
           %9 = load %0[%8, %i3] : memref<100x100xf32>
-          // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-          // expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
-          // expected-note@-3 {{dependence from 1 to 1 at depth 2 = false}}
-          // expected-note@-4 {{dependence from 1 to 1 at depth 3 = false}}
-          // expected-note@-5 {{dependence from 1 to 1 at depth 4 = false}}
-          // expected-note@-6 {{dependence from 1 to 1 at depth 5 = false}}
+          // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+          // expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
+          // expected-remark@-3 {{dependence from 1 to 1 at depth 2 = false}}
+          // expected-remark@-4 {{dependence from 1 to 1 at depth 3 = false}}
+          // expected-remark@-5 {{dependence from 1 to 1 at depth 4 = false}}
+          // expected-remark@-6 {{dependence from 1 to 1 at depth 5 = false}}
         }
       }
     }
@@ -700,10 +700,10 @@ func @mod_div_3d() {
         %idx1 = affine.apply (d0, d1, d2) -> (d1 mod 2) (%i0, %i1, %i2)
         %idx2 = affine.apply (d0, d1, d2) -> (d2 floordiv 4) (%i0, %i1, %i2)
         store %c0, %M[%idx0, %idx1, %idx2] : memref<2 x 2 x 2 x i32>
-        // expected-note@-1 {{dependence from 0 to 0 at depth 1 = [1, 3][-7, 7][-3, 3]}}
-        // expected-note@-2 {{dependence from 0 to 0 at depth 2 = [0, 0][2, 7][-3, 3]}}
-        // expected-note@-3 {{dependence from 0 to 0 at depth 3 = [0, 0][0, 0][1, 3]}}
-        // expected-note@-4 {{dependence from 0 to 0 at depth 4 = false}}
+        // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = [1, 3][-7, 7][-3, 3]}}
+        // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = [0, 0][2, 7][-3, 3]}}
+        // expected-remark@-3 {{dependence from 0 to 0 at depth 3 = [0, 0][0, 0][1, 3]}}
+        // expected-remark@-4 {{dependence from 0 to 0 at depth 4 = false}}
       }
     }
   }
@@ -726,15 +726,15 @@ func @delinearize_mod_floordiv() {
           affine.for %i4 = 0 to 16 {
             affine.for %i5 = 0 to 1 {
               store %val, %in[%i0, %i1, %i2, %i3, %i4, %i5] : memref<2x2x3x3x16x1xi32>
-// expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-// expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-// expected-note@-3 {{dependence from 0 to 0 at depth 3 = false}}
-// expected-note@-4 {{dependence from 0 to 0 at depth 4 = false}}
-// expected-note@-5 {{dependence from 0 to 0 at depth 5 = false}}
-// expected-note@-6 {{dependence from 0 to 0 at depth 6 = false}}
-// expected-note@-7 {{dependence from 0 to 0 at depth 7 = false}}
-// expected-note@-8 {{dependence from 0 to 1 at depth 1 = true}}
-// expected-note@-9 {{dependence from 0 to 2 at depth 1 = false}}
+// expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+// expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+// expected-remark@-3 {{dependence from 0 to 0 at depth 3 = false}}
+// expected-remark@-4 {{dependence from 0 to 0 at depth 4 = false}}
+// expected-remark@-5 {{dependence from 0 to 0 at depth 5 = false}}
+// expected-remark@-6 {{dependence from 0 to 0 at depth 6 = false}}
+// expected-remark@-7 {{dependence from 0 to 0 at depth 7 = false}}
+// expected-remark@-8 {{dependence from 0 to 1 at depth 1 = true}}
+// expected-remark@-9 {{dependence from 0 to 2 at depth 1 = false}}
             }
           }
         }
@@ -759,23 +759,23 @@ func @delinearize_mod_floordiv() {
         ((((((d0 mod 294912) mod 147456) mod 1152) mod 384) mod 128)
           floordiv 128) (%a0)
       %v0 = load %in[%a10, %a11, %a13, %a14, %a12, %a15] : memref<2x2x3x3x16x1xi32>
-// expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-// expected-note@-2 {{dependence from 1 to 1 at depth 1 = false}}
-// expected-note@-3 {{dependence from 1 to 1 at depth 2 = false}}
-// expected-note@-4 {{dependence from 1 to 1 at depth 3 = false}}
-// expected-note@-5 {{dependence from 1 to 2 at depth 1 = false}}
-// expected-note@-6 {{dependence from 1 to 2 at depth 2 = false}}
-// expected-note@-7 {{dependence from 1 to 2 at depth 3 = false}}
+// expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+// expected-remark@-2 {{dependence from 1 to 1 at depth 1 = false}}
+// expected-remark@-3 {{dependence from 1 to 1 at depth 2 = false}}
+// expected-remark@-4 {{dependence from 1 to 1 at depth 3 = false}}
+// expected-remark@-5 {{dependence from 1 to 2 at depth 1 = false}}
+// expected-remark@-6 {{dependence from 1 to 2 at depth 2 = false}}
+// expected-remark@-7 {{dependence from 1 to 2 at depth 3 = false}}
 // TODO(andydavis): the dep tester shouldn't be printing out these messages
 // below; they are redundant.
       store %v0, %out[%ii, %jj] : memref<64x9xi32>
-// expected-note@-1 {{dependence from 2 to 0 at depth 1 = false}}
-// expected-note@-2 {{dependence from 2 to 1 at depth 1 = false}}
-// expected-note@-3 {{dependence from 2 to 1 at depth 2 = false}}
-// expected-note@-4 {{dependence from 2 to 1 at depth 3 = false}}
-// expected-note@-5 {{dependence from 2 to 2 at depth 1 = false}}
-// expected-note@-6 {{dependence from 2 to 2 at depth 2 = false}}
-// expected-note@-7 {{dependence from 2 to 2 at depth 3 = false}}
+// expected-remark@-1 {{dependence from 2 to 0 at depth 1 = false}}
+// expected-remark@-2 {{dependence from 2 to 1 at depth 1 = false}}
+// expected-remark@-3 {{dependence from 2 to 1 at depth 2 = false}}
+// expected-remark@-4 {{dependence from 2 to 1 at depth 3 = false}}
+// expected-remark@-5 {{dependence from 2 to 2 at depth 1 = false}}
+// expected-remark@-6 {{dependence from 2 to 2 at depth 2 = false}}
+// expected-remark@-7 {{dependence from 2 to 2 at depth 3 = false}}
     }
   }
   return
@@ -792,15 +792,15 @@ func @strided_loop_with_dependence_at_depth2() {
   %cf0 = constant 0.0 : f32
   affine.for %i0 = 0 to 8 step 2 {
     store %cf0, %0[%i0] : memref<10xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = true}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = true}}
     %v0 = load %0[%i0] : memref<10xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
@@ -815,15 +815,15 @@ func @strided_loop_with_no_dependence() {
   affine.for %i0 = 0 to 8 step 2 {
     %a0 = affine.apply (d0) -> (d0 + 1)(%i0)
     store %cf0, %0[%a0] : memref<10xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = false}}
     %v0 = load %0[%i0] : memref<10xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
@@ -838,15 +838,15 @@ func @strided_loop_with_loop_carried_dependence_at_depth1() {
   affine.for %i0 = 0 to 8 step 2 {
     %a0 = affine.apply (d0) -> (d0 + 4)(%i0)
     store %cf0, %0[%a0] : memref<10xf32>
-    // expected-note@-1 {{dependence from 0 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 0 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 0 to 1 at depth 1 = [4, 4]}}
-    // expected-note@-4 {{dependence from 0 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 0 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 0 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 0 to 1 at depth 1 = [4, 4]}}
+    // expected-remark@-4 {{dependence from 0 to 1 at depth 2 = false}}
     %v0 = load %0[%i0] : memref<10xf32>
-    // expected-note@-1 {{dependence from 1 to 0 at depth 1 = false}}
-    // expected-note@-2 {{dependence from 1 to 0 at depth 2 = false}}
-    // expected-note@-3 {{dependence from 1 to 1 at depth 1 = false}}
-    // expected-note@-4 {{dependence from 1 to 1 at depth 2 = false}}
+    // expected-remark@-1 {{dependence from 1 to 0 at depth 1 = false}}
+    // expected-remark@-2 {{dependence from 1 to 0 at depth 2 = false}}
+    // expected-remark@-3 {{dependence from 1 to 1 at depth 1 = false}}
+    // expected-remark@-4 {{dependence from 1 to 1 at depth 2 = false}}
   }
   return
 }
diff --git a/mlir/test/Transforms/parallelism-detection.mlir b/mlir/test/Transforms/parallelism-detection.mlir
index 2d76b2649df..5b2032b0b98 100644
--- a/mlir/test/Transforms/parallelism-detection.mlir
+++ b/mlir/test/Transforms/parallelism-detection.mlir
@@ -6,9 +6,9 @@ func @loop_nest_3d_outer_two_parallel(%N : index) {
   %1 = alloc() : memref<1024 x 1024 x vector<64xf32>>
   %2 = alloc() : memref<1024 x 1024 x vector<64xf32>>
   affine.for %i = 0 to %N {
-  // expected-note@-1 {{parallel loop}}
+    // expected-remark@-1 {{parallel loop}}
     affine.for %j = 0 to %N {
-    // expected-note@-1 {{parallel loop}}
+      // expected-remark@-1 {{parallel loop}}
       affine.for %k = 0 to %N {
         %5 = load %0[%i, %k] : memref<1024x1024xvector<64xf32>>
         %6 = load %1[%k, %j] : memref<1024x1024xvector<64xf32>>
diff --git a/mlir/tools/mlir-opt/mlir-opt.cpp b/mlir/tools/mlir-opt/mlir-opt.cpp
index 71d01b21479..812dec9a8af 100644
--- a/mlir/tools/mlir-opt/mlir-opt.cpp
+++ b/mlir/tools/mlir-opt/mlir-opt.cpp
@@ -160,6 +160,8 @@ static StringRef getDiagnosticKindString(DiagnosticSeverity kind) {
     return "warning";
   case DiagnosticSeverity::Error:
     return "error";
+  case DiagnosticSeverity::Remark:
+    return "remark";
   }
 }
 
@@ -172,6 +174,8 @@ static llvm::SourceMgr::DiagKind getDiagKind(DiagnosticSeverity kind) {
     return llvm::SourceMgr::DK_Warning;
   case DiagnosticSeverity::Error:
     return llvm::SourceMgr::DK_Error;
+  case DiagnosticSeverity::Remark:
+    return llvm::SourceMgr::DK_Remark;
   }
 }
 
@@ -270,7 +274,7 @@ static OptResult processFile(std::unique_ptr<MemoryBuffer> ownedBuffer) {
   // error handler.
   // Extract the expected errors from the file.
   llvm::Regex expected(
-      "expected-(error|note|warning) *(@[+-][0-9]+)? *{{(.*)}}");
+      "expected-(error|note|remark|warning) *(@[+-][0-9]+)? *{{(.*)}}");
   SmallVector<StringRef, 100> lines;
   buffer.getBuffer().split(lines, '\n');
   for (unsigned lineNo = 0, e = lines.size(); lineNo < e; ++lineNo) {
@@ -284,6 +288,8 @@ static OptResult processFile(std::unique_ptr<MemoryBuffer> ownedBuffer) {
         kind = DiagnosticSeverity::Error;
       else if (matches[1] == "warning")
         kind = DiagnosticSeverity::Warning;
+      else if (matches[1] == "remark")
+        kind = DiagnosticSeverity::Remark;
       else {
         assert(matches[1] == "note");
         kind = DiagnosticSeverity::Note;