[mlir][spirv] add support lowering of extract_slice to scalar type

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

struct VectorExtractStridedSliceOpConvert final
   LogicalResult
   matchAndRewrite(vector::ExtractStridedSliceOp extractOp,
                   ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = getTypeConverter()->convertType(extractOp.getType());
     if (!dstType)
       return failure();
 
-    // Extract vector<1xT> not supported yet.
-    if (dstType.isa<spirv::ScalarType>())
-      return failure();
 
     uint64_t offset = getFirstIntValue(extractOp.offsets());
     uint64_t size = getFirstIntValue(extractOp.sizes());
     uint64_t stride = getFirstIntValue(extractOp.strides());
     if (stride != 1)
       return failure();
 
     Value srcVector = operands.front();
 
+    // Extract vector<1xT> case.
+    if (dstType.isa<spirv::ScalarType>()) {
+      int32_t id = getFirstIntValue(extractOp.offsets());
+      rewriter.replaceOpWithNewOp<spirv::CompositeExtractOp>(extractOp,
+                                                             srcVector, id);
+      return success();
+    }
+
     SmallVector<int32_t, 2> indices(size);
     std::iota(indices.begin(), indices.end(), offset);
 
     rewriter.replaceOpWithNewOp<spirv::VectorShuffleOp>(
         extractOp, dstType, srcVector, srcVector,
         rewriter.getI32ArrayAttr(indices));
 
     return success();

mlir/test/Conversion/VectorToSPIRV/simple.mlir

// expected-error @+1 {{failed to legalize operation 'vector.extractelement'}}
   spv.ReturnValue %0: f32
 }
 
 // -----
 
 // CHECK-LABEL: func @extract_strided_slice
 //  CHECK-SAME: %[[ARG:.+]]: vector<4xf32>
 //       CHECK: %{{.+}} = spv.VectorShuffle [1 : i32, 2 : i32] %[[ARG]] : vector<4xf32>, %[[ARG]] : vector<4xf32> -> vector<2xf32>
+//       CHECK: %{{.+}} = spv.CompositeExtract %[[ARG]][1 : i32] : vector<4xf32>
 func @extract_strided_slice(%arg0: vector<4xf32>) {
   %0 = vector.extract_strided_slice %arg0 {offsets = [1], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32>
+  %1 = vector.extract_strided_slice %arg0 {offsets = [1], sizes = [1], strides = [1]} : vector<4xf32> to vector<1xf32>
   spv.Return
 }
 
 // -----
 
 // CHECK-LABEL: insert_element
 //  CHECK-SAME: %[[VAL:.*]]: f32, %[[V:.*]]: vector<4xf32>, %[[ID:.*]]: i32
 //       CHECK:   spv.VectorInsertDynamic %[[VAL]], %[[V]][%[[ID]]] : vector<4xf32>, i32