diff --git a/samples/main.cc b/samples/main.cc
index 4b22b6a0e8..7ea3f3121f 100644
--- a/samples/main.cc
+++ b/samples/main.cc
@@ -429,7 +429,7 @@ int main(int argc, const char** argv) {
     }
   }
   if (options.format == Format::kSpirv) {
-    auto w = static_cast<tint::writer::spirv::Generator*>(writer.get());
+    auto* w = static_cast<tint::writer::spirv::Generator*>(writer.get());
     if (!WriteFile(options.output_file, "wb", w->result())) {
       return 1;
     }
diff --git a/src/reader/spirv/function.cc b/src/reader/spirv/function.cc
index 994cc922e7..40292dfcb7 100644
--- a/src/reader/spirv/function.cc
+++ b/src/reader/spirv/function.cc
@@ -325,6 +325,11 @@ class StructuredTraverser {
 
 }  // namespace
 
+BlockInfo::BlockInfo(const spvtools::opt::BasicBlock& bb)
+    : basic_block(&bb), id(bb.id()) {}
+
+BlockInfo::~BlockInfo() {}
+
 FunctionEmitter::FunctionEmitter(ParserImpl* pi,
                                  const spvtools::opt::Function& function)
     : parser_impl_(*pi),
diff --git a/src/reader/spirv/function.h b/src/reader/spirv/function.h
index 72fb2ab245..c2e8b1cf78 100644
--- a/src/reader/spirv/function.h
+++ b/src/reader/spirv/function.h
@@ -74,8 +74,8 @@ enum class EdgeKind {
 struct BlockInfo {
   /// Constructor
   /// @param bb internal representation of the basic block
-  explicit BlockInfo(const spvtools::opt::BasicBlock& bb)
-      : basic_block(&bb), id(bb.id()) {}
+  explicit BlockInfo(const spvtools::opt::BasicBlock& bb);
+  ~BlockInfo();
 
   /// The internal representation of the basic block.
   const spvtools::opt::BasicBlock* basic_block;
diff --git a/src/reader/spirv/function_cfg_test.cc b/src/reader/spirv/function_cfg_test.cc
index a37bfabd73..e1d96d379f 100644
--- a/src/reader/spirv/function_cfg_test.cc
+++ b/src/reader/spirv/function_cfg_test.cc
@@ -3944,7 +3944,7 @@ TEST_F(SpvParserTest, FindSwitchCaseHeaders_DefaultIsMerge) {
   ASSERT_NE(bi99, nullptr);
   EXPECT_EQ(bi99->case_head_for, nullptr);
   ASSERT_NE(bi99->default_head_for, nullptr);
-  EXPECT_EQ(bi99->default_head_for->begin_id, 10);
+  EXPECT_EQ(bi99->default_head_for->begin_id, 10u);
   EXPECT_TRUE(bi99->default_is_merge);
   EXPECT_EQ(bi99->case_values.get(), nullptr);
 }
@@ -3982,7 +3982,7 @@ TEST_F(SpvParserTest, FindSwitchCaseHeaders_DefaultIsNotMerge) {
   ASSERT_NE(bi30, nullptr);
   EXPECT_EQ(bi30->case_head_for, nullptr);
   ASSERT_NE(bi30->default_head_for, nullptr);
-  EXPECT_EQ(bi30->default_head_for->begin_id, 10);
+  EXPECT_EQ(bi30->default_head_for->begin_id, 10u);
   EXPECT_FALSE(bi30->default_is_merge);
   EXPECT_EQ(bi30->case_values.get(), nullptr);
 }
@@ -4019,7 +4019,7 @@ TEST_F(SpvParserTest, FindSwitchCaseHeaders_CaseIsNotDefault) {
   const auto* bi20 = fe.GetBlockInfo(20);
   ASSERT_NE(bi20, nullptr);
   ASSERT_NE(bi20->case_head_for, nullptr);
-  EXPECT_EQ(bi20->case_head_for->begin_id, 10);
+  EXPECT_EQ(bi20->case_head_for->begin_id, 10u);
   EXPECT_EQ(bi20->default_head_for, nullptr);
   EXPECT_FALSE(bi20->default_is_merge);
   EXPECT_THAT(*(bi20->case_values.get()), UnorderedElementsAre(200));
@@ -4054,7 +4054,7 @@ TEST_F(SpvParserTest, FindSwitchCaseHeaders_CaseIsDefault) {
   const auto* bi20 = fe.GetBlockInfo(20);
   ASSERT_NE(bi20, nullptr);
   ASSERT_NE(bi20->case_head_for, nullptr);
-  EXPECT_EQ(bi20->case_head_for->begin_id, 10);
+  EXPECT_EQ(bi20->case_head_for->begin_id, 10u);
   EXPECT_EQ(bi20->default_head_for, bi20->case_head_for);
   EXPECT_FALSE(bi20->default_is_merge);
   EXPECT_THAT(*(bi20->case_values.get()), UnorderedElementsAre(200));
@@ -4122,7 +4122,7 @@ TEST_F(SpvParserTest, FindSwitchCaseHeaders_ManyValuesWithSameCase) {
   const auto* bi20 = fe.GetBlockInfo(20);
   ASSERT_NE(bi20, nullptr);
   ASSERT_NE(bi20->case_head_for, nullptr);
-  EXPECT_EQ(bi20->case_head_for->begin_id, 10);
+  EXPECT_EQ(bi20->case_head_for->begin_id, 10u);
   EXPECT_EQ(bi20->default_head_for, nullptr);
   EXPECT_FALSE(bi20->default_is_merge);
   EXPECT_THAT(*(bi20->case_values.get()), UnorderedElementsAre(200, 300));
@@ -4365,7 +4365,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_BackEdge_SingleBlockLoop) {
 
   auto* bi20 = fe.GetBlockInfo(20);
   ASSERT_NE(bi20, nullptr);
-  EXPECT_EQ(bi20->succ_edge.count(20), 1);
+  EXPECT_EQ(bi20->succ_edge.count(20), 1u);
   EXPECT_EQ(bi20->succ_edge[20], EdgeKind::kBack);
 }
 
@@ -4397,7 +4397,7 @@ TEST_F(SpvParserTest,
 
   auto* bi40 = fe.GetBlockInfo(40);
   ASSERT_NE(bi40, nullptr);
-  EXPECT_EQ(bi40->succ_edge.count(20), 1);
+  EXPECT_EQ(bi40->succ_edge.count(20), 1u);
   EXPECT_EQ(bi40->succ_edge[20], EdgeKind::kBack);
 }
 
@@ -4432,7 +4432,7 @@ TEST_F(SpvParserTest,
 
   auto* bi50 = fe.GetBlockInfo(50);
   ASSERT_NE(bi50, nullptr);
-  EXPECT_EQ(bi50->succ_edge.count(20), 1);
+  EXPECT_EQ(bi50->succ_edge.count(20), 1u);
   EXPECT_EQ(bi50->succ_edge[20], EdgeKind::kBack);
 }
 
@@ -4491,7 +4491,7 @@ TEST_F(SpvParserTest,
 
   auto* bi = fe.GetBlockInfo(20);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kLoopBreak);
 }
 
@@ -4520,7 +4520,7 @@ TEST_F(SpvParserTest,
 
   auto* bi = fe.GetBlockInfo(20);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kLoopBreak);
 }
 
@@ -4548,7 +4548,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_LoopBreak_FromContinueConstructHeader) {
 
   auto* bi = fe.GetBlockInfo(30);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kLoopBreak);
 }
 
@@ -4573,7 +4573,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_ToMerge_FromIfHeader) {
 
   auto* bi = fe.GetBlockInfo(20);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kToMerge);
 }
 
