[mlir] Remove the `type` keyword from type alias definitions

[rriddle]

Summary

This was carry over from LLVM IR where the alias definition can
be ambiguous, but MLIR type aliases have no such problems.
Having the type keyword is superfluous and doesn't add anything.
This commit drops it, which also nicely aligns with the syntax for
attribute aliases (which doesn't have a keyword).

[rriddle]

mlir/utils/tree-sitter-mlir/grammar.js

10–13

Looks like clang-format got a little trigger happy here, will revert the unrelated changes.

[aartbik]

LGTM for sparse

flang/include/flang/Optimizer/Dialect/FIROps.td

 def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
   let summary = "generate a type descriptor for a given type";
   let description = [{
     Generates a constant object that is an abstract type descriptor of the
     specified type.  The meta-type of a type descriptor for the type `T`
     is `!fir.tdesc<T>`.
 
     ```mlir
-      !T = type !fir.type<T{...}>
+      !T = !fir.type<T{...}>
       %t = fir.gentypedesc !T  // returns value of !fir.tdesc<!T>
     ```
   }];
 
   let arguments = (ins FortranTypeAttr:$in_type);
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;

flang/test/Fir/affine-promotion.fir

 // Test affine promotion pass
 
 // RUN: fir-opt --split-input-file --promote-to-affine --affine-loop-invariant-code-motion --cse %s | FileCheck %s
 
-!arr_d1 = type !fir.ref<!fir.array<?xf32>>
+!arr_d1 = !fir.ref<!fir.array<?xf32>>
 #arr_len = affine_map<()[j1,k1] -> (k1 - j1 + 1)>
 
 func.func @loop_with_load_and_store(%a1: !arr_d1, %a2: !arr_d1, %a3: !arr_d1) {
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %len = arith.constant 100 : index
   %dims = fir.shape %len : (index) -> !fir.shape<1>
   %siz = affine.apply #arr_len()[%c1,%len]

 // CHECK:      %[[VAL_21:.*]] = arith.mulf %[[VAL_19]], %[[VAL_20]] : f32
 // CHECK:      affine.store %[[VAL_21]], %[[VAL_16]]{{\[}}%[[VAL_18]]] : memref<?xf32>
 // CHECK:    }
 // CHECK:    return
 // CHECK:  }
 
 // -----
 
-!arr_d1 = type !fir.ref<!fir.array<?xf32>>
+!arr_d1 = !fir.ref<!fir.array<?xf32>>
 #arr_len = affine_map<()[j1,k1] -> (k1 - j1 + 1)>
 
 func.func @loop_with_if(%a: !arr_d1, %v: f32) {
   %c0 = arith.constant 0 : index
   %c1 = arith.constant 1 : index
   %c2 = arith.constant 2 : index
   %len = arith.constant 100 : index
   %dims = fir.shape %len : (index) -> !fir.shape<1>

flang/test/Fir/array-value-copy-3.fir

 // Test overlapping assignment of derived type arrays with allocatable components.
 // This requires initializing the allocatable components to an unallocated status
 // before they can be used in component assignments, and to deallocate the components
 // that may have been allocated in the end.
 
 // RUN: fir-opt --array-value-copy %s | FileCheck %s
 
 
-!t_with_alloc_comp = type !fir.type<t{i:!fir.box<!fir.heap<!fir.array<?xi32>>>}>
+!t_with_alloc_comp = !fir.type<t{i:!fir.box<!fir.heap<!fir.array<?xi32>>>}>
 func.func private @custom_assign(!fir.ref<!t_with_alloc_comp>, !fir.ref<!t_with_alloc_comp>)
 func.func @test_overlap_with_alloc_components(%arg0: !fir.ref<!fir.array<10x!t_with_alloc_comp>>) {
   %0 = fir.alloca !fir.box<!t_with_alloc_comp>
   %c10 = arith.constant 10 : index
   %c9 = arith.constant 9 : index
   %c1 = arith.constant 1 : index
   %c-1 = arith.constant -1 : index
   %c0 = arith.constant 0 : index

flang/test/Fir/ignore-missing-type-descriptor.fir

 // Test the option to avoid failing if derived type descriptors are not found.
 // This is a debug option to allow manually writing derived type fir.embox without
 // having to care with providing an ABI compliant derived type descriptor object.
 // Missing derived type descriptor pointers are replaced by null pointers.
 // RUN: tco --ignore-missing-type-desc -o - %s | FileCheck %s
 
-!some_freestyle_type = type !fir.type<some_not_mangled_type{j:i32}>
+!some_freestyle_type = !fir.type<some_not_mangled_type{j:i32}>
 
 func.func private @bar(!fir.box<!some_freestyle_type>)
 
 func.func @test_embox(%addr: !fir.ref<!some_freestyle_type>) {
   %0 = fir.embox %addr : (!fir.ref<!some_freestyle_type>) -> !fir.box<!some_freestyle_type>
   fir.call @bar(%0) : (!fir.box<!some_freestyle_type>) -> ()
   return
 }
 // CHECK-LABEL: define void @test_embox(
 // CHECK-SAME: %some_not_mangled_type* %[[ADDR:.*]])
 // CHECK: insertvalue { %some_not_mangled_type*, i64, i32, i8, i8, i8, i8, i8*, [1 x i64] }
 // CHECK-SAME: { %some_not_mangled_type* undef, i64 ptrtoint (%some_not_mangled_type* getelementptr (%some_not_mangled_type, %some_not_mangled_type* null, i32 1) to i64),
 // CHECK-SAME: i32 20180515, i8 0, i8 42, i8 0, i8 1, i8* null, [1 x i64] undef },
 // CHECK-SAME: %some_not_mangled_type* %[[ADDR]], 0,

flang/test/Fir/recursive-type.fir

 // Test lowering FIR to LLVM IR for recursive types
   
 // RUN: fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s | FileCheck %s
 // RUN: fir-opt --fir-to-llvm-ir="target=aarch64-unknown-linux-gnu" %s | FileCheck %s
 // RUN: fir-opt --fir-to-llvm-ir="target=i386-unknown-linux-gnu" %s | FileCheck %s
 // RUN: fir-opt --fir-to-llvm-ir="target=powerpc64le-unknown-linux-gn" %s | FileCheck %s
 
-!t1 = type !fir.type<t1 {a1:!fir.ptr<!fir.type<t1>>}>
-!t2 = type !fir.type<t2 {b1:f32,b2:!fir.ptr<!fir.type<t2>>,b3:i32,b4:!fir.ptr<!fir.type<t2>>}>
-!t3 = type !fir.type<t3 {c1:!fir.ptr<!fir.type<t4>>}>
-!t4 = type !fir.type<t4 {d1:!fir.ptr<!fir.type<t3>>}>
+!t1 = !fir.type<t1 {a1:!fir.ptr<!fir.type<t1>>}>
+!t2 = !fir.type<t2 {b1:f32,b2:!fir.ptr<!fir.type<t2>>,b3:i32,b4:!fir.ptr<!fir.type<t2>>}>
+!t3 = !fir.type<t3 {c1:!fir.ptr<!fir.type<t4>>}>
+!t4 = !fir.type<t4 {d1:!fir.ptr<!fir.type<t3>>}>
 
 // CHECK-LABEL: llvm.func @recursiveTypes
 // CHECK-SAME: %{{.*}}: !llvm.struct<"[[T1:.*]]", (ptr<struct<"[[T1]]">>)>
 // CHECK-SAME: %{{.*}}: !llvm.struct<"[[T2:.*]]", (f32, ptr<struct<"[[T2]]">>, i32, ptr<struct<"[[T2]]">>)>
 // CHECK-SAME: %{{.*}}: !llvm.struct<"[[T3:.*]]", (ptr<struct<"[[T4:.*]]", (ptr<struct<"[[T3]]">>)>>)>, %{{.*}}: !llvm.struct<"[[T4]]", (ptr<struct<"[[T3]]", (ptr<struct<"[[T4]]">>)>>)>)
 func.func @recursiveTypes(%a : !t1, %b : !t2, %c : !t3, %d : !t4) {
   return
 }

mlir/docs/LangRef.md

 ssa-use-and-type-list ::= ssa-use-and-type (`,` ssa-use-and-type)*
 
 function-type ::= (type | type-list-parens) `->` (type | type-list-parens)
 ```
 
 ### Type Aliases
 
 ```
-type-alias-def ::= '!' alias-name '=' 'type' type
+type-alias-def ::= '!' alias-name '=' type
 type-alias ::= '!' alias-name
 ```
 
 MLIR supports defining named aliases for types. A type alias is an identifier
 that can be used in the place of the type that it defines. These aliases *must*
 be defined before their uses. Alias names may not contain a '.', since those
 names are reserved for [dialect types](#dialect-types).
 
 Example:
 
 ```mlir
-!avx_m128 = type vector<4 x f32>
+!avx_m128 = vector<4 x f32>
 
 // Using the original type.
 "foo"(%x) : vector<4 x f32> -> ()
 
 // Using the type alias.
 "foo"(%x) : !avx_m128 -> ()
 ```
 

mlir/docs/TargetLLVMIR.md

 ```mlir
 func.func @foo(%arg0: memref<?xf32>) -> () {
   "use"(%arg0) : (memref<?xf32>) -> ()
   return
 }
 
 // Gets converted to the following
 // (using type alias for brevity):
-!llvm.memref_1d = type !llvm.struct<(ptr<f32>, ptr<f32>, i64,
-                                     array<1xi64>, array<1xi64>)>
+!llvm.memref_1d = !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1xi64>, array<1xi64>)>
 
 llvm.func @foo(%arg0: !llvm.ptr<f32>,  // Allocated pointer.
                %arg1: !llvm.ptr<f32>,  // Aligned pointer.
                %arg2: i64,             // Offset.
                %arg3: i64,             // Size in dim 0.
                %arg4: i64) {           // Stride in dim 0.
   // Populate memref descriptor structure.
   %0 = llvm.mlir.undef :

 func.func @bar() {
   %0 = "get"() : () -> (memref<?xf32>)
   call @foo(%0) : (memref<?xf32>) -> ()
   return
 }
 
 // Gets converted to the following
 // (using type alias for brevity):
-!llvm.memref_1d = type !llvm.struct<(ptr<f32>, ptr<f32>, i64,
-                                     array<1xi64>, array<1xi64>)>
+!llvm.memref_1d = !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1xi64>, array<1xi64>)>
 
 llvm.func @bar() {
   %0 = "get"() : () -> !llvm.memref_1d
 
   // Unpack the memref descriptor.
   %1 = llvm.extractvalue %0[0] : !llvm.memref_1d
   %2 = llvm.extractvalue %0[1] : !llvm.memref_1d
   %3 = llvm.extractvalue %0[2] : !llvm.memref_1d

 Examples:
 
 ```mlir
 
 func.func @qux(%arg0: memref<?x?xf32>)
 
 // Gets converted into the following
 // (using type alias for brevity):
-!llvm.memref_2d = type !llvm.struct<(ptr<f32>, ptr<f32>, i64,
-                                     array<2xi64>, array<2xi64>)>
+!llvm.memref_2d = !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2xi64>, array<2xi64>)>
 
 // Function with unpacked arguments.
 llvm.func @qux(%arg0: !llvm.ptr<f32>, %arg1: !llvm.ptr<f32>,
                %arg2: i64, %arg3: i64, %arg4: i64,
                %arg5: i64, %arg6: i64) {
   // Populate memref descriptor (as per calling convention).
   %0 = llvm.mlir.undef : !llvm.memref_2d
   %1 = llvm.insertvalue %arg0, %0[0] : !llvm.memref_2d

 
 ```mlir
 func.func @foo(%arg0: memref<?x?xf32>) {
   return
 }
 
 // Gets converted into the following
 // (using type alias for brevity):
-!llvm.memref_2d = type !llvm.struct<(ptr<f32>, ptr<f32>, i64,
-                                     array<2xi64>, array<2xi64>)>
-!llvm.memref_2d_ptr = type !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64,
-                                             array<2xi64>, array<2xi64>)>>
+!llvm.memref_2d = !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2xi64>, array<2xi64>)>
+!llvm.memref_2d_ptr = !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<2xi64>, array<2xi64>)>>
 
 // Function with unpacked arguments.
 llvm.func @foo(%arg0: !llvm.ptr<f32>, %arg1: !llvm.ptr<f32>,
                %arg2: i64, %arg3: i64, %arg4: i64,
                %arg5: i64, %arg6: i64) {
   llvm.return
 }
 

 
 ```mlir
 func.func @foo(%arg0: memref<?x?xf32>) -> memref<?x?xf32> {
   return %arg0 : memref<?x?xf32>
 }
 
 // Gets converted into the following
 // (using type alias for brevity):
-!llvm.memref_2d = type !llvm.struct<(ptr<f32>, ptr<f32>, i64,
-                                     array<2xi64>, array<2xi64>)>
-!llvm.memref_2d_ptr = type !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64,
-                                             array<2xi64>, array<2xi64>)>>
+!llvm.memref_2d = !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2xi64>, array<2xi64>)>
+!llvm.memref_2d_ptr = !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<2xi64>, array<2xi64>)>>
 
 // Function with unpacked arguments.
 llvm.func @foo(%arg0: !llvm.ptr<f32>, %arg1: !llvm.ptr<f32>, %arg2: i64,
                %arg3: i64, %arg4: i64, %arg5: i64, %arg6: i64)
     -> !llvm.memref_2d {
   %0 = llvm.mlir.undef : !llvm.memref_2d
   %1 = llvm.insertvalue %arg0, %0[0] : !llvm.memref_2d
   %2 = llvm.insertvalue %arg1, %1[1] : !llvm.memref_2d

mlir/lib/IR/AsmPrinter.cpp

auto filterFn = [=](const auto &aliasIt) {
     return aliasIt.second.canBeDeferred() == isDeferred;
   };
   for (const auto &it : llvm::make_filter_range(attrToAlias, filterFn)) {
     it.second.print(os << '#');
     os << " = " << it.first << newLine;
   }
   for (const auto &it : llvm::make_filter_range(typeToAlias, filterFn)) {
     it.second.print(os << '!');
-    os << " = type " << it.first << newLine;
+    os << " = " << it.first << newLine;
   }
 }
 
 //===----------------------------------------------------------------------===//
 // SSANameState
 //===----------------------------------------------------------------------===//
 
 namespace {

mlir/lib/Parser/Parser.cpp

if (!attr)
     return failure();
 
   state.symbols.attributeAliasDefinitions[aliasName] = attr;
   return success();
 }
 
 /// Parse a type alias declaration.
 ///
-///   type-alias-def ::= '!' alias-name `=` 'type' type
+///   type-alias-def ::= '!' alias-name `=` type
 ///
 ParseResult TopLevelOperationParser::parseTypeAliasDef() {
   assert(getToken().is(Token::exclamation_identifier));
   StringRef aliasName = getTokenSpelling().drop_front();
 
   // Check for redefinitions.
   if (state.symbols.typeAliasDefinitions.count(aliasName) > 0)
     return emitError("redefinition of type alias id '" + aliasName + "'");
 
   // Make sure this isn't invading the dialect type namespace.
   if (aliasName.contains('.'))
     return emitError("type names with a '.' are reserved for "
                      "dialect-defined names");
-
   consumeToken(Token::exclamation_identifier);
 
-  // Parse the '=' and 'type'.
-  if (parseToken(Token::equal, "expected '=' in type alias definition") ||
-      parseToken(Token::kw_type, "expected 'type' in type alias definition"))
+  // Parse the '='.
+  if (parseToken(Token::equal, "expected '=' in type alias definition"))
     return failure();
 
   // Parse the type.
   Type aliasedType = parseType();
   if (!aliasedType)
     return failure();
 
   // Register this alias with the parser state.

mlir/test/Conversion/FuncToLLVM/func-memref.mlir

 func.func @check_scalar_func_call(%in : f32) {
   // BAREPTR-NEXT:    %[[call:.*]] = llvm.call @goo(%[[in]]) : (f32) -> f32
   %res = call @goo(%in) : (f32) -> (f32)
   return
 }
 
 // -----
 
-!base_type = type memref<64xi32, 201>
+!base_type = memref<64xi32, 201>
 
 // CHECK-LABEL: func @loop_carried
 // BAREPTR-LABEL: func @loop_carried
 func.func @loop_carried(%arg0 : index, %arg1 : index, %arg2 : index, %base0 : !base_type, %base1 : !base_type) -> (!base_type, !base_type) {
   // This test checks that in the BAREPTR case, the branch arguments only forward the descriptor.
   // This test was lowered from a simple scf.for that swaps 2 memref iter_args.
   //      BAREPTR: llvm.br ^bb1(%{{.*}}, %{{.*}}, %{{.*}} : i64, !llvm.struct<(ptr<i32, 201>, ptr<i32, 201>, i64, array<1 x i64>, array<1 x i64>)>, !llvm.struct<(ptr<i32, 201>, ptr<i32, 201>, i64, array<1 x i64>, array<1 x i64>)>)
   cf.br ^bb1(%arg0, %base0, %base1 : index, memref<64xi32, 201>, memref<64xi32, 201>)

mlir/test/Dialect/LLVMIR/types.mlir

 
 // -----
 
 // Check that type aliases can be used inside LLVM dialect types. Note that
 // currently they are _not_ printed back as this would require
 // DialectAsmPrinter to have a mechanism for querying the presence and
 // usability of an alias outside of its `printType` method.
 
-!baz = type i64
-!qux = type !llvm.struct<(!baz)>
+!baz = i64
+!qux = !llvm.struct<(!baz)>
 
-!rec = type !llvm.struct<"a", (ptr<struct<"a">>)>
+!rec = !llvm.struct<"a", (ptr<struct<"a">>)>
 
 // CHECK: aliases
 llvm.func @aliases() {
   // CHECK: !llvm.struct<(i32, f32, struct<(i64)>)>
   "some.op"() : () -> !llvm.struct<(i32, f32, !qux)>
   // CHECK: !llvm.struct<"a", (ptr<struct<"a">>)>
   "some.op"() : () -> !rec
   llvm.return
 }

mlir/test/Dialect/Linalg/standard.mlir

#matmul_accesses = [
   affine_map<(m, n, k) -> (m, n)>
 ]
 #matmul_trait = {
   iterator_types = ["parallel", "parallel", "reduction"],
   indexing_maps = #matmul_accesses,
   library_call = "external_outerproduct_matmul"
 }
 
-!vector_type_A = type vector<4xf32>
-!vector_type_B = type vector<4xf32>
-!vector_type_C = type vector<4x4xf32>
-
-!matrix_type_A = type memref<?x?x!vector_type_A>
-!matrix_type_B = type memref<?x?x!vector_type_B>
-!matrix_type_C = type memref<?x?x!vector_type_C>
+!vector_type_A = vector<4xf32>
+!vector_type_B = vector<4xf32>
+!vector_type_C = vector<4x4xf32>
+
+!matrix_type_A = memref<?x?x!vector_type_A>
+!matrix_type_B = memref<?x?x!vector_type_B>
+!matrix_type_C = memref<?x?x!vector_type_C>
 
 func.func @matmul_vec_impl(%A: !matrix_type_A, %B: !matrix_type_B, %C: !matrix_type_C) {
   linalg.generic #matmul_trait
       ins(%A, %B : !matrix_type_A, !matrix_type_B)
      outs(%C : !matrix_type_C) {
     ^bb0(%a: !vector_type_A, %b: !vector_type_B, %c: !vector_type_C):
       %d = vector.outerproduct %a, %b, %c: !vector_type_A, !vector_type_B
       linalg.yield %d: !vector_type_C
   }
   return
 }
 // CHECK-LABEL: func @matmul_vec_impl(
 // CHECK:  call @external_outerproduct_matmul(%{{.*}}) :

mlir/test/Dialect/Quant/parse-any-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // -----
 // Unrecognized token: missing storage type maximum
 // expected-error@+1 {{expected ':'}}
-!qalias = type !quant.any<i8<16>:f32>
+!qalias = !quant.any<i8<16>:f32>
 
 // -----
 // Unrecognized token: missing closing angle bracket
 // expected-error@+1 {{expected '>'}}
-!qalias = type !quant<"any<i8<-4:3:f32>">
+!qalias = !quant<"any<i8<-4:3:f32>">
 
 // -----
 // Unrecognized token: missing type colon
 // expected-error@+1 {{expected '>'}}
-!qalias = type !quant.any<i8<-4:3>f32>
+!qalias = !quant.any<i8<-4:3>f32>
 
 // -----
 // Unrecognized storage type: illegal prefix
 // expected-error@+1 {{illegal storage type prefix}}
-!qalias = type !quant.any<int8<-4:3>:f32>
+!qalias = !quant.any<int8<-4:3>:f32>
 
 // -----
 // Unrecognized storage type: no width
 // expected-error@+1 {{illegal storage type prefix}}
-!qalias = type !quant.any<i<-4:3>:f32>
+!qalias = !quant.any<i<-4:3>:f32>
 
 // -----
 // Unrecognized storage type: storage size > 32
 // expected-error@+1 {{illegal storage type size: 33}}
-!qalias = type !quant.any<i33:f32>
+!qalias = !quant.any<i33:f32>
 
 // -----
 // Unrecognized storage type: storage size < 0
 // expected-error@+1 {{illegal storage type size: 1024}}
-!qalias = type !quant.any<i1024<-4:3>:f32>
+!qalias = !quant.any<i1024<-4:3>:f32>
 
 // -----
 // Unrecognized storage type: storage size
 // expected-error@+1 {{invalid integer width}}
-!qalias = type !quant.any<i0123123123123123<-4:3>:f32>
+!qalias = !quant.any<i0123123123123123<-4:3>:f32>
 
 // -----
 // Illegal storage min/max: max - min < 0
 // expected-error@+1 {{illegal storage min and storage max: (2:1)}}
-!qalias = type !quant.any<i8<2:1>:f32>
+!qalias = !quant.any<i8<2:1>:f32>
 
 // -----
 // Illegal storage min/max: max - min == 0
 // expected-error@+1 {{illegal storage min and storage max: (1:1)}}
-!qalias = type !quant.any<i8<1:1>:f32>
+!qalias = !quant.any<i8<1:1>:f32>
 
 // -----
 // Illegal storage min/max: max > defaultMax
 // expected-error@+1 {{illegal storage type maximum: 9}}
-!qalias = type !quant.any<i4<-1:9>:f32>
+!qalias = !quant.any<i4<-1:9>:f32>
 
 // -----
 // Illegal storage min/max: min < defaultMin
 // expected-error@+1 {{illegal storage type minimum: -9}}
-!qalias = type !quant.any<i4<-9:1>:f32>
+!qalias = !quant.any<i4<-9:1>:f32>

mlir/test/Dialect/Quant/parse-any.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file | FileCheck %s
 
 // -----
 // CHECK-LABEL: parseFullySpecified
 // CHECK: !quant.any<i8<-8:7>:f32>
-!qalias = type !quant.any<i8<-8:7>:f32>
+!qalias = !quant.any<i8<-8:7>:f32>
 func.func @parseFullySpecified() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // CHECK-LABEL: parseNoExpressedType
 // CHECK: !quant.any<i8<-8:7>>
-!qalias = type !quant.any<i8<-8:7>>
+!qalias = !quant.any<i8<-8:7>>
 func.func @parseNoExpressedType() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // CHECK-LABEL: parseOnlyStorageType
 // CHECK: !quant.any<i8>
-!qalias = type !quant.any<i8>
+!qalias = !quant.any<i8>
 func.func @parseOnlyStorageType() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }

mlir/test/Dialect/Quant/parse-calibrated-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // -----
 // Unrecognized token: missing calibrated type maximum
 // expected-error@+2 {{calibrated values must be present}}
 // expected-error@+1 {{expected ':'}}
-!qalias = type !quant.calibrated<f32<-0.998>>
+!qalias = !quant.calibrated<f32<-0.998>>
 
 // -----
 // Unrecognized token: missing closing angle bracket
 // expected-error@+1 {{expected '>'}}
-!qalias = type !quant<"calibrated<f32<-0.998:1.232>">
+!qalias = !quant<"calibrated<f32<-0.998:1.232>">
 
 // -----
 // Unrecognized expressed type: integer type
 // expected-error@+2 {{invalid kind of type specified}}
 // expected-error@+1 {{expecting float expressed type}}
-!qalias = type !quant.calibrated<i8<-4:3>>
+!qalias = !quant.calibrated<i8<-4:3>>
 
 // -----
 // Illegal storage min/max: max - min < 0
 // expected-error@+1 {{illegal min and max: (1.000000e+00:-1.000000e+00)}}
-!qalias = type !quant.calibrated<f32<1.0:-1.0>>
+!qalias = !quant.calibrated<f32<1.0:-1.0>>
 
 // -----
 // Illegal storage min/max: max - min == 0
 // expected-error@+1 {{illegal min and max: (1.000000e+00:1.000000e+00)}}
-!qalias = type !quant.calibrated<f32<1.0:1.0>>
+!qalias = !quant.calibrated<f32<1.0:1.0>>

mlir/test/Dialect/Quant/parse-calibrated.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file | FileCheck %s
 
 // -----
 // CHECK-LABEL: parseCalibrated
 // CHECK: !quant.calibrated<f32<-0.998:1.232100e+00>
-!qalias = type !quant.calibrated<f32<-0.998:1.2321>>
+!qalias = !quant.calibrated<f32<-0.998:1.2321>>
 func.func @parseCalibrated() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }

mlir/test/Dialect/Quant/parse-uniform-invalid.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // -----
 // Invalid type.
 // expected-error@+1 {{unknown quantized type foobar}}
-!qalias = type !quant.foobar
+!qalias = !quant.foobar
 
 // -----
 // Unrecognized token: illegal token
 // expected-error@+1 {{unknown quantized type __}}
-!qalias = type !quant.__
+!qalias = !quant.__
 
 // -----
 // Unrecognized token: trailing
 // expected-error@+1 {{expected '>'}}
-!qalias = type !quant.uniform<i8<-4:3>:f32, 0.99872:127 23>
+!qalias = !quant.uniform<i8<-4:3>:f32, 0.99872:127 23>
 
 // -----
 // Unrecognized token: missing storage type maximum
 // expected-error@+1 {{expected ':'}}
-!qalias = type !quant.uniform<i8<16>:f32, 0.99872:127>
+!qalias = !quant.uniform<i8<16>:f32, 0.99872:127>
 
 // -----
 // Unrecognized token: missing closing angle bracket
 // expected-error@+1 {{expected '>'}}
-!qalias = type !quant<"uniform<i8<-4:3:f32, 0.99872:127>">
+!qalias = !quant<"uniform<i8<-4:3:f32, 0.99872:127>">
 
 // -----
 // Unrecognized token: missing type colon
 // expected-error@+1 {{expected ':'}}
-!qalias = type !quant.uniform<i8<-4:3>f32, 0.99872:127>
+!qalias = !quant.uniform<i8<-4:3>f32, 0.99872:127>
 
 // -----
 // Unrecognized token: missing comma
 // expected-error@+1 {{expected ','}}
-!qalias = type !quant.uniform<i8<-4:3>:f32 0.99872:127>
+!qalias = !quant.uniform<i8<-4:3>:f32 0.99872:127>
 
 // -----
 // Unrecognized storage type: illegal prefix
 // expected-error@+1 {{illegal storage type prefix}}
-!qalias = type !quant.uniform<int8<-4:3>:f32, 0.99872:127>
+!qalias = !quant.uniform<int8<-4:3>:f32, 0.99872:127>
 
 // -----
 // Unrecognized storage type: no width
 // expected-error@+1 {{illegal storage type prefix}}
-!qalias = type !quant.uniform<i<-4:3>:f32, 0.99872:127>
+!qalias = !quant.uniform<i<-4:3>:f32, 0.99872:127>
 
 // -----
 // Unrecognized storage type: storage size > 32
 // expected-error@+1 {{illegal storage type size: 33}}
-!qalias = type !quant.uniform<i33:f32, 0.99872:127>
+!qalias = !quant.uniform<i33:f32, 0.99872:127>
 
 // -----
 // Unrecognized storage type: storage size < 0
 // expected-error@+1 {{illegal storage type prefix}}
-!qalias = type !quant.uniform<i-1<-4:3>:f32, 0.99872:127>
+!qalias = !quant.uniform<i-1<-4:3>:f32, 0.99872:127>
 
 // -----
 // Unrecognized storage type: storage size
 // expected-error@+1 {{invalid integer width}}
-!qalias = type !quant.uniform<i123123123120<-4:3>:f32, 0.99872:127>
+!qalias = !quant.uniform<i123123123120<-4:3>:f32, 0.99872:127>
 
 // -----
 // Illegal storage min/max: max - min < 0
 // expected-error@+1 {{illegal storage min and storage max: (2:1)}}
-!qalias = type !quant.uniform<i8<2:1>:f32, 0.99872:127>
+!qalias = !quant.uniform<i8<2:1>:f32, 0.99872:127>
 
 // -----
 // Illegal storage min/max: max - min == 0
 // expected-error@+1 {{illegal storage min and storage max: (1:1)}}
-!qalias = type !quant.uniform<i8<1:1>:f32, 0.99872:127>
+!qalias = !quant.uniform<i8<1:1>:f32, 0.99872:127>
 
 // -----
 // Illegal storage min/max: max > defaultMax
 // expected-error@+1 {{illegal storage type maximum: 9}}
-!qalias = type !quant.uniform<i4<-1:9>:f32, 0.99872:127>
+!qalias = !quant.uniform<i4<-1:9>:f32, 0.99872:127>
 
 // -----
 // Illegal storage min/max: min < defaultMin
 // expected-error@+1 {{illegal storage type minimum: -9}}
-!qalias = type !quant.uniform<i4<-9:1>:f32, 0.99872:127>
+!qalias = !quant.uniform<i4<-9:1>:f32, 0.99872:127>
 
 // -----
 // Illegal uniform params: invalid scale
 // expected-error@+1 {{expected floating point literal}}
-!qalias = type !quant.uniform<i8<-4:3>:f32, abc:127>
+!qalias = !quant.uniform<i8<-4:3>:f32, abc:127>
 
 // -----
 // Illegal uniform params: invalid zero point separator
 // expected-error@+1 {{expected '>'}}
-!qalias = type !quant.uniform<i8<-4:3>:f32, 0.1abc>
+!qalias = !quant.uniform<i8<-4:3>:f32, 0.1abc>
 
 // -----
 // Illegal uniform params: missing zero point
 // expected-error@+1 {{expected integer value}}
-!qalias = type !quant.uniform<i8<-4:3>:f32, 0.1:>
+!qalias = !quant.uniform<i8<-4:3>:f32, 0.1:>
 
 // -----
 // Illegal uniform params: invalid zero point
 // expected-error@+1 {{expected integer value}}
-!qalias = type !quant.uniform<i8<-4:3>:f32, 0.1:abc>
+!qalias = !quant.uniform<i8<-4:3>:f32, 0.1:abc>
 
 // -----
 // Illegal expressed type: f33
 // expected-error@+1 {{expected non-function type}}
-!qalias = type !quant.uniform<i8<-4:3>:f33, 0.99872:127>
+!qalias = !quant.uniform<i8<-4:3>:f33, 0.99872:127>
 
 // -----
 // Illegal scale: negative
 // expected-error@+1 {{illegal scale: -1.000000}}
-!qalias = type !quant.uniform<i8<-4:3>:f32, -1.0:127>
+!qalias = !quant.uniform<i8<-4:3>:f32, -1.0:127>
 
 // -----
 // Illegal uniform params: missing quantized dimension
 // expected-error@+1 {{expected integer value}}
-!qalias = type !quant.uniform<i8<-4:3>:f32:, {2.000000e+02:-19.987200e-01:1}>
+!qalias = !quant.uniform<i8<-4:3>:f32:, {2.000000e+02:-19.987200e-01:1}>
 
 // -----
 // Illegal uniform params: unspecified quantized dimension, when multiple scales
 // provided.
 // expected-error@+1 {{expected floating point literal}}
-!qalias = type !quant.uniform<i8<-4:3>:f32, {2.000000e+02,-19.987200e-01:1}>
+!qalias = !quant.uniform<i8<-4:3>:f32, {2.000000e+02,-19.987200e-01:1}>

mlir/test/Dialect/Quant/parse-uniform.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file | FileCheck %s
 
 // -----
 // All per-layer params specified:
 //   [signed] storageType, storageTypeMin, storageTypeMax, expressedType, scale, zeroPoint
 // CHECK: !quant.uniform<i8<-8:7>:f32, 9.987200e-01:127>
-!qalias = type !quant.uniform<i8<-8:7>:f32, 0.99872:127>
+!qalias = !quant.uniform<i8<-8:7>:f32, 0.99872:127>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Trailing whitespace.
 // CHECK: !quant.uniform<i8<-8:7>:f32, 9.987200e-01:127>
-!qalias = type !quant.uniform<i8<-8:7>:f32, 0.99872:127  >
+!qalias = !quant.uniform<i8<-8:7>:f32, 0.99872:127  >
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Required per-layer params specified:
 //   [unsigned] storageType, expressedType, scale
 // CHECK: !quant.uniform<u8:f32, 9.987200e-01>
-!qalias = type !quant.uniform<u8:f32, 0.99872>
+!qalias = !quant.uniform<u8:f32, 0.99872>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Exponential scale (-)
 // CHECK: !quant.uniform<u8:f32, 2.000000e-02>
-!qalias = type !quant.uniform<u8:f32, 2.0e-2>
+!qalias = !quant.uniform<u8:f32, 2.0e-2>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Exponential scale (+)
 // CHECK: !quant.uniform<u8:f32, 2.000000e+02>
-!qalias = type !quant.uniform<u8:f32, 2.0e+2>
+!qalias = !quant.uniform<u8:f32, 2.0e+2>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Storage type: i16
 // CHECK: !quant.uniform<i16:f32, 2.000000e+02>
-!qalias = type !quant.uniform<i16:f32, 2.0e+2>
+!qalias = !quant.uniform<i16:f32, 2.0e+2>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Storage type: u16
 // CHECK: !quant.uniform<u16:f32, 2.000000e+02>
-!qalias = type !quant.uniform<u16:f32, 2.0e+2>
+!qalias = !quant.uniform<u16:f32, 2.0e+2>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Storage type: i32
 // CHECK: !quant.uniform<i32:f32, 2.000000e+02>
-!qalias = type !quant.uniform<i32:f32, 2.0e+2>
+!qalias = !quant.uniform<i32:f32, 2.0e+2>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Storage type: u32
 // CHECK: !quant.uniform<u32:f32, 2.000000e+02>
-!qalias = type !quant.uniform<u32:f32, 2.0e+2>
+!qalias = !quant.uniform<u32:f32, 2.0e+2>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Expressed type: f32
 // CHECK: !quant.uniform<u8:f32, 2.000000e+02>
-!qalias = type !quant.uniform<u8:f32, 2.0e+2>
+!qalias = !quant.uniform<u8:f32, 2.0e+2>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Expressed type: f32
 // CHECK: !quant.uniform<u8:f32, 0x41646ABBA0000000:128>
-!qalias = type !quant.uniform<u8:f32, 0x41646ABBA0000000:128>
+!qalias = !quant.uniform<u8:f32, 0x41646ABBA0000000:128>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Expressed type: f16
 // CHECK: !quant.uniform<u8:f16, 2.000000e+02>
-!qalias = type !quant.uniform<u8:f16, 2.0e+2>
+!qalias = !quant.uniform<u8:f16, 2.0e+2>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Expressed type: f64
 // CHECK: !quant.uniform<u8:f64, 2.000000e+02>
-!qalias = type !quant.uniform<u8:f64, 2.0e+2>
+!qalias = !quant.uniform<u8:f64, 2.0e+2>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Expressed type: bf16
 // CHECK: !quant.uniform<u8:bf16, 2.000000e+02>
-!qalias = type !quant.uniform<u8:bf16, 2.0e+2>
+!qalias = !quant.uniform<u8:bf16, 2.0e+2>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Per-axis scales and zero points (affine)
 // CHECK: !quant.uniform<u8:f32:1, {2.000000e+02:-120,9.987200e-01:127}>
-!qalias = type !quant.uniform<u8:f32:1, {2.0e+2:-120,0.99872:127}>
+!qalias = !quant.uniform<u8:f32:1, {2.0e+2:-120,0.99872:127}>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Per-axis scales and no zero points (fixedpoint)
 // CHECK: !quant.uniform<i8:f32:1, {2.000000e+02,9.987200e-01}>
-!qalias = type !quant.uniform<i8:f32:1, {2.0e+2,0.99872}>
+!qalias = !quant.uniform<i8:f32:1, {2.0e+2,0.99872}>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }
 
 // -----
 // Per-axis scales and zero points (mixed affine and fixedpoint)
 // CHECK: !quant.uniform<i8:f32:1, {2.000000e+02,9.987200e-01:120}>
-!qalias = type !quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>
+!qalias = !quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>
 func.func @parse() -> !qalias {
   %0 = "foo"() : () -> !qalias
   return %0 : !qalias
 }

mlir/test/IR/invalid-unregistered.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics
 
 // expected-error @below {{operation being parsed with an unregistered dialect}}
 "unregistered_dialect.op"() : () -> ()
 
 // -----
 
 // expected-error @below {{attribute created with unregistered dialect}}
 #attr = #unregistered_dialect.attribute
 
 // -----
 
 // expected-error @below {{type created with unregistered dialect}}
-!type = type !unregistered_dialect.type
+!type = !unregistered_dialect.type

mlir/test/IR/invalid.mlir

 
 // -----
 
 // expected-error @+1 {{type names with a '.' are reserved for dialect-defined names}}
 !foo.bar = i32
 
 // -----
 
-!missing_eq_alias type i32 // expected-error {{expected '=' in type alias definition}}
+!missing_eq_alias i32 // expected-error {{expected '=' in type alias definition}}
 
 // -----
 
-!missing_kw_type_alias = i32 // expected-error {{expected 'type' in type alias definition}}
+!missing_type_alias = // expected-error {{expected non-function type}}
 
 // -----
 
-!missing_type_alias = type // expected-error {{expected non-function type}}
-
-// -----
-
-!redef_alias = type i32
-!redef_alias = type i32 // expected-error {{redefinition of type alias id 'redef_alias'}}
+!redef_alias = i32
+!redef_alias = i32 // expected-error {{redefinition of type alias id 'redef_alias'}}
 
 // -----
 
 // Check ill-formed opaque tensor.
 func.func @complex_loops() {
   affine.for %i1 = 1 to 100 {
   // expected-error @+1 {{expected '"' in string literal}}
   "opaqueIntTensor"(){bar = opaque<"_", "0x686]> : tensor<2x1x4xi32>} : () -> ()

mlir/test/IR/parser.mlir

func.func @unknown_dialect_type() -> !bar<""> {
 
   // CHECK: "foo"() : () -> !bar.baz
   %1 = "foo"() : () -> !bar<"baz">
 
   return %0 : !bar<"">
 }
 
 // CHECK-LABEL: func @type_alias() -> i32 {
-!i32_type_alias = type i32
+!i32_type_alias = i32
 func.func @type_alias() -> !i32_type_alias {
 
   // Return a non-aliased i32 type.
   %0 = "foo"() : () -> i32
   return %0 : i32
 }
 
 // CHECK-LABEL: func @no_integer_set_constraints(

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

 
 // CHECK-DAG: #_0_test_alias = "alias_test:prefixed_digit"
 "test.op"() {alias_test = "alias_test:prefixed_digit"} : () -> ()
 
 // CHECK-DAG: #test_alias_conflict0_0 = "alias_test:sanitize_conflict_a"
 // CHECK-DAG: #test_alias_conflict0_1 = "alias_test:sanitize_conflict_b"
 "test.op"() {alias_test = ["alias_test:sanitize_conflict_a", "alias_test:sanitize_conflict_b"]} : () -> ()
 
-// CHECK-DAG: !tuple = type 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: !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>
 "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>
+// CHECK-DAG: !test_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>
 "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: !test_ui8_ = !test.int<unsigned, 8>
 // CHECK-DAG: tensor<32x!test_ui8_>
 "test.op"() : () -> tensor<32x!test.int<unsigned, 8>>

mlir/test/Integration/Dialect/Linalg/CPU/benchmark_matmul.mlir

 // Activate to dump assembly
 // R_UN:   -dump-object-file -object-filename=/tmp/a.o \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_runner_utils%shlibext \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // Use tee to both print to stderr and FileCheck
 // RUN: tee -a /dev/stderr | FileCheck %s
 
 
-!elem_type_a = type f32
-!elem_type_b = type f32
-!elem_type_c = type f32
-!row_major_A = type memref<${M}x${K}x!elem_type_a>
-!row_major_B = type memref<${K}x${N}x!elem_type_b>
-!row_major_C = type memref<${M}x${N}x!elem_type_c>
+!elem_type_a = f32
+!elem_type_b = f32
+!elem_type_c = f32
+!row_major_A = memref<${M}x${K}x!elem_type_a>
+!row_major_B = memref<${K}x${N}x!elem_type_b>
+!row_major_C = memref<${M}x${N}x!elem_type_c>
 
 func.func @matmul(%a: !row_major_A, %b: !row_major_B, %c: !row_major_C)
 // TODO: activate manually for now.
 // attributes { passthrough = [["target-cpu", "skylake-avx512"], ["prefer-vector-width", "512"]]}
 {
   linalg.matmul ins(%a, %b : !row_major_A, !row_major_B)
     outs(%c: !row_major_C)
   return

mlir/test/Integration/Dialect/SparseTensor/CPU/dense_output.mlir

 // RUN: mlir-opt %s --sparse-compiler | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
-!Filename = type !llvm.ptr<i8>
+!Filename = !llvm.ptr<i8>
 
 #DenseMatrix = #sparse_tensor.encoding<{
   dimLevelType = [ "dense", "dense" ],
   dimOrdering = affine_map<(i,j) -> (i,j)>
 }>
 
 #SparseMatrix = #sparse_tensor.encoding<{
   dimLevelType = [ "dense", "compressed" ],

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_flatten.mlir

 // RUN: mlir-opt %s --sparse-compiler | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/test.tns" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 //
 // Do the same run, but now with SIMDization as well. This should not change the outcome.
 //
 // RUN: mlir-opt %s --sparse-compiler="vectorization-strategy=2 vl=4" | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/test.tns" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
-!Filename = type !llvm.ptr<i8>
+!Filename = !llvm.ptr<i8>
 
 #SparseTensor = #sparse_tensor.encoding<{
   dimLevelType = [ "compressed", "compressed", "compressed", "compressed",
                    "compressed", "compressed", "compressed", "compressed" ],
   // Note that any dimOrdering permutation should give the same results
   // since, even though it impacts the sparse storage scheme layout,
   // it should not change the semantics.
   dimOrdering = affine_map<(i,j,k,l,m,n,o,p) -> (p,o,j,k,i,l,m,n)>

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_matvec.mlir

 // RUN: mlir-opt %s \
 // RUN:   --sparse-compiler="vectorization-strategy=2 vl=16 enable-simd-index32" | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/wide.mtx" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
-!Filename = type !llvm.ptr<i8>
+!Filename = !llvm.ptr<i8>
 
 #SparseMatrix = #sparse_tensor.encoding<{
   dimLevelType = [ "dense", "compressed" ],
   pointerBitWidth = 8,
   indexBitWidth = 8
 }>
 
 #matvec = {

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_mttkrp.mlir

 // RUN: mlir-opt %s --sparse-compiler | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/mttkrp_b.tns" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 //
 // Do the same run, but now with SIMDization as well. This should not change the outcome.
 //
 // RUN: mlir-opt %s --sparse-compiler="vectorization-strategy=2 vl=4" | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/mttkrp_b.tns" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
-!Filename = type !llvm.ptr<i8>
+!Filename = !llvm.ptr<i8>
 
 #SparseTensor = #sparse_tensor.encoding<{
   dimLevelType = [ "compressed", "compressed", "compressed" ]
 }>
 
 #mttkrp = {
   indexing_maps = [
     affine_map<(i,j,k,l) -> (i,k,l)>, // B

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_out_simple.mlir

 // RUN: mlir-opt %s --sparse-compiler | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 //
 // Do the same run, but now with SIMDization as well. This should not change the outcome.
 //
 // RUN: mlir-opt %s --sparse-compiler="vectorization-strategy=2 vl=4" | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
-!Filename = type !llvm.ptr<i8>
+!Filename = !llvm.ptr<i8>
 
 #DCSR = #sparse_tensor.encoding<{
   dimLevelType = [ "compressed", "compressed" ],
   dimOrdering = affine_map<(i,j) -> (i,j)>
 }>
 
 #eltwise_mult = {
   indexing_maps = [

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_sampled_matmul.mlir

 // RUN:   --sparse-compiler="vectorization-strategy=2 vl=4 enable-simd-index32" | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/test.mtx" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 //
 
-!Filename = type !llvm.ptr<i8>
+!Filename = !llvm.ptr<i8>
 
 #SparseMatrix = #sparse_tensor.encoding<{
   dimLevelType = [ "compressed", "compressed" ],
   pointerBitWidth = 32,
   indexBitWidth = 32
 }>
 
 #trait_sampled_dense_dense = {

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_spmm.mlir

 // RUN: mlir-opt %s --sparse-compiler | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/wide.mtx" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 //
 // Do the same run, but now with SIMDization as well. This should not change the outcome.
 //
 // RUN: mlir-opt %s --sparse-compiler="vectorization-strategy=2 vl=2" | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/wide.mtx" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
-!Filename = type !llvm.ptr<i8>
+!Filename = !llvm.ptr<i8>
 
 #SparseMatrix = #sparse_tensor.encoding<{
   dimLevelType = [ "dense", "compressed" ]
 }>
 
 #spmm = {
   indexing_maps = [
     affine_map<(i,j,k) -> (i,k)>, // A

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_sum.mlir

 // RUN: mlir-opt %s --sparse-compiler | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/test_symmetric.mtx" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 //
 // Do the same run, but now with SIMDization as well. This should not change the outcome.
 //
 // RUN: mlir-opt %s --sparse-compiler="vectorization-strategy=2 vl=2" | \
 // RUN: TENSOR0="%mlir_integration_test_dir/data/test_symmetric.mtx" \
 // RUN: mlir-cpu-runner \
 // RUN:  -e entry -entry-point-result=void  \
 // RUN:  -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
-!Filename = type !llvm.ptr<i8>
+!Filename = !llvm.ptr<i8>
 
 #SparseMatrix = #sparse_tensor.encoding<{
   dimLevelType = [ "compressed", "compressed" ]
 }>
 
 #trait_sum_reduce = {
   indexing_maps = [
     affine_map<(i,j) -> (i,j)>, // A

mlir/test/Integration/Dialect/SparseTensor/taco/tools/mlir_pytaco_utils.py

sparsity = ", ".join(
       map(lambda s: '"compressed"' if s.value else '"dense"', sparsity_codes))
 
   # Get the MLIR text code to write the dimension sizes to the output buffer.
   output_dims = "\n".join(
       map(lambda d: _output_one_dim(d, rank, shape, type), range(rank)))
 
   # Return the MLIR text kernel.
   return f"""
-!Ptr = type !llvm.ptr<i8>
+!Ptr = !llvm.ptr<i8>
 #enc = #sparse_tensor.encoding<{{
   dimLevelType = [ {sparsity} ]
 }}>
 func.func @{_ENTRY_NAME}(%filename: !Ptr) -> (tensor<{shape}x{type}, #enc>, memref<{rank}xindex>)
 attributes {{ llvm.emit_c_interface }} {{
   %t = sparse_tensor.new %filename : !Ptr to tensor<{shape}x{type}, #enc>
   %b = memref.alloc() : memref<{rank}xindex>
   {output_dims}
def _get_output_sparse_tensor_kernel(
 
   # Convert the encoded sparsity values to a string representation.
   sparsity = ", ".join(
       map(lambda s: '"compressed"'
           if s.value else '"dense"', sparsity_codes))
 
   # Return the MLIR text kernel.
   return f"""
-!Ptr = type !llvm.ptr<i8>
+!Ptr = !llvm.ptr<i8>
 #enc = #sparse_tensor.encoding<{{
   dimLevelType = [ {sparsity} ]
 }}>
 func.func @{_ENTRY_NAME}(%t: tensor<{shape}x{type}, #enc>, %filename: !Ptr)
 attributes {{ llvm.emit_c_interface }} {{
   sparse_tensor.out %t, %filename : tensor<{shape}x{type}, #enc>, !Ptr
   func.return
 }}"""

mlir/test/Integration/Dialect/Vector/CPU/test-outerproduct-f32.mlir

 // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e entry -entry-point-result=void  \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
-!vector_type_A = type vector<8xf32>
-!vector_type_B = type vector<8xf32>
-!vector_type_C = type vector<8x8xf32>
-
-!vector_type_X = type vector<2xf32>
-!vector_type_Y = type vector<3xf32>
-!vector_type_Z = type vector<2x3xf32>
+!vector_type_A = vector<8xf32>
+!vector_type_B = vector<8xf32>
+!vector_type_C = vector<8x8xf32>
+
+!vector_type_X = vector<2xf32>
+!vector_type_Y = vector<3xf32>
+!vector_type_Z = vector<2x3xf32>
 
-!vector_type_R = type vector<7xf32>
+!vector_type_R = vector<7xf32>
 
 func.func @vector_outerproduct_splat_8x8(%fa: f32, %fb: f32, %fc: f32) -> !vector_type_C {
   %a = vector.splat %fa: !vector_type_A
   %b = vector.splat %fb: !vector_type_B
   %c = vector.splat %fc: !vector_type_C
   %d = vector.outerproduct %a, %b, %c : !vector_type_A, !vector_type_B
   return %d: !vector_type_C
 }

mlir/test/Integration/Dialect/Vector/CPU/test-outerproduct-i64.mlir

 // RUN: mlir-opt %s -convert-scf-to-cf -convert-vector-to-llvm -convert-func-to-llvm -reconcile-unrealized-casts | \
 // RUN: mlir-cpu-runner -e entry -entry-point-result=void  \
 // RUN:   -shared-libs=%mlir_integration_test_dir/libmlir_c_runner_utils%shlibext | \
 // RUN: FileCheck %s
 
-!vector_type_A = type vector<8xi64>
-!vector_type_B = type vector<8xi64>
-!vector_type_C = type vector<8x8xi64>
-
-!vector_type_X = type vector<2xi64>
-!vector_type_Y = type vector<3xi64>
-!vector_type_Z = type vector<2x3xi64>
+!vector_type_A = vector<8xi64>
+!vector_type_B = vector<8xi64>
+!vector_type_C = vector<8x8xi64>
+
+!vector_type_X = vector<2xi64>
+!vector_type_Y = vector<3xi64>
+!vector_type_Z = vector<2x3xi64>
 
-!vector_type_R = type vector<7xi64>
+!vector_type_R = vector<7xi64>
 
 func.func @vector_outerproduct_splat_8x8(%ia: i64, %ib: i64, %ic: i64) -> !vector_type_C {
   %a = vector.splat %ia: !vector_type_A
   %b = vector.splat %ib: !vector_type_B
   %c = vector.splat %ic: !vector_type_C
   %d = vector.outerproduct %a, %b, %c : !vector_type_A, !vector_type_B
   return %d: !vector_type_C
 }

mlir/test/mlir-cpu-runner/utils.mlir

 // PRINT-3D-COUNT-4: {{.*[[:space:]].*}}2,    2,    2,    2,    2
 // PRINT-3D-COUNT-4: {{.*[[:space:]].*}}2,    2,    2,    2,    2
 // PRINT-3D-COUNT-2: {{.*[[:space:]].*}}2,    2,    2,    2,    2
 //    PRINT-3D-NEXT: 2,    2,    4,    2,    2
 //    PRINT-3D-NEXT: 2,    2,    2,    2,    2
 
 func.func private @printMemrefF32(memref<*xf32>) attributes { llvm.emit_c_interface }
 
-!vector_type_C = type vector<4x4xf32>
-!matrix_type_CC = type memref<1x1x!vector_type_C>
+!vector_type_C = vector<4x4xf32>
+!matrix_type_CC = memref<1x1x!vector_type_C>
 func.func @vector_splat_2d() {
   %c0 = arith.constant 0 : index
   %f10 = arith.constant 10.0 : f32
   %vf10 = vector.splat %f10: !vector_type_C
   %C = memref.alloc() : !matrix_type_CC
   memref.store %vf10, %C[%c0, %c0]: !matrix_type_CC
 
   %CC = memref.cast %C: !matrix_type_CC to memref<?x?x!vector_type_C>

mlir/utils/tree-sitter-mlir/grammar.js

 module.exports = grammar({
   name : 'mlir',
   extras : $ => [/\s/,
                  $.comment,
 ],
   conflicts : $ => [],
   rules : {
     // Top level production:
     //   (operation | attribute-alias-def | type-alias-def)
     toplevel : $ => seq(choice(
                  $.operation,
                  $.attribute_alias_def,
                  $.type_alias_def,
                  )),
 
     // Common syntax (lang-ref)
     //  digit     ::= [0-9]
     //  hex_digit ::= [0-9a-fA-F]
     //  letter    ::= [a-zA-Z]
     //  id-punct  ::= [$._-]
     //
rules : {
     ssa_use_and_type : $ => seq($.ssa_use, ':', $.type),
     ssa_use : $ => $.value_use,
     ssa_use_and_type_list : $ => seq($.ssa_use_and_type,
                                      repeat(seq(',', $.ssa_use_and_type))),
     function_type : $ => seq(choice($.type, $.type_list_parens), '->',
                              choice($.type, $.type_list_parens)),
 
     // Type aliases
-    //   type-alias-def ::= '!' alias-name '=' 'type' type
+    //   type-alias-def ::= '!' alias-name '=' type
     //   type-alias ::= '!' alias-name
-    type_alias_def : $ => seq('!', $.alias_name, '=', 'type', $.type),
+    type_alias_def : $ => seq('!', $.alias_name, '=', $.type),
     type_alias : $ => seq('!', $.alias_name),
 
     // Dialect Types
     //   dialect-namespace ::= bare-id
     //
     //   opaque-dialect-item ::= dialect-namespace '<' string-literal '>'
     //
     //   pretty-dialect-item ::= dialect-namespace '.'