[mlir] Fix AsmPrinter for types with sub elements

[vinograd47]

Summary

Call printType(subElemType) instead of os << subElemType for them.
It allows to handle type aliases inside complex types.

As a side effect, fixed test.int parsing.

[mehdi_amini]

Nice! LGTM but I'd like River to have another look at it.
Thanks.

mlir/lib/IR/AsmPrinter.cpp

TypeSwitch<Type>(type)
         os << 'i' << integerTy.getWidth();
       })
       .Case<FunctionType>([&](FunctionType funcTy) {
         os << '(';
         interleaveComma(funcTy.getInputs(), [&](Type ty) { printType(ty); });
         os << ") -> ";
         ArrayRef<Type> results = funcTy.getResults();
         if (results.size() == 1 && !results[0].isa<FunctionType>()) {
-          os << results[0];
+          printType(results[0]);
         } else {
           os << '(';
           interleaveComma(results, [&](Type ty) { printType(ty); });
           os << ')';
         }
       })
       .Case<VectorType>([&](VectorType vectorTy) {
         os << "vector<";
         for (int64_t dim : vectorTy.getShape())
           os << dim << 'x';
-        os << vectorTy.getElementType() << '>';
+        printType(vectorTy.getElementType());
+        os << '>';
       })
       .Case<RankedTensorType>([&](RankedTensorType tensorTy) {
         os << "tensor<";
         for (int64_t dim : tensorTy.getShape()) {
           if (ShapedType::isDynamic(dim))
             os << '?';
           else
             os << dim;
           os << 'x';
         }
-        os << tensorTy.getElementType();
+        printType(tensorTy.getElementType());
         // Only print the encoding attribute value if set.
         if (tensorTy.getEncoding()) {
           os << ", ";
           printAttribute(tensorTy.getEncoding());
         }
         os << '>';
       })
       .Case<UnrankedTensorType>([&](UnrankedTensorType tensorTy) {

mlir/test/IR/print-attr-type-aliases.mlir

 "test.op"() {alias_test = "alias_test:large_tuple"} : () -> (tuple<i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32>)
 
 // CHECK-DAG: !test_tuple = type tuple<!test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla>
 "test.op"() {alias_test = "alias_test:large_tuple"} : () -> (tuple<!test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla, !test.smpla>)
 
 // CHECK-DAG: #test_encoding = "alias_test:tensor_encoding"
 // CHECK-DAG: tensor<32xf32, #test_encoding>
 "test.op"() : () -> tensor<32xf32, "alias_test:tensor_encoding">
+
+// CHECK-DAG: !test_ui8_ = type !test.int<unsigned, 8>
+// CHECK-DAG: tensor<32x!test_ui8_>
+"test.op"() : () -> tensor<32x!test.int<unsigned, 8>>

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

if (auto tupleType = type.dyn_cast<TupleType>()) {
       if (tupleType.size() > 0 &&
           llvm::all_of(tupleType.getTypes(), [](Type elemType) {
             return elemType.isa<SimpleAType>();
           })) {
         os << "test_tuple";
         return AliasResult::FinalAlias;
       }
     }
+    if (auto intType = type.dyn_cast<TestIntegerType>()) {
+      if (intType.getSignedness() ==
+              TestIntegerType::SignednessSemantics::Unsigned &&
+          intType.getWidth() == 8) {
+        os << "test_ui8";
+        return AliasResult::FinalAlias;
+      }
+    }
     return AliasResult::NoAlias;
   }
 
   void getAsmResultNames(Operation *op,
                          OpAsmSetValueNameFn setNameFn) const final {
     if (auto asmOp = dyn_cast<AsmDialectInterfaceOp>(op))
       setNameFn(asmOp, "result");
   }

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

 // Custom parser for SignednessSemantics.
 static ParseResult
 parseSignedness(DialectAsmParser &parser,
                 TestIntegerType::SignednessSemantics &result) {
   StringRef signStr;
   auto loc = parser.getCurrentLocation();
   if (parser.parseKeyword(&signStr))
     return failure();
-  if (signStr.compare_insensitive("u") ||
-      signStr.compare_insensitive("unsigned"))
+  if (signStr.equals_insensitive("u") || signStr.equals_insensitive("unsigned"))
     result = TestIntegerType::SignednessSemantics::Unsigned;
-  else if (signStr.compare_insensitive("s") ||
-           signStr.compare_insensitive("signed"))
+  else if (signStr.equals_insensitive("s") ||
+           signStr.equals_insensitive("signed"))
     result = TestIntegerType::SignednessSemantics::Signed;
-  else if (signStr.compare_insensitive("n") ||
-           signStr.compare_insensitive("none"))
+  else if (signStr.equals_insensitive("n") ||
+           signStr.equals_insensitive("none"))
     result = TestIntegerType::SignednessSemantics::Signless;
   else
     return parser.emitError(loc, "expected signed, unsigned, or none");
   return success();
 }
 
 // Custom printer for SignednessSemantics.
 static void printSignedness(DialectAsmPrinter &printer,

mlir/test/mlir-tblgen/testdialect-typedefs.mlir

 // RUN: mlir-opt %s | mlir-opt -verify-diagnostics | FileCheck %s
 
 //////////////
 // Tests the types in the 'Test' dialect, not the ones in 'typedefs.mlir'
 
 // CHECK: @simpleA(%arg0: !test.smpla)
 func @simpleA(%A : !test.smpla) -> () {
   return
 }
 
 // CHECK: @compoundA(%arg0: !test.cmpnd_a<1, !test.smpla, [5, 6]>)
 func @compoundA(%A : !test.cmpnd_a<1, !test.smpla, [5, 6]>)-> () {
   return
 }
 
-// CHECK: @testInt(%arg0: !test.int<unsigned, 8>, %arg1: !test.int<unsigned, 2>, %arg2: !test.int<unsigned, 1>)
+// CHECK: @testInt(%arg0: !test.int<signed, 8>, %arg1: !test.int<unsigned, 2>, %arg2: !test.int<none, 1>)
 func @testInt(%A : !test.int<s, 8>, %B : !test.int<unsigned, 2>, %C : !test.int<n, 1>) {
   return
 }
 
-// CHECK: @structTest(%arg0: !test.struct<{field1,!test.smpla},{field2,!test.int<unsigned, 3>}>)
+// CHECK: @structTest(%arg0: !test.struct<{field1,!test.smpla},{field2,!test.int<none, 3>}>)
 func @structTest (%A : !test.struct< {field1, !test.smpla}, {field2, !test.int<none, 3>} > ) {
   return
 }