@@ -4602,13 +4602,13 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_ToMerge_FromIfThenElse) {
   // Then clause
   auto* bi20 = fe.GetBlockInfo(20);
   ASSERT_NE(bi20, nullptr);
-  EXPECT_EQ(bi20->succ_edge.count(99), 1);
+  EXPECT_EQ(bi20->succ_edge.count(99), 1u);
   EXPECT_EQ(bi20->succ_edge[99], EdgeKind::kToMerge);
 
   // Else clause
   auto* bi50 = fe.GetBlockInfo(50);
   ASSERT_NE(bi50, nullptr);
-  EXPECT_EQ(bi50->succ_edge.count(99), 1);
+  EXPECT_EQ(bi50->succ_edge.count(99), 1u);
   EXPECT_EQ(bi50->succ_edge[99], EdgeKind::kToMerge);
 }
 
@@ -4633,7 +4633,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_SwitchBreak_FromSwitchCaseDirect) {
 
   auto* bi = fe.GetBlockInfo(10);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kSwitchBreak);
 }
 
@@ -4658,7 +4658,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_SwitchBreak_FromSwitchCaseBody) {
 
   auto* bi = fe.GetBlockInfo(20);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kSwitchBreak);
 }
 
@@ -4686,7 +4686,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_SwitchBreak_FromSwitchDefaultBody) {
 
   auto* bi = fe.GetBlockInfo(30);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kSwitchBreak);
 }
 
