[mlir][spirv] NFC: use Optional to replace SPV_Optional

mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td

 def SPV_ScalarOrVector : AnyTypeOf<[SPV_Scalar, SPV_Vector]>;
 def SPV_ScalarOrVectorOrPtr : AnyTypeOf<[SPV_ScalarOrVector, SPV_AnyPtr]>;
 
 class SPV_Vec4<Type type> : VectorOfLengthAndType<[4], [type]>;
 def SPV_IntVec4 : SPV_Vec4<SPV_Integer>;
 def SPV_IOrUIVec4 : SPV_Vec4<SPV_SignlessOrUnsignedInt>;
 def SPV_Int32Vec4 : SPV_Vec4<AnyI32>;
 
-// TODO(antiagainst): Use a more appropriate way to model optional operands
-class SPV_Optional<Type type> : Variadic<type>;
-
 // TODO(ravishankarm): From 1.4, this should also include Composite type.
 def SPV_SelectType : AnyTypeOf<[SPV_Scalar, SPV_Vector, SPV_AnyPtr]>;
 
 //===----------------------------------------------------------------------===//
 // SPIR-V OpTrait definitions
 //===----------------------------------------------------------------------===//
 
 // Check that an op can only be used within the scope of a function-like op.

mlir/include/mlir/Dialect/SPIRV/SPIRVControlFlowOps.td

def SPV_FunctionCallOp : SPV_Op<"FunctionCall", [
   }];
 
   let arguments = (ins
     FlatSymbolRefAttr:$callee,
     Variadic<SPV_Type>:$arguments
   );
 
   let results = (outs
-    SPV_Optional<SPV_Type>:$result
+    Optional<SPV_Type>:$result
   );
 
   let autogenSerialization = 0;
 
   let assemblyFormat = [{
     $callee `(` $arguments `)` attr-dict `:`
     functional-type($arguments, results)
   }];

mlir/include/mlir/Dialect/SPIRV/SPIRVNonUniformOps.td

Capability<[SPV_C_GroupNonUniformArithmetic,
                 SPV_C_GroupNonUniformClustered,
                 SPV_C_GroupNonUniformPartitionedNV]>
   ];
 
   let arguments = (ins
     SPV_ScopeAttr:$execution_scope,
     SPV_GroupOperationAttr:$group_operation,
     SPV_ScalarOrVectorOf<type>:$value,
-    SPV_Optional<SPV_Integer>:$cluster_size
+    Optional<SPV_Integer>:$cluster_size
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<type>:$result
   );
 
   let parser = [{ return parseGroupNonUniformArithmeticOp(parser, result); }];
   let printer = [{ printGroupNonUniformArithmeticOp(getOperation(), p); }];

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.td

