[mlir][Vector] First step for 0D vector type

[michalt]

Summary

There seems to be a consensus that we should allow 0D vectors:
https://llvm.discourse.group/t/should-we-have-0-d-vectors/3097

This commit is only the first step: it changes the verifier and the parser to
allow vectors like vector<f32> (but does not allow explicit 0 dimensions,
i.e., vector<0xf32> is not allowed).

[nicolasvasilache]

Thanks for starting this @michalt !

mlir/include/mlir/IR/BuiltinTypes.td

def Builtin_Vector : Builtin_Type<"Vector", [
   let summary = "Multi-dimensional SIMD vector type";
   let description = [{
     Syntax:
 
     ```
     vector-type ::= `vector` `<` static-dimension-list vector-element-type `>`
     vector-element-type ::= float-type | integer-type | index-type
 
-    static-dimension-list ::= (decimal-literal `x`)+
+    static-dimension-list ::= (decimal-literal `x`)*
     ```
 
     The vector type represents a SIMD style vector, used by target-specific
     operation sets like AVX. While the most common use is for 1D vectors (e.g.
     vector<16 x f32>) we also support multidimensional registers on targets that
     support them (like TPUs).
 
-    Vector shapes must be positive decimal integers.
+    Vector shapes must be positive decimal integers. 0D vectors are allowed by
+    omitting the dimension: `vector<f32>`.
 
     Note: hexadecimal integer literals are not allowed in vector type
     declarations, `vector<0x42xi32>` is invalid because it is interpreted as a
     2D vector with shape `(0, 42)` and zero shapes are not allowed.
 
-
     Examples:
 
     ```mlir
     vector<3x42xi32>
     ```
   }];
   let parameters = (ins
     ArrayRefParameter<"int64_t">:$shape,

mlir/lib/IR/BuiltinTypes.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // VectorType
 //===----------------------------------------------------------------------===//
 
 LogicalResult VectorType::verify(function_ref<InFlightDiagnostic()> emitError,
                                  ArrayRef<int64_t> shape, Type elementType) {
-  if (shape.empty())
-    return emitError() << "vector types must have at least one dimension";
-
   if (!isValidElementType(elementType))
     return emitError()
            << "vector elements must be int/index/float type but got "
            << elementType;
 
   if (any_of(shape, [](int64_t i) { return i <= 0; }))
     return emitError()
            << "vector types must have positive constant sizes but got "

mlir/lib/Parser/TypeParser.cpp

if (parseTypeListNoParens(types) ||
       parseToken(Token::greater, "expected '>' in tuple type"))
     return nullptr;
 
   return TupleType::get(getContext(), types);
 }
 
 /// Parse a vector type.
 ///
-///   vector-type ::= `vector` `<` non-empty-static-dimension-list type `>`
-///   non-empty-static-dimension-list ::= decimal-literal `x`
-///                                       static-dimension-list
+///   vector-type ::= `vector` `<` static-dimension-list type `>`
 ///   static-dimension-list ::= (decimal-literal `x`)*
 ///
 VectorType Parser::parseVectorType() {
   consumeToken(Token::kw_vector);
 
   if (parseToken(Token::less, "expected '<' in vector type"))
     return nullptr;
 
   SmallVector<int64_t, 4> dimensions;
   if (parseDimensionListRanked(dimensions, /*allowDynamic=*/false))
     return nullptr;
-  if (dimensions.empty())
-    return (emitError("expected dimension size in vector type"), nullptr);
   if (any_of(dimensions, [](int64_t i) { return i <= 0; }))
     return emitError(getToken().getLoc(),
                      "vector types must have positive constant sizes"),
            nullptr;
 
   // Parse the element type.
   auto typeLoc = getToken().getLoc();
   auto elementType = parseType();

mlir/test/IR/invalid.mlir

 
 // -----
 
 // expected-error @+1 {{vector types must have positive constant sizes}}
 func @zero_in_vector_type() -> vector<1x0xi32>
 
 // -----
 
-// expected-error @+1 {{expected dimension size in vector type}}
+// expected-error @+1 {{expected non-function type}}
 func @negative_vector_size() -> vector<-1xi32>
 
 // -----
 
 // expected-error @+1 {{expected non-function type}}
 func @negative_in_vector_size() -> vector<1x-1xi32>
 
 // -----

mlir/test/IR/parser.mlir

 func private @sint_types(si2, si4) -> (si7, si1023)
 
 // CHECK: func private @uint_types(ui2, ui4) -> (ui7, ui1023)
 func private @uint_types(ui2, ui4) -> (ui7, ui1023)
 
 // CHECK: func private @float_types(f80, f128)
 func private @float_types(f80, f128)
 
-// CHECK: func private @vectors(vector<1xf32>, vector<2x4xf32>)
-func private @vectors(vector<1 x f32>, vector<2x4xf32>)
+// CHECK: func private @vectors(vector<f32>, vector<1xf32>, vector<2x4xf32>)
+func private @vectors(vector<f32>, vector<1 x f32>, vector<2x4xf32>)
 
 // CHECK: func private @tensors(tensor<*xf32>, tensor<*xvector<2x4xf32>>, tensor<1x?x4x?x?xi32>, tensor<i8>)
 func private @tensors(tensor<* x f32>, tensor<* x vector<2x4xf32>>,
                  tensor<1x?x4x?x?xi32>, tensor<i8>)
 
 // CHECK: func private @tensor_encoding(tensor<16x32xf64, "sparse">)
 func private @tensor_encoding(tensor<16x32xf64, "sparse">)