[naga spv-out] Delete BlockContext::is_intermediate; use types.

Delete the function `BlockContext::is_intermediate`. Instead, have
`Access` and `AccessIndex` instructions decide whether to defer code
generation based on the type of the base expression: indexing
operations on pointers are deferred; anything else is not.

naga/src/back/spv/block.rs

@@ -212,32 +212,6 @@ impl Writer {
 }
 
 impl<'w> BlockContext<'w> {
-    /// Decide whether to put off emitting instructions for `expr_handle`.
-    ///
-    /// We would like to gather together chains of `Access` and `AccessIndex`
-    /// Naga expressions into a single `OpAccessChain` SPIR-V instruction. To do
-    /// this, we don't generate instructions for these exprs when we first
-    /// encounter them. Their ids in `self.writer.cached.ids` are left as zero. Then,
-    /// once we encounter a `Load` or `Store` expression that actually needs the
-    /// chain's value, we call `write_expression_pointer` to handle the whole
-    /// thing in one fell swoop.
-    fn is_intermediate(&self, expr_handle: Handle<crate::Expression>) -> bool {
-        match self.ir_function.expressions[expr_handle] {
-            crate::Expression::GlobalVariable(handle) => {
-                self.ir_module.global_variables[handle].space != crate::AddressSpace::Handle
-            }
-            crate::Expression::LocalVariable(_) => true,
-            crate::Expression::FunctionArgument(index) => {
-                let arg = &self.ir_function.arguments[index as usize];
-                self.ir_module.types[arg.ty].inner.pointer_space().is_some()
-            }
-
-            // The chain rule: if this `Access...`'s `base` operand was
-            // previously omitted, then omit this one, too.
-            _ => self.cached.ids[expr_handle] == 0,
-        }
-    }
-
     /// Cache an expression for a value.
     pub(super) fn cache_expression_value(
         &mut self,
@@ -308,18 +282,22 @@ impl<'w> BlockContext<'w> {
                     id
                 }
             }
-            crate::Expression::Access { base, index: _ } if self.is_intermediate(base) => {
-                // See `is_intermediate`; we'll handle this later in
-                // `write_expression_pointer`.
-                0
-            }
             crate::Expression::Access { base, index } => {
                 let base_ty_inner = self.fun_info[base].ty.inner_with(&self.ir_module.types);
                 match *base_ty_inner {
+                    crate::TypeInner::Pointer { .. } | crate::TypeInner::ValuePointer { .. } => {
+                        // When we have a chain of `Access` and `AccessIndex` expressions
+                        // operating on pointers, we want to generate a single
+                        // `OpAccessChain` instruction for the whole chain. Put off
+                        // generating any code for this until we find the `Expression`
+                        // that actually dereferences the pointer.
+                        0
+                    }
                     crate::TypeInner::Vector { .. } => {
                         self.write_vector_access(expr_handle, base, index, block)?
                     }
-                    // Only binding arrays in the Handle address space will take this path (due to `is_intermediate`)
+                    // Only binding arrays in the `Handle` address space will take this
+                    // path, since we handled the `Pointer` case above.
                     crate::TypeInner::BindingArray {
                         base: binding_type, ..
                     } => {
@@ -404,13 +382,16 @@ impl<'w> BlockContext<'w> {
                     }
                 }
             }
-            crate::Expression::AccessIndex { base, index: _ } if self.is_intermediate(base) => {
-                // See `is_intermediate`; we'll handle this later in
-                // `write_expression_pointer`.
-                0
-            }
             crate::Expression::AccessIndex { base, index } => {
                 match *self.fun_info[base].ty.inner_with(&self.ir_module.types) {
+                    crate::TypeInner::Pointer { .. } | crate::TypeInner::ValuePointer { .. } => {
+                        // When we have a chain of `Access` and `AccessIndex` expressions
+                        // operating on pointers, we want to generate a single
+                        // `OpAccessChain` instruction for the whole chain. Put off
+                        // generating any code for this until we find the `Expression`
+                        // that actually dereferences the pointer.
+                        0
+                    }
                     crate::TypeInner::Vector { .. }
                     | crate::TypeInner::Matrix { .. }
                     | crate::TypeInner::Array { .. }