[mlir][Index] Add pretty result names for ConstantOp and BoolConstantOp

[rriddle]

Summary

ConstantOp uses %idx<value> and BoolConstantOp uses true/false, which
is similar to the printing for arith::ConstantOp.

[lattner]

nice, thank you for this!

mlir/include/mlir/Dialect/Index/IR/IndexOps.h

 //===- IndexOps.h - Index operation declarations ------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_INDEX_IR_INDEXOPS_H
 #define MLIR_DIALECT_INDEX_IR_INDEXOPS_H
 
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpDefinition.h"
+#include "mlir/IR/OpImplementation.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 //===----------------------------------------------------------------------===//
 // Forward Declarations
 //===----------------------------------------------------------------------===//
 

mlir/include/mlir/Dialect/Index/IR/IndexOps.td

 //===- IndexOps.td - Index operation definitions -----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef INDEX_OPS
 #define INDEX_OPS
 
 include "mlir/Dialect/Index/IR/IndexDialect.td"
 include "mlir/Dialect/Index/IR/IndexEnums.td"
 include "mlir/Interfaces/CastInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
+include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/OpBase.td"
 
 //===----------------------------------------------------------------------===//
 // IndexOp
 //===----------------------------------------------------------------------===//
 
 /// Base class for Index dialect operations.
 class IndexOp<string mnemonic, list<Trait> traits = []>
def Index_SizeOfOp : IndexOp<"sizeof"> {
   let results = (outs Index:$result);
   let assemblyFormat = "attr-dict";
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
-def Index_ConstantOp : IndexOp<"constant", [ConstantLike]> {
+def Index_ConstantOp : IndexOp<"constant", [
+    ConstantLike,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>
+  ]> {
   let summary = "index constant";
   let description = [{
     The `index.constant` operation produces an index-typed SSA value equal to
     some index-typed integer constant.
 
     Example:
 
     ```mlir
     %0 = index.constant 42
     ```
   }];
 
   let arguments = (ins IndexAttr:$value);
   let results = (outs Index:$result);
   let assemblyFormat = "attr-dict $value";
   let hasFolder = 1;
 
   let builders = [OpBuilder<(ins "int64_t":$value)>];
 }
 
 //===----------------------------------------------------------------------===//
 // BoolConstantOp
 //===----------------------------------------------------------------------===//
 
-def Index_BoolConstantOp : IndexOp<"bool.constant", [ConstantLike]> {
+def Index_BoolConstantOp : IndexOp<"bool.constant", [
+    ConstantLike,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>
+  ]> {
   let summary = "boolean constant";
   let description = [{
     The `index.bool.constant` operation produces an bool-typed SSA value equal
     to either `true` or `false`.
 
     This operation is used to materialize bool constants that arise when folding
     `index.cmp`.
 

mlir/lib/Dialect/Index/IR/IndexOps.cpp

 //===- IndexOps.cpp - Index operation definitions --------------------------==//
 //
 // 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/Index/IR/IndexOps.h"
 #include "mlir/Dialect/Index/IR/IndexAttrs.h"
 #include "mlir/Dialect/Index/IR/IndexDialect.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/OpImplementation.h"
+#include "llvm/ADT/SmallString.h"
 
 using namespace mlir;
 using namespace mlir::index;
 
 //===----------------------------------------------------------------------===//
 // IndexDialect
 //===----------------------------------------------------------------------===//
 
if (result64 != result32)
     return {};
   return BoolAttr::get(getContext(), result64);
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
+void ConstantOp::getAsmResultNames(
+    function_ref<void(Value, StringRef)> setNameFn) {
+  llvm::SmallString<32> specialNameBuffer;
+  llvm::raw_svector_ostream specialName(specialNameBuffer);
+  specialName << "idx" << getValueAttr().getValue();
+  setNameFn(getResult(), specialName.str());
+}
+
 OpFoldResult ConstantOp::fold(ArrayRef<Attribute> operands) {
   return getValueAttr();
 }
 
 void ConstantOp::build(OpBuilder &b, OperationState &state, int64_t value) {
   build(b, state, b.getIndexType(), b.getIndexAttr(value));
 }
 
 //===----------------------------------------------------------------------===//
 // BoolConstantOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult BoolConstantOp::fold(ArrayRef<Attribute> operands) {
   return getValueAttr();
 }
 
+void BoolConstantOp::getAsmResultNames(
+    function_ref<void(Value, StringRef)> setNameFn) {
+  setNameFn(getResult(), getValue() ? "true" : "false");
+}
+
 //===----------------------------------------------------------------------===//
 // ODS-Generated Definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Index/IR/IndexOps.cpp.inc"

mlir/test/Dialect/Index/index-ops.mlir

 func.func @sizeof_op() {
   // CHECK: index.sizeof
   %0 = index.sizeof
   return
 }
 
 // CHECK-LABEL: @constant_op
 func.func @constant_op() {
-  // CHECK-NEXT: index.constant 0
+  // CHECK-NEXT: %idx0 = index.constant 0
   %0 = index.constant 0
-  // CHECK-NEXT: index.constant 1
+  // CHECK-NEXT: %idx1 = index.constant 1
   %1 = index.constant 1
-  // CHECK-NEXT: index.constant 42
+  // CHECK-NEXT: %idx42 = index.constant 42
   %2 = index.constant 42
   return
 }
 
 // CHECK-LABEL: @bool_constant_op
 func.func @bool_constant_op() {
-  // CHECK-NEXT: index.bool.constant true
+  // CHECK-NEXT: %true = index.bool.constant true
   %0 = index.bool.constant true
-  // CHECK-NEXT: index.bool.constant false
+  // CHECK-NEXT: %false = index.bool.constant false
   %1 = index.bool.constant false
   return
 }
 
 // CHECK-LABEL: @cast_op
 // CHECK-SAME: %[[A:.*]]: index, %[[B:.*]]: i32, %[[C:.*]]: i64
 func.func @cast_op(%a: index, %b: i32, %c: i64) {
   // CHECK-NEXT: index.casts %[[A]] : index to i64