@@ -4711,7 +4711,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_SwitchBreak_FromSwitchDefaultIsMerge) {
 
   auto* bi = fe.GetBlockInfo(10);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kSwitchBreak);
 }
 
@@ -4742,7 +4742,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_LoopBreak_FromLoopBody) {
 
   auto* bi = fe.GetBlockInfo(30);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kLoopBreak);
 }
 
@@ -4776,7 +4776,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_LoopBreak_FromContinueConstructTail) {
 
   auto* bi = fe.GetBlockInfo(60);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kLoopBreak);
 }
 
@@ -4807,7 +4807,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_LoopBreak_FromLoopBodyDirect) {
 
   auto* bi = fe.GetBlockInfo(30);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(99), 1);
+  EXPECT_EQ(bi->succ_edge.count(99), 1u);
   EXPECT_EQ(bi->succ_edge[99], EdgeKind::kLoopBreak);
 }
 
@@ -4838,7 +4838,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_LoopContinue_LoopBodyToContinue) {
 
   auto* bi = fe.GetBlockInfo(30);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(80), 1);
+  EXPECT_EQ(bi->succ_edge.count(80), 1u);
   EXPECT_EQ(bi->succ_edge[80], EdgeKind::kLoopContinue);
 }
 
@@ -4876,7 +4876,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_LoopContinue_FromNestedIf) {
 
   auto* bi = fe.GetBlockInfo(40);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(80), 1);
+  EXPECT_EQ(bi->succ_edge.count(80), 1u);
   EXPECT_EQ(bi->succ_edge[80], EdgeKind::kLoopContinue);
 }
 
@@ -4914,7 +4914,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_LoopContinue_ConditionalFromNestedIf) {
 
   auto* bi = fe.GetBlockInfo(40);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(80), 1);
+  EXPECT_EQ(bi->succ_edge.count(80), 1u);
   EXPECT_EQ(bi->succ_edge[80], EdgeKind::kLoopContinue);
 }
 
@@ -4953,7 +4953,7 @@ TEST_F(SpvParserTest,
 
   auto* bi = fe.GetBlockInfo(40);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(80), 1);
+  EXPECT_EQ(bi->succ_edge.count(80), 1u);
   EXPECT_EQ(bi->succ_edge[80], EdgeKind::kLoopContinue);
 }
 
@@ -5068,7 +5068,7 @@ TEST_F(SpvParserTest,
 
   auto* bi = fe.GetBlockInfo(40);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(80), 1);
+  EXPECT_EQ(bi->succ_edge.count(80), 1u);
   EXPECT_EQ(bi->succ_edge[80], EdgeKind::kLoopContinue);
 }
 
@@ -5108,7 +5108,7 @@ TEST_F(
 
   auto* bi = fe.GetBlockInfo(40);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(80), 1);
+  EXPECT_EQ(bi->succ_edge.count(80), 1u);
   EXPECT_EQ(bi->succ_edge[80], EdgeKind::kLoopContinue);
 }
 
@@ -5139,7 +5139,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Fallthrough_CaseTailToCase) {
 
   auto* bi = fe.GetBlockInfo(30);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(40), 1);
