Replace SpirvValueKind::IllegalTypeUsed with mere undef.

Author: eddyb

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -3411,10 +3411,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         if buffer_store_intrinsic {
             self.codegen_buffer_store_intrinsic(fn_abi, args);
             let void_ty = SpirvType::Void.def(rustc_span::DUMMY_SP, self);
-            return SpirvValue {
-                kind: SpirvValueKind::IllegalTypeUsed(void_ty),
-                ty: void_ty,
-            };
+            return self.undef(void_ty);
         }
 
         if let Some((source_ty, target_ty)) = from_trait_impl {

crates/rustc_codegen_spirv/src/builder/byte_addressable_buffer.rs

@@ -2,7 +2,7 @@
 use crate::maybe_pqp_cg_ssa as rustc_codegen_ssa;
 
 use super::Builder;
-use crate::builder_spirv::{SpirvValue, SpirvValueExt, SpirvValueKind};
+use crate::builder_spirv::{SpirvValue, SpirvValueExt};
 use crate::spirv_type::SpirvType;
 use rspirv::spirv::{Decoration, Word};
 use rustc_abi::{Align, Size};
@@ -188,12 +188,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ) -> SpirvValue {
         let pass_mode = &fn_abi.unwrap().ret.mode;
         match pass_mode {
-            PassMode::Ignore => {
-                return SpirvValue {
-                    kind: SpirvValueKind::IllegalTypeUsed(result_type),
-                    ty: result_type,
-                };
-            }
+            PassMode::Ignore => return self.undef(result_type),
+
             // PassMode::Pair is identical to PassMode::Direct - it's returned as a struct
             PassMode::Direct(_) | PassMode::Pair(_, _) => (),
             PassMode::Cast { .. } => {

crates/rustc_codegen_spirv/src/builder_spirv.rs

@@ -40,13 +40,6 @@ pub enum SpirvValueKind {
     /// of such constants, instead of where they're generated (and cached).
     IllegalConst(Word),
 
-    /// This can only happen in one specific case - which is as a result of
-    /// `codegen_buffer_store_intrinsic`, that function is supposed to return
-    /// `OpTypeVoid`, however because it gets inline by the compiler it can't.
-    /// Instead we return this, and trigger an error if we ever end up using the
-    /// result of this function call (which we can't).
-    IllegalTypeUsed(Word),
-
     // FIXME(eddyb) this shouldn't be needed, but `rustc_codegen_ssa` still relies
     // on converting `Function`s to `Value`s even for direct calls, the `Builder`
     // should just have direct and indirect `call` variants (or a `Callee` enum).
@@ -166,16 +159,6 @@ impl SpirvValue {
                 id
             }
 
-            SpirvValueKind::IllegalTypeUsed(id) => {
-                cx.tcx
-                    .dcx()
-                    .struct_span_err(span, "Can't use type as a value")
-                    .with_note(format!("Type: *{}", cx.debug_type(id)))
-                    .emit();
-
-                id
-            }
-
             SpirvValueKind::FnAddr { .. } => {
                 cx.builder
                     .const_to_id