Adding test attribute and test

Author: quartersdg

mlir/lib/AsmParser/Parser.cpp

@@ -308,13 +308,6 @@ OptionalParseResult Parser::parseOptionalInteger(APInt &result) {
   return success();
 }
 
-namespace {
-bool isBinOrHexOrOctIndicator(char c) {
-  return (llvm::toLower(c) == 'x' || llvm::toLower(c) == 'b' ||
-          llvm::isDigit(c));
-}
-} // namespace
-
 /// Parse an optional integer value only in decimal format from the stream.
 OptionalParseResult Parser::parseOptionalDecimalInteger(APInt &result) {
   Token curToken = getToken();
@@ -329,10 +322,11 @@ OptionalParseResult Parser::parseOptionalDecimalInteger(APInt &result) {
   }
 
   StringRef spelling = curTok.getSpelling();
-  // If the integer is in bin, hex, or oct format, return only the 0 and reset
-  // the lex pointer.
+  // If the integer is in hexadecimal return only the 0. The lexer has already
+  // moved past the entire hexidecimal encoded integer so we reset the lex
+  // pointer to just past the 0 we actualy want to consume.
   if (spelling[0] == '0' && spelling.size() > 1 &&
-      isBinOrHexOrOctIndicator(spelling[1])) {
+      llvm::toLower(spelling[1]) == 'x') {
     result = 0;
     state.lex.resetPointer(spelling.data() + 1);
     consumeToken();

mlir/test/lib/Dialect/Test/TestAttrDefs.td

@@ -81,6 +81,15 @@ def AttrWithTrait : Test_Attr<"AttrWithTrait", [TestAttrTrait]> {
   let mnemonic = "attr_with_trait";
 }
 
+// An attribute of decimal formatted integer.
+def TestDecimalIntegerAttr : Test_Attr<"TestDecimalInteger"> {
+  let mnemonic = "decimal_integer";
+
+  let parameters = (ins "int64_t":$value);
+
+  let hasCustomAssemblyFormat = 1;
+}
+
 // Test support for ElementsAttrInterface.
 def TestI64ElementsAttr : Test_Attr<"TestI64Elements", [ElementsAttrInterface]> {
   let mnemonic = "i64_elements";

mlir/test/lib/Dialect/Test/TestAttributes.cpp

@@ -13,9 +13,11 @@
 
 #include "TestAttributes.h"
 #include "TestDialect.h"
+#include "TestTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/ExtensibleDialect.h"
+#include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/Hashing.h"
@@ -63,6 +65,25 @@ void CompoundAAttr::print(AsmPrinter &printer) const {
 // CompoundAAttr
 //===----------------------------------------------------------------------===//
 
+
+Attribute TestDecimalIntegerAttr::parse(AsmParser &parser, Type type) {
+  if (parser.parseLess()){
+    return Attribute();
+  }
+  uint64_t intVal;
+  if (failed(*parser.parseOptionalDecimalInteger(intVal))) {
+    return Attribute();
+  }
+  if (parser.parseGreater()) {
+    return Attribute();
+  }
+  return get(parser.getContext(), intVal);
+}
+
+void TestDecimalIntegerAttr::print(AsmPrinter &printer) const {
+  printer << "<" << getValue() << ">";
+}
+
 Attribute TestI64ElementsAttr::parse(AsmParser &parser, Type type) {
   SmallVector<uint64_t> elements;
   if (parser.parseLess() || parser.parseLSquare())

mlir/test/mlir-tblgen/testdialect-attrdefs.mlir

@@ -1,4 +1,4 @@
-// RUN: mlir-opt %s | mlir-opt -verify-diagnostics | FileCheck %s
+// RUN: mlir-opt %s -split-input-file -verify-diagnostics | FileCheck %s
 
 // CHECK-LABEL: func private @compoundA()
 // CHECK-SAME: #test.cmpnd_a<1, !test.smpla, [5, 6]>
@@ -19,3 +19,16 @@ func.func private @qualifiedAttr() attributes {foo = #test.cmpnd_nested_outer_qu
 func.func private @overriddenAttr() attributes {
   foo = #test.override_builder<5>
 }
+
+// CHECK-LABEL: @decimalInteger
+// CHECK-SAME: foo = #test.decimal_integer<5>
+func.func private @decimalInteger() attributes {
+  foo = #test.decimal_integer<5>
+}
+
+// -----
+
+func.func private @hexdecimalInteger() attributes {
+// expected-error @below {{expected '>'}}
+  foo = #test.decimal_integer<0x5>
+}