[mlir][Affine] Minor clean-up of D79829

[dcaballe]

Summary

Addressing D79829 post-commit comments. Minor changes.

[rriddle]

Thanks!

mlir/include/mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h

 //===- AffineMemoryOpInterfaces.h -------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a set of interfaces for affine memory ops.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_INTERFACES_AFFINEMEMORYOPINTERFACES_H_
-#define MLIR_INTERFACES_AFFINEMEMORYOPINTERFACES_H_
+#ifndef MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPDIALECT_H_
+#define MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPDIALECT_H_
 
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
 
 namespace mlir {
 #include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h.inc"
 } // namespace mlir
 
-#endif // MLIR_INTERFACES_AFFINEMEMORYOPINTERFACES_H_
+#endif // MLIR_DIALECT_AFFINE_IR_AFFINEMEMORYOPDIALECT_H_

mlir/include/mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.td

 //===- AffineMemoryOpInterfaces.td -------------------------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a set of interfaces for affine memory ops.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_AFFINEMEMORYOPINTERFACES
-#define MLIR_AFFINEMEMORYOPINTERFACES
+#ifndef AFFINEMEMORYOPINTERFACES
+#define AFFINEMEMORYOPINTERFACES
 
 include "mlir/IR/OpBase.td"
 
 def AffineReadOpInterface : OpInterface<"AffineReadOpInterface"> {
   let description = [{
       Interface to query characteristics of read-like ops with affine
       restrictions.
   }];
 
   let methods = [
     InterfaceMethod<
-      /*desc=*/[{ Returns the memref operand to read from. }],
+      /*desc=*/"Returns the memref operand to read from.",
       /*retTy=*/"Value",
       /*methodName=*/"getMemRef",
       /*args=*/(ins),
       /*methodBody*/[{}],
       /*defaultImplementation=*/ [{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getOperand(op.getMemRefOperandIndex());
       }]
     >,
     InterfaceMethod<
-      /*desc=*/[{ Returns the type of the memref operand. }],
+      /*desc=*/"Returns the type of the memref operand.",
       /*retTy=*/"MemRefType",
       /*methodName=*/"getMemRefType",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getMemRef().getType().template cast<MemRefType>();
       }]
     >,
     InterfaceMethod<
-      /*desc=*/[{ Returns affine map operands. }],
+      /*desc=*/"Returns affine map operands.",
       /*retTy=*/"Operation::operand_range",
       /*methodName=*/"getMapOperands",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return llvm::drop_begin(op.getOperands(), 1);
       }]
     >,
     InterfaceMethod<
-      /*desc=*/[{ Returns the affine map used to index the memref for this
-                  operation. }],
+      /*desc=*/[{
+        Returns the affine map used to index the memref for this operation.
+      }],
       /*retTy=*/"AffineMap",
       /*methodName=*/"getAffineMap",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getAffineMapAttr().getValue();
       }]
     >,
   ];
 }
 
 def AffineWriteOpInterface : OpInterface<"AffineWriteOpInterface"> {
   let description = [{
       Interface to query characteristics of write-like ops with affine
       restrictions.
   }];
 
   let methods = [
     InterfaceMethod<
-      /*desc=*/[{ Returns the memref operand to write to. }],
+      /*desc=*/"Returns the memref operand to write to.",
       /*retTy=*/"Value",
       /*methodName=*/"getMemRef",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getOperand(op.getMemRefOperandIndex());
       }]
     >,
     InterfaceMethod<
-      /*desc=*/[{ Returns the type of the memref operand. }],
+      /*desc=*/"Returns the type of the memref operand.",
       /*retTy=*/"MemRefType",
       /*methodName=*/"getMemRefType",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getMemRef().getType().template cast<MemRefType>();
       }]
     >,
     InterfaceMethod<
-      /*desc=*/[{ Returns affine map operands. }],
+      /*desc=*/"Returns affine map operands.",
       /*retTy=*/"Operation::operand_range",
       /*methodName=*/"getMapOperands",
       /*args=*/(ins),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return llvm::drop_begin(op.getOperands(), 2);
       }]
     >,
     InterfaceMethod<
-      /*desc=*/[{ Returns the affine map used to index the memref for this
-                  operation. }],
+      /*desc=*/[{
+        Returns the affine map used to index the memref for this operation.
+      }],
       /*retTy=*/"AffineMap",
       /*methodName=*/"getAffineMap",
       /*args=*/(ins),
       /*methodName=*/[{}],
       /*defaultImplementation=*/[{
         ConcreteOp op = cast<ConcreteOp>(this->getOperation());
         return op.getAffineMapAttr().getValue();
       }]
     >,
   ];
 }
 
-#endif // MLIR_AFFINEMEMORYOPINTERFACES
+#endif // AFFINEMEMORYOPINTERFACES

mlir/include/mlir/Dialect/Affine/IR/CMakeLists.txt

 add_mlir_dialect(AffineOps affine)
 add_mlir_doc(AffineOps -gen-op-doc AffineOps Dialects/)
 
-set(LLVM_TARGET_DEFINITIONS AffineMemoryOpInterfaces.td)
-mlir_tablegen(AffineMemoryOpInterfaces.h.inc -gen-op-interface-decls)
-mlir_tablegen(AffineMemoryOpInterfaces.cpp.inc -gen-op-interface-defs)
-add_public_tablegen_target(MLIRAffineMemoryOpInterfacesIncGen)
-add_dependencies(mlir-generic-headers MLIRAffineMemoryOpInterfacesIncGen)
-
+add_mlir_interface(AffineMemoryOpInterfaces)
 add_dependencies(MLIRAffineOpsIncGen MLIRAffineMemoryOpInterfacesIncGen)

mlir/lib/Analysis/AffineAnalysis.cpp

static void computeDirectionVector(
   }
 }
 
 // Populates 'accessMap' with composition of AffineApplyOps reachable from
 // indices of MemRefAccess.
 void MemRefAccess::getAccessMap(AffineValueMap *accessMap) const {
   // Get affine map from AffineLoad/Store.
   AffineMap map;
-  if (auto loadOp = dyn_cast<AffineReadOpInterface>(opInst)) {
+  if (auto loadOp = dyn_cast<AffineReadOpInterface>(opInst))
     map = loadOp.getAffineMap();
-  } else {
-    auto storeOp = cast<AffineWriteOpInterface>(opInst);
-    map = storeOp.getAffineMap();
-  }
+  else
+    map = cast<AffineWriteOpInterface>(opInst).getAffineMap();
+
   SmallVector<Value, 8> operands(indices.begin(), indices.end());
   fullyComposeAffineMapAndOperands(&map, &operands);
   map = simplifyAffineMap(map);
   canonicalizeMapAndOperands(&map, &operands);
   accessMap->reset(map, operands);
 }
 
 // Builds a flat affine constraint system to check if there exists a dependence

mlir/lib/Dialect/Affine/IR/AffineMemoryOpInterfaces.cpp

-//===- AffineMemoryOpInterfaces.cpp - Loop-like operations in MLIR --------===//
+//===- AffineMemoryOpInterfaces.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Affine/IR/AffineMemoryOpInterfaces.h"