+  EXPECT_EQ(bi->succ_edge.count(40), 1u);
   EXPECT_EQ(bi->succ_edge[40], EdgeKind::kCaseFallThrough);
 }
 
@@ -5170,7 +5170,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Fallthrough_CaseTailToDefaultNotMerge) {
 
   auto* bi = fe.GetBlockInfo(30);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(40), 1);
+  EXPECT_EQ(bi->succ_edge.count(40), 1u);
   EXPECT_EQ(bi->succ_edge[40], EdgeKind::kCaseFallThrough);
 }
 
@@ -5201,7 +5201,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Fallthrough_DefaultToCase) {
 
   auto* bi = fe.GetBlockInfo(30);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(40), 1);
+  EXPECT_EQ(bi->succ_edge.count(40), 1u);
   EXPECT_EQ(bi->succ_edge[40], EdgeKind::kCaseFallThrough);
 }
 
@@ -5316,7 +5316,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Forward_IfToThen) {
 
   auto* bi = fe.GetBlockInfo(10);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(20), 1);
+  EXPECT_EQ(bi->succ_edge.count(20), 1u);
   EXPECT_EQ(bi->succ_edge[20], EdgeKind::kForward);
 }
 
@@ -5341,7 +5341,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Forward_IfToElse) {
 
   auto* bi = fe.GetBlockInfo(10);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(30), 1);
+  EXPECT_EQ(bi->succ_edge.count(30), 1u);
   EXPECT_EQ(bi->succ_edge[30], EdgeKind::kForward);
 }
 
@@ -5366,7 +5366,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Forward_SwitchToCase) {
 
   auto* bi = fe.GetBlockInfo(10);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(20), 1);
+  EXPECT_EQ(bi->succ_edge.count(20), 1u);
   EXPECT_EQ(bi->succ_edge[20], EdgeKind::kForward);
 }
 
@@ -5394,7 +5394,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Forward_SwitchToDefaultNotMerge) {
 
   auto* bi = fe.GetBlockInfo(10);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(30), 1);
+  EXPECT_EQ(bi->succ_edge.count(30), 1u);
   EXPECT_EQ(bi->succ_edge[30], EdgeKind::kForward);
 }
 
@@ -5425,7 +5425,7 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Forward_LoopHeadToBody) {
 
   auto* bi = fe.GetBlockInfo(20);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(30), 1);
+  EXPECT_EQ(bi->succ_edge.count(30), 1u);
   EXPECT_EQ(bi->succ_edge[30], EdgeKind::kForward);
 }
 
@@ -5713,9 +5713,9 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Pathological_Forward_LoopHeadSplitBody) {
 
   auto* bi = fe.GetBlockInfo(20);
   ASSERT_NE(bi, nullptr);
-  EXPECT_EQ(bi->succ_edge.count(30), 1);
+  EXPECT_EQ(bi->succ_edge.count(30), 1u);
   EXPECT_EQ(bi->succ_edge[30], EdgeKind::kForward);
-  EXPECT_EQ(bi->succ_edge.count(50), 1);
+  EXPECT_EQ(bi->succ_edge.count(50), 1u);
   EXPECT_EQ(bi->succ_edge[50], EdgeKind::kForward);
 }
 
@@ -5750,22 +5750,22 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Pathological_Forward_Premerge) {
 
   auto* bi20 = fe.GetBlockInfo(20);
   ASSERT_NE(bi20, nullptr);
-  EXPECT_EQ(bi20->succ_edge.count(50), 1);
+  EXPECT_EQ(bi20->succ_edge.count(50), 1u);
   EXPECT_EQ(bi20->succ_edge[50], EdgeKind::kForward);
 
   auto* bi30 = fe.GetBlockInfo(30);
   ASSERT_NE(bi30, nullptr);
-  EXPECT_EQ(bi30->succ_edge.count(50), 1);
+  EXPECT_EQ(bi30->succ_edge.count(50), 1u);
   EXPECT_EQ(bi30->succ_edge[50], EdgeKind::kForward);
 
   auto* bi50 = fe.GetBlockInfo(50);
   ASSERT_NE(bi50, nullptr);
-  EXPECT_EQ(bi50->succ_edge.count(60), 1);
+  EXPECT_EQ(bi50->succ_edge.count(60), 1u);
   EXPECT_EQ(bi50->succ_edge[60], EdgeKind::kForward);
 
   auto* bi60 = fe.GetBlockInfo(60);
   ASSERT_NE(bi60, nullptr);
-  EXPECT_EQ(bi60->succ_edge.count(99), 1);
+  EXPECT_EQ(bi60->succ_edge.count(99), 1u);
   EXPECT_EQ(bi60->succ_edge[99], EdgeKind::kToMerge);
 }
 
