diff --git a/src/reader/spirv/function.cc b/src/reader/spirv/function.cc
index 8ca69c7..2578e06 100644
--- a/src/reader/spirv/function.cc
+++ b/src/reader/spirv/function.cc
@@ -630,7 +630,7 @@
 bool FunctionEmitter::EmitBody() {
   RegisterBasicBlocks();
 
-  if (!TerminatorsAreSane()) {
+  if (!TerminatorsAreValid()) {
     return false;
   }
   if (!RegisterMerges()) {
@@ -674,7 +674,7 @@
   }
 }
 
-bool FunctionEmitter::TerminatorsAreSane() {
+bool FunctionEmitter::TerminatorsAreValid() {
   if (failed()) {
     return false;
   }
@@ -1261,7 +1261,7 @@
 
     for (const auto dest : successors) {
       const auto* dest_info = GetBlockInfo(dest);
-      // We've already checked terminators are sane.
+      // We've already checked terminators are valid.
       assert(dest_info);
       const auto dest_pos = dest_info->pos;
 
diff --git a/src/reader/spirv/function.h b/src/reader/spirv/function.h
index 32a062c..6d3ebb3 100644
--- a/src/reader/spirv/function.h
+++ b/src/reader/spirv/function.h
@@ -319,13 +319,13 @@
 
   /// Verifies that terminators only branch to labels in the current function.
   /// Assumes basic blocks have been registered.
-  /// @returns true if terminators are sane
-  bool TerminatorsAreSane();
+  /// @returns true if terminators are valid
+  bool TerminatorsAreValid();
 
   /// Populates merge-header cross-links and the |is_continue_entire_loop|
   /// member of BlockInfo.  Also verifies that merge instructions go to blocks
   /// in the same function.  Assumes basic blocks have been registered, and
-  /// terminators are sane.
+  /// terminators are valid.
   /// @returns false if registration fails
   bool RegisterMerges();
 
@@ -346,7 +346,7 @@
 
   /// Labels each basic block with its nearest enclosing structured construct.
   /// Populates the |construct| member of BlockInfo, and the |constructs_| list.
-  /// Assumes terminators are sane and merges have been registered, block
+  /// Assumes terminators are valid and merges have been registered, block
   /// order has been computed, and each block is labeled with its position.
   /// Checks nesting of structured control flow constructs.
   /// @returns false if bad nesting has been detected
diff --git a/src/reader/spirv/function_cfg_test.cc b/src/reader/spirv/function_cfg_test.cc
index 42961bc..0a2db84 100644
--- a/src/reader/spirv/function_cfg_test.cc
+++ b/src/reader/spirv/function_cfg_test.cc
@@ -122,7 +122,7 @@
   return fe->FindIfSelectionInternalHeaders();
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_SingleBlock) {
+TEST_F(SpvParserTest, TerminatorsAreValid_SingleBlock) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -134,10 +134,10 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_TRUE(fe.TerminatorsAreSane());
+  EXPECT_TRUE(fe.TerminatorsAreValid());
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_Sequence) {
+TEST_F(SpvParserTest, TerminatorsAreValid_Sequence) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -152,10 +152,10 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_TRUE(fe.TerminatorsAreSane()) << p->error();
+  EXPECT_TRUE(fe.TerminatorsAreValid()) << p->error();
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_If) {
+TEST_F(SpvParserTest, TerminatorsAreValid_If) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -177,10 +177,10 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_TRUE(fe.TerminatorsAreSane()) << p->error();
+  EXPECT_TRUE(fe.TerminatorsAreValid()) << p->error();
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_Switch) {
+TEST_F(SpvParserTest, TerminatorsAreValid_Switch) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -205,10 +205,10 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_TRUE(fe.TerminatorsAreSane());
+  EXPECT_TRUE(fe.TerminatorsAreValid());
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_Loop_SingleBlock) {
+TEST_F(SpvParserTest, TerminatorsAreValid_Loop_SingleBlock) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -227,10 +227,10 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_TRUE(fe.TerminatorsAreSane());
+  EXPECT_TRUE(fe.TerminatorsAreValid());
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_Loop_Simple) {
+TEST_F(SpvParserTest, TerminatorsAreValid_Loop_Simple) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -255,10 +255,10 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_TRUE(fe.TerminatorsAreSane());
+  EXPECT_TRUE(fe.TerminatorsAreValid());
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_Kill) {
+TEST_F(SpvParserTest, TerminatorsAreValid_Kill) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -270,10 +270,10 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_TRUE(fe.TerminatorsAreSane());
+  EXPECT_TRUE(fe.TerminatorsAreValid());
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_Unreachable) {
+TEST_F(SpvParserTest, TerminatorsAreValid_Unreachable) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -285,10 +285,10 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_TRUE(fe.TerminatorsAreSane());
+  EXPECT_TRUE(fe.TerminatorsAreValid());
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_MissingTerminator) {
+TEST_F(SpvParserTest, TerminatorsAreValid_MissingTerminator) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -300,7 +300,7 @@
   EXPECT_FALSE(p->BuildAndParseInternalModuleExceptFunctions());
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_DisallowLoopToEntryBlock) {
+TEST_F(SpvParserTest, TerminatorsAreValid_DisallowLoopToEntryBlock) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -315,11 +315,11 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_FALSE(fe.TerminatorsAreSane());
+  EXPECT_FALSE(fe.TerminatorsAreValid());
   EXPECT_THAT(p->error(), Eq("Block 20 branches to function entry block 10"));
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_DisallowNonBlock) {
+TEST_F(SpvParserTest, TerminatorsAreValid_DisallowNonBlock) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -331,13 +331,13 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_FALSE(fe.TerminatorsAreSane());
+  EXPECT_FALSE(fe.TerminatorsAreValid());
   EXPECT_THAT(p->error(),
               Eq("Block 10 in function 100 branches to 999 which is "
                  "not a block in the function"));
 }
 
-TEST_F(SpvParserTest, TerminatorsAreSane_DisallowBlockInDifferentFunction) {
+TEST_F(SpvParserTest, TerminatorsAreValid_DisallowBlockInDifferentFunction) {
   auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
 
@@ -357,7 +357,7 @@
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
   FunctionEmitter fe(p, *spirv_function(100));
   fe.RegisterBasicBlocks();
-  EXPECT_FALSE(fe.TerminatorsAreSane());
+  EXPECT_FALSE(fe.TerminatorsAreValid());
   EXPECT_THAT(p->error(), Eq("Block 10 in function 100 branches to 210 which "
                              "is not a block in the function"));
 }
diff --git a/src/reader/spirv/parser_impl.h b/src/reader/spirv/parser_impl.h
index 953ff14..f1bcd64 100644
--- a/src/reader/spirv/parser_impl.h
+++ b/src/reader/spirv/parser_impl.h
@@ -55,7 +55,7 @@
 
 /// An AST expression with its type.
 struct TypedExpression {
-  /// Dummy constructor
+  /// Constructor
   TypedExpression();
   /// Constructor
   /// @param t the type