let description = [{
     %2 = spv.Variable init(%0): !spv.ptr<f32, Private>
     %3 = spv.Variable init(%0) bind(1, 2): !spv.ptr<f32, Uniform>
     %3 = spv.Variable built_in("GlobalInvocationID") : !spv.ptr<vector<3xi32>, Uniform>
     ```
   }];
 
   let arguments = (ins
     SPV_StorageClassAttr:$storage_class,
-    SPV_Optional<AnyType>:$initializer
+    Optional<AnyType>:$initializer
   );
 
   let results = (outs
     SPV_AnyPtr:$pointer
   );
 }
 
 // -----
 
 #endif // SPIRV_OPS

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRV.cpp

LogicalResult SingleWorkgroupReduction::matchAndRewrite(
 
   // Perform the group reduction operation.
   Value groupOperation;
 #define CREATE_GROUP_NON_UNIFORM_BIN_OP(opKind, spvOp)                         \
   case linalg::RegionMatcher::BinaryOpKind::opKind: {                          \
     groupOperation = rewriter.create<spirv::spvOp>(                            \
         loc, originalInputType.getElementType(), spirv::Scope::Subgroup,       \
         spirv::GroupOperation::Reduce, inputElement,                           \
-        /*cluster_size=*/ArrayRef<Value>());                                   \
+        /*cluster_size=*/nullptr);                                             \
   } break
   switch (*binaryOpKind) {
     CREATE_GROUP_NON_UNIFORM_BIN_OP(IAdd, GroupNonUniformIAddOp);
   }
 #undef CREATE_GROUP_NON_UNIFORM_BIN_OP
 
   // Get the output element accessed by this reduction.
   Value zero = spirv::ConstantOp::getZero(

mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp

Deserializer::processOp<spirv::FunctionCallOp>(ArrayRef<uint32_t> operands) {
   }
 
   Type resultType = getType(operands[0]);
   if (!resultType) {
     return emitError(unknownLoc, "undefined result type from <id> ")
            << operands[0];
   }
 
+  // Use null type to mean no result type.
+  if (isVoidType(resultType))
+    resultType = nullptr;
+
   auto resultID = operands[1];
   auto functionID = operands[2];
 
   auto functionName = getFunctionSymbol(functionID);
 
   SmallVector<Value, 4> arguments;
   for (auto operand : llvm::drop_begin(operands, 3)) {
     auto value = getValue(operand);
     if (!value) {
       return emitError(unknownLoc, "unknown <id> ")
              << operand << " used by OpFunctionCall";
     }
     arguments.push_back(value);
   }
 
-  SmallVector<Type, 1> resultTypes;
-  if (!isVoidType(resultType)) {
-    resultTypes.push_back(resultType);
-  }
-
   auto opFunctionCall = opBuilder.create<spirv::FunctionCallOp>(
-      unknownLoc, resultTypes, opBuilder.getSymbolRefAttr(functionName),
+      unknownLoc, resultType, opBuilder.getSymbolRefAttr(functionName),
       arguments);
 
-  if (!resultTypes.empty()) {
+  if (resultType)
     valueMap[resultID] = opFunctionCall.getResult(0);
-  }
   return success();
 }
 
 template <>
 LogicalResult
 Deserializer::processOp<spirv::MemoryBarrierOp>(ArrayRef<uint32_t> operands) {
   if (operands.size() != 2) {
     return emitError(unknownLoc, "OpMemoryBarrier must have memory scope <id> "

mlir/test/Dialect/SPIRV/control-flow-ops.mlir

func @caller() {
   spv.FunctionCall @callee() : () -> ()
   spv.Return
 }
 
 // -----
 
 spv.module Logical GLSL450 {
   spv.func @f_invalid_result_type(%arg0 : i32, %arg1 : i32) -> () "None" {
-    // expected-error @+1 {{expected callee function to have 0 or 1 result, but provided 2}}
+    // expected-error @+1 {{result group starting at #0 requires 0 or 1 element, but found 2}}
     %0:2 = spv.FunctionCall @f_invalid_result_type(%arg0, %arg1) : (i32, i32) -> (i32, i32)
     spv.Return
   }
 }
 
 // -----
 
 spv.module Logical GLSL450 {

mlir/utils/spirv/gen_spirv_dialect.py

def map_spec_operand_to_ods_argument(operand):
   # not be handled here.
   assert kind != 'IdResultType', 'unexpected to handle "IdResultType" kind'
   assert kind != 'IdResult', 'unexpected to handle "IdResult" kind'
 
   if kind == 'IdRef':
     if quantifier == '':
       arg_type = 'SPV_Type'
     elif quantifier == '?':
-      arg_type = 'SPV_Optional<SPV_Type>'
+      arg_type = 'Optional<SPV_Type>'
     else:
       arg_type = 'Variadic<SPV_Type>'
   elif kind == 'IdMemorySemantics' or kind == 'IdScope':
     # TODO(antiagainst): Need to further constrain 'IdMemorySemantics'
     # and 'IdScope' given that they should be generated from OpConstant.
     assert quantifier == '', ('unexpected to have optional/variadic memory '
                               'semantics or scope <id>')
     arg_type = 'SPV_' + kind[2:] + 'Attr'