@@ -5791,12 +5791,12 @@ TEST_F(SpvParserTest, ClassifyCFGEdges_Pathological_Forward_Regardless) {
 
   auto* bi10 = fe.GetBlockInfo(10);
   ASSERT_NE(bi10, nullptr);
-  EXPECT_EQ(bi10->succ_edge.count(20), 1);
+  EXPECT_EQ(bi10->succ_edge.count(20), 1u);
   EXPECT_EQ(bi10->succ_edge[20], EdgeKind::kForward);
 
   auto* bi20 = fe.GetBlockInfo(20);
   ASSERT_NE(bi20, nullptr);
-  EXPECT_EQ(bi20->succ_edge.count(99), 1);
+  EXPECT_EQ(bi20->succ_edge.count(99), 1u);
   EXPECT_EQ(bi20->succ_edge[99], EdgeKind::kToMerge);
 }
 
diff --git a/src/reader/spirv/function_logical_test.cc b/src/reader/spirv/function_logical_test.cc
index bf480b07b3..040a59977e 100644
--- a/src/reader/spirv/function_logical_test.cc
+++ b/src/reader/spirv/function_logical_test.cc
@@ -229,7 +229,7 @@ TEST_F(SpvUnaryLogicalTest, LogicalNot_Vector) {
      OpReturn
      OpFunctionEnd
   )";
-  auto p = parser(test::Assemble(assembly));
+  auto* p = parser(test::Assemble(assembly));
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
   FunctionEmitter fe(p, *spirv_function(100));
   EXPECT_TRUE(fe.EmitBody()) << p->error();
diff --git a/src/writer/spirv/builder.cc b/src/writer/spirv/builder.cc
index 43e2172347..e8f0534e55 100644
--- a/src/writer/spirv/builder.cc
+++ b/src/writer/spirv/builder.cc
@@ -126,6 +126,10 @@ uint32_t IndexFromName(char name) {
 
 }  // namespace
 
+Builder::AccessorInfo::AccessorInfo() : source_id(0), source_type(nullptr) {}
+
+Builder::AccessorInfo::~AccessorInfo() {}
+
 Builder::Builder(ast::Module* mod) : mod_(mod), scope_stack_({}) {}
 
 Builder::~Builder() = default;
diff --git a/src/writer/spirv/builder.h b/src/writer/spirv/builder.h
index 823dcd9cec..2754b7fa45 100644
--- a/src/writer/spirv/builder.h
+++ b/src/writer/spirv/builder.h
@@ -40,15 +40,18 @@ class Builder {
  public:
   /// Contains information for generating accessor chains
   struct AccessorInfo {
+    AccessorInfo();
+    ~AccessorInfo();
+
     /// The ID of the current chain source. The chain source may change as we
     /// evaluate the access chain. The chain source always points to the ID
     /// which we will use to evaluate the current set of accessors. This maybe
     /// the original variable, or maybe an intermediary if we had to evaulate
     /// the access chain early (in the case of a swizzle of an access chain).
-    uint32_t source_id = 0;
+    uint32_t source_id;
     /// The type of the current chain source. This type matches the deduced
     /// result_type of the current source defined above.
-    ast::type::Type* source_type = nullptr;
+    ast::type::Type* source_type;
     /// A list of access chain indices to emit. Note, we _only_ have access
     /// chain indices if the source is pointer.
     std::vector<uint32_t> access_chain_indices;