diff --git a/BUILD.gn b/BUILD.gn
index a3b566b..04bf5dc 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -13,12 +13,14 @@
 # limitations under the License.
 
 import("//build_overrides/build.gni")
+import("//testing/test.gni")
 import("tint_overrides_with_defaults.gni")
 
+###############################################################################
+# Common - Configs, etc. shared across targets
+###############################################################################
+
 config("tint_common_config") {
-  cflags = []
-  ldflags = []
-  include_dirs = []
   defines = []
 
   if (tint_build_spv_reader) {
@@ -46,15 +48,20 @@
   }
 }
 
-# libtint source sets are divided into a non-optional core in :libtint_core and
-# optional :libtint_* subsets, because ninja does not like having multiple source
-# files with the same name, like function.cc, in the same source set target.
+###############################################################################
+# Library - Tint core and optional modules of libtint
+###############################################################################
+# libtint source sets are divided into a non-optional core in :libtint_core_src
+# and optional :libtint_*_src subsets, because ninja does not like having
+# multiple source files with the same name, like function.cc, in the same
+# source set
+# target.
 #
-# Targets that want to use tint as a library should depend on ":libtint" and use
-# the build flags to control what is included, instead of trying to specify the
-# subsets that they want.
+# Targets that want to use tint as a library should depend on ":libtint" and
+# use the build flags to control what is included, instead of trying to specify
+# the subsets that they want.
 
-source_set("libtint_core") {
+source_set("libtint_core_src") {
   sources = [
     "src/ast/array_accessor_expression.cc",
     "src/ast/array_accessor_expression.h",
@@ -224,7 +231,7 @@
   }
 }
 
-config("tint_spv_reader_config") {
+config("libtint_spv_config") {
   include_dirs = [
     "${tint_spirv_tools_dir}/",
     "${tint_spirv_tools_dir}/include",
@@ -232,7 +239,7 @@
   ]
 }
 
-source_set("libtint_spv_reader") {
+source_set("libtint_spv_reader_src") {
   sources = [
     "src/reader/spirv/enum_converter.cc",
     "src/reader/spirv/enum_converter.h",
@@ -253,8 +260,10 @@
     "${tint_spirv_tools_dir}/:spvtools_val",
   ]
 
-  configs += [ ":tint_common_config" ]
-  configs += [ ":tint_spv_reader_config" ]
+  configs += [
+    ":tint_common_config",
+    ":libtint_spv_config",
+  ]
 
   if (build_with_chromium) {
     configs -= [ "//build/config/compiler:chromium_code" ]
@@ -262,7 +271,7 @@
   }
 }
 
-source_set("libtint_spv_writer") {
+source_set("libtint_spv_writer_src") {
   sources = [
     "src/writer/spirv/binary_writer.cc",
     "src/writer/spirv/binary_writer.h",
@@ -280,7 +289,10 @@
 
   deps = [ "${tint_spirv_headers_dir}/:spv_headers" ]
 
-  configs += [ ":tint_common_config" ]
+  configs += [
+    ":tint_common_config",
+    ":libtint_spv_config",
+  ]
 
   if (build_with_chromium) {
     configs -= [ "//build/config/compiler:chromium_code" ]
@@ -288,7 +300,7 @@
   }
 }
 
-source_set("libtint_wgsl_reader") {
+source_set("libtint_wgsl_reader_src") {
   sources = [
     "src/reader/wgsl/lexer.cc",
     "src/reader/wgsl/lexer.h",
@@ -308,7 +320,7 @@
   }
 }
 
-source_set("libtint_wgsl_writer") {
+source_set("libtint_wgsl_writer_src") {
   sources = [
     "src/writer/wgsl/generator.cc",
     "src/writer/wgsl/generator.h",
@@ -325,22 +337,22 @@
 }
 
 source_set("libtint") {
-  deps = [ ":libtint_core" ]
+  deps = [ ":libtint_core_src" ]
 
   if (tint_build_spv_reader) {
-    deps += [ ":libtint_spv_reader" ]
+    deps += [ ":libtint_spv_reader_src" ]
   }
 
   if (tint_build_spv_writer) {
-    deps += [ ":libtint_spv_writer" ]
+    deps += [ ":libtint_spv_writer_src" ]
   }
 
   if (tint_build_wgsl_reader) {
-    deps += [ ":libtint_wgsl_reader" ]
+    deps += [ ":libtint_wgsl_reader_src" ]
   }
 
   if (tint_build_wgsl_writer) {
-    deps += [ ":libtint_wgsl_writer" ]
+    deps += [ ":libtint_wgsl_writer_src" ]
   }
 
   configs += [ ":tint_common_config" ]
@@ -351,6 +363,408 @@
   }
 }
 
+###############################################################################
+# Gtest Gmock - Handle building inside and outside of Chromium.
+###############################################################################
+# When building outside of Chromium we need to define our own targets for GTest
+# and GMock. However when compiling inside of Chromium we need to reuse the
+# existing targets, both because Chromium has a special harness for swarming
+# and because otherwise the "gn check" fails.
+
+if (!build_with_chromium) {
+  # When we aren't in Chromium we define out own targets based on the location
+  # of the googletest repo.
+  config("gtest_config") {
+    include_dirs = [
+      "${tint_googletest_dir}/googletest",
+      "${tint_googletest_dir}/googletest/include",
+    ]
+  }
+  static_library("gtest") {
+    testonly = true
+    sources = [ "${tint_googletest_dir}/googletest/src/gtest-all.cc" ]
+    public_configs = [ ":gtest_config" ]
+  }
+
+  config("gmock_config") {
+    include_dirs = [
+      "${tint_googletest_dir}/googlemock",
+      "${tint_googletest_dir}/googlemock/include",
+      "${tint_googletest_dir}/googletest/include",
+    ]
+  }
+
+  static_library("gmock") {
+    testonly = true
+    sources = [
+      "${tint_googletest_dir}/googlemock/src/gmock-all.cc",
+      "${tint_googletest_dir}/googlemock/src/gmock_main.cc",
+    ]
+    public_configs = [ ":gmock_config" ]
+  }
+
+  group("gmock_and_gtest") {
+    testonly = true
+    public_deps = [
+      ":gmock",
+      ":gtest",
+    ]
+  }
+} else {
+  # When we are in Chromium we reuse its targets, and also add some deps that
+  # are needed to launch the test in swarming mode.
+  group("gmock_and_gtest") {
+    testonly = true
+    public_deps = [
+      "//base",
+      "//base/test:test_support",
+      "//testing/gmock",
+      "//testing/gtest",
+    ]
+  }
+}
+
+###############################################################################
+# Tests - For libtint core and optional modules
+###############################################################################
+config("tint_unittests_config") {
+  include_dirs = [
+    "${tint_googletest_dir}/googlemock/include",
+    "${tint_googletest_dir}/googletest/include",
+  ]
+}
+
+source_set("tint_unittests_core_src") {
+  sources = [
+    "src/ast/array_accessor_expression_test.cc",
+    "src/ast/as_expression_test.cc",
+    "src/ast/assignment_statement_test.cc",
+    "src/ast/binary_expression_test.cc",
+    "src/ast/binding_decoration_test.cc",
+    "src/ast/bool_literal_test.cc",
+    "src/ast/break_statement_test.cc",
+    "src/ast/builtin_decoration_test.cc",
+    "src/ast/call_expression_test.cc",
+    "src/ast/case_statement_test.cc",
+    "src/ast/cast_expression_test.cc",
+    "src/ast/continue_statement_test.cc",
+    "src/ast/decorated_variable_test.cc",
+    "src/ast/else_statement_test.cc",
+    "src/ast/entry_point_test.cc",
+    "src/ast/fallthrough_statement_test.cc",
+    "src/ast/float_literal_test.cc",
+    "src/ast/function_test.cc",
+    "src/ast/identifier_expression_test.cc",
+    "src/ast/if_statement_test.cc",
+    "src/ast/import_test.cc",
+    "src/ast/int_literal_test.cc",
+    "src/ast/kill_statement_test.cc",
+    "src/ast/location_decoration_test.cc",
+    "src/ast/loop_statement_test.cc",
+    "src/ast/member_accessor_expression_test.cc",
+    "src/ast/module_test.cc",
+    "src/ast/nop_statement_test.cc",
+    "src/ast/return_statement_test.cc",
+    "src/ast/scalar_constructor_expression_test.cc",
+    "src/ast/set_decoration_test.cc",
+    "src/ast/struct_member_offset_decoration_test.cc",
+    "src/ast/struct_member_test.cc",
+    "src/ast/struct_test.cc",
+    "src/ast/switch_statement_test.cc",
+    "src/ast/type/alias_type_test.cc",
+    "src/ast/type/array_type_test.cc",
+    "src/ast/type/bool_type_test.cc",
+    "src/ast/type/f32_type_test.cc",
+    "src/ast/type/i32_type_test.cc",
+    "src/ast/type/matrix_type_test.cc",
+    "src/ast/type/pointer_type_test.cc",
+    "src/ast/type/struct_type_test.cc",
+    "src/ast/type/u32_type_test.cc",
+    "src/ast/type/vector_type_test.cc",
+    "src/ast/type_constructor_expression_test.cc",
+    "src/ast/uint_literal_test.cc",
+    "src/ast/unary_derivative_expression_test.cc",
+    "src/ast/unary_method_expression_test.cc",
+    "src/ast/unary_op_expression_test.cc",
+    "src/ast/unless_statement_test.cc",
+    "src/ast/variable_decl_statement_test.cc",
+    "src/ast/variable_test.cc",
+    "src/scope_stack_test.cc",
+    "src/type_determiner_test.cc",
+    "src/type_manager_test.cc",
+    "src/validator_impl_import_test.cc",
+  ]
+
+  configs += [
+    ":tint_common_config",
+    ":tint_unittests_config",
+  ]
+
+  if (build_with_chromium) {
+    configs -= [ "//build/config/compiler:chromium_code" ]
+    configs += [ "//build/config/compiler:no_chromium_code" ]
+  }
+}
+
+source_set("tint_unittests_spv_reader_src") {
+  sources = [
+    "src/reader/spirv/enum_converter_test.cc",
+    "src/reader/spirv/fail_stream_test.cc",
+    "src/reader/spirv/function_arithmetic_test.cc",
+    "src/reader/spirv/function_decl_test.cc",
+    "src/reader/spirv/function_logical_test.cc",
+    "src/reader/spirv/function_memory_test.cc",
+    "src/reader/spirv/function_var_test.cc",
+    "src/reader/spirv/namer_test.cc",
+    "src/reader/spirv/parser_impl_convert_member_decoration_test.cc",
+    "src/reader/spirv/parser_impl_convert_type_test.cc",
+    "src/reader/spirv/parser_impl_entry_point_test.cc",
+    "src/reader/spirv/parser_impl_function_decl_test.cc",
+    "src/reader/spirv/parser_impl_get_decorations_test.cc",
+    "src/reader/spirv/parser_impl_import_test.cc",
+    "src/reader/spirv/parser_impl_module_var_test.cc",
+    "src/reader/spirv/parser_impl_named_types_test.cc",
+    "src/reader/spirv/parser_impl_test.cc",
+    "src/reader/spirv/parser_impl_user_name_test.cc",
+    "src/reader/spirv/parser_test.cc",
+    "src/reader/spirv/spirv_tools_helpers_test.cc",
+    "src/reader/spirv/spirv_tools_helpers_test.h",
+  ]
+
+  deps = [ "${tint_spirv_headers_dir}/:spv_headers" ]
+
+  configs += [
+    ":libtint_spv_config",
+    ":tint_common_config",
+    ":tint_unittests_config",
+  ]
+
+  if (build_with_chromium) {
+    configs -= [ "//build/config/compiler:chromium_code" ]
+    configs += [ "//build/config/compiler:no_chromium_code" ]
+  }
+}
+
+source_set("tint_unittests_spv_writer_src") {
+  sources = [
+    "src/writer/spirv/binary_writer_test.cc",
+    "src/writer/spirv/builder_assign_test.cc",
+    "src/writer/spirv/builder_binary_expression_test.cc",
+    "src/writer/spirv/builder_constructor_expression_test.cc",
+    "src/writer/spirv/builder_entry_point_test.cc",
+    "src/writer/spirv/builder_function_test.cc",
+    "src/writer/spirv/builder_function_variable_test.cc",
+    "src/writer/spirv/builder_global_variable_test.cc",
+    "src/writer/spirv/builder_ident_expression_test.cc",
+    "src/writer/spirv/builder_if_test.cc",
+    "src/writer/spirv/builder_literal_test.cc",
+    "src/writer/spirv/builder_return_test.cc",
+    "src/writer/spirv/builder_test.cc",
+    "src/writer/spirv/builder_type_test.cc",
+    "src/writer/spirv/instruction_test.cc",
+    "src/writer/spirv/operand_test.cc",
+    "src/writer/spirv/spv_dump.cc",
+    "src/writer/spirv/spv_dump.h",
+  ]
+  deps = [ "${tint_spirv_headers_dir}/:spv_headers" ]
+
+  configs += [
+    ":libtint_spv_config",
+    ":tint_common_config",
+    ":tint_unittests_config",
+  ]
+
+  if (build_with_chromium) {
+    configs -= [ "//build/config/compiler:chromium_code" ]
+    configs += [ "//build/config/compiler:no_chromium_code" ]
+  }
+}
+
+source_set("tint_unittests_wgsl_reader_src") {
+  sources = [
+    "src/reader/wgsl/lexer_test.cc",
+    "src/reader/wgsl/parser_impl_additive_expression_test.cc",
+    "src/reader/wgsl/parser_impl_and_expression_test.cc",
+    "src/reader/wgsl/parser_impl_argument_expression_list_test.cc",
+    "src/reader/wgsl/parser_impl_assignment_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_body_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_break_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_builtin_decoration_test.cc",
+    "src/reader/wgsl/parser_impl_case_body_test.cc",
+    "src/reader/wgsl/parser_impl_const_expr_test.cc",
+    "src/reader/wgsl/parser_impl_const_literal_test.cc",
+    "src/reader/wgsl/parser_impl_continue_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_continuing_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_derivative_modifier_test.cc",
+    "src/reader/wgsl/parser_impl_else_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_elseif_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_entry_point_decl_test.cc",
+    "src/reader/wgsl/parser_impl_equality_expression_test.cc",
+    "src/reader/wgsl/parser_impl_exclusive_or_expression_test.cc",
+    "src/reader/wgsl/parser_impl_function_decl_test.cc",
+    "src/reader/wgsl/parser_impl_function_header_test.cc",
+    "src/reader/wgsl/parser_impl_function_type_decl_test.cc",
+    "src/reader/wgsl/parser_impl_global_constant_decl_test.cc",
+    "src/reader/wgsl/parser_impl_global_decl_test.cc",
+    "src/reader/wgsl/parser_impl_global_variable_decl_test.cc",
+    "src/reader/wgsl/parser_impl_if_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_import_decl_test.cc",
+    "src/reader/wgsl/parser_impl_inclusive_or_expression_test.cc",
+    "src/reader/wgsl/parser_impl_logical_and_expression_test.cc",
+    "src/reader/wgsl/parser_impl_logical_or_expression_test.cc",
+    "src/reader/wgsl/parser_impl_loop_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_multiplicative_expression_test.cc",
+    "src/reader/wgsl/parser_impl_param_list_test.cc",
+    "src/reader/wgsl/parser_impl_paren_rhs_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_pipeline_stage_test.cc",
+    "src/reader/wgsl/parser_impl_postfix_expression_test.cc",
+    "src/reader/wgsl/parser_impl_primary_expression_test.cc",
+    "src/reader/wgsl/parser_impl_relational_expression_test.cc",
+    "src/reader/wgsl/parser_impl_shift_expression_test.cc",
+    "src/reader/wgsl/parser_impl_statement_test.cc",
+    "src/reader/wgsl/parser_impl_statements_test.cc",
+    "src/reader/wgsl/parser_impl_storage_class_test.cc",
+    "src/reader/wgsl/parser_impl_struct_body_decl_test.cc",
+    "src/reader/wgsl/parser_impl_struct_decl_test.cc",
+    "src/reader/wgsl/parser_impl_struct_decoration_decl_test.cc",
+    "src/reader/wgsl/parser_impl_struct_decoration_test.cc",
+    "src/reader/wgsl/parser_impl_struct_member_decoration_decl_test.cc",
+    "src/reader/wgsl/parser_impl_struct_member_decoration_test.cc",
+    "src/reader/wgsl/parser_impl_struct_member_test.cc",
+    "src/reader/wgsl/parser_impl_switch_body_test.cc",
+    "src/reader/wgsl/parser_impl_switch_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_test.cc",
+    "src/reader/wgsl/parser_impl_test_helper.cc",
+    "src/reader/wgsl/parser_impl_test_helper.h",
+    "src/reader/wgsl/parser_impl_type_alias_test.cc",
+    "src/reader/wgsl/parser_impl_type_decl_test.cc",
+    "src/reader/wgsl/parser_impl_unary_expression_test.cc",
+    "src/reader/wgsl/parser_impl_unless_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_variable_decl_test.cc",
+    "src/reader/wgsl/parser_impl_variable_decoration_list_test.cc",
+    "src/reader/wgsl/parser_impl_variable_decoration_test.cc",
+    "src/reader/wgsl/parser_impl_variable_ident_decl_test.cc",
+    "src/reader/wgsl/parser_impl_variable_stmt_test.cc",
+    "src/reader/wgsl/parser_impl_variable_storage_decoration_test.cc",
+    "src/reader/wgsl/parser_test.cc",
+    "src/reader/wgsl/token_test.cc",
+  ]
+
+  configs += [
+    ":tint_common_config",
+    ":tint_unittests_config",
+  ]
+
+  if (build_with_chromium) {
+    configs -= [ "//build/config/compiler:chromium_code" ]
+    configs += [ "//build/config/compiler:no_chromium_code" ]
+  }
+}
+
+source_set("tint_unittests_wgsl_writer_src") {
+  sources = [
+    "src/writer/wgsl/generator_impl_alias_type_test.cc",
+    "src/writer/wgsl/generator_impl_array_accessor_test.cc",
+    "src/writer/wgsl/generator_impl_as_test.cc",
+    "src/writer/wgsl/generator_impl_assign_test.cc",
+    "src/writer/wgsl/generator_impl_break_test.cc",
+    "src/writer/wgsl/generator_impl_call_test.cc",
+    "src/writer/wgsl/generator_impl_case_test.cc",
+    "src/writer/wgsl/generator_impl_cast_test.cc",
+    "src/writer/wgsl/generator_impl_constructor_test.cc",
+    "src/writer/wgsl/generator_impl_continue_test.cc",
+    "src/writer/wgsl/generator_impl_else_test.cc",
+    "src/writer/wgsl/generator_impl_entry_point_test.cc",
+    "src/writer/wgsl/generator_impl_fallthrough_test.cc",
+    "src/writer/wgsl/generator_impl_function_test.cc",
+    "src/writer/wgsl/generator_impl_identifier_test.cc",
+    "src/writer/wgsl/generator_impl_if_test.cc",
+    "src/writer/wgsl/generator_impl_import_test.cc",
+    "src/writer/wgsl/generator_impl_kill_test.cc",
+    "src/writer/wgsl/generator_impl_loop_test.cc",
+    "src/writer/wgsl/generator_impl_member_accessor_test.cc",
+    "src/writer/wgsl/generator_impl_nop_test.cc",
+    "src/writer/wgsl/generator_impl_relational_test.cc",
+    "src/writer/wgsl/generator_impl_return_test.cc",
+    "src/writer/wgsl/generator_impl_switch_test.cc",
+    "src/writer/wgsl/generator_impl_test.cc",
+    "src/writer/wgsl/generator_impl_type_test.cc",
+    "src/writer/wgsl/generator_impl_unary_derivative_test.cc",
+    "src/writer/wgsl/generator_impl_unary_method_test.cc",
+    "src/writer/wgsl/generator_impl_unary_op_test.cc",
+    "src/writer/wgsl/generator_impl_unless_test.cc",
+    "src/writer/wgsl/generator_impl_variable_decl_statement_test.cc",
+    "src/writer/wgsl/generator_impl_variable_test.cc",
+  ]
+
+  configs += [
+    ":tint_common_config",
+    ":tint_unittests_config",
+  ]
+
+  if (build_with_chromium) {
+    configs -= [ "//build/config/compiler:chromium_code" ]
+    configs += [ "//build/config/compiler:no_chromium_code" ]
+  }
+}
+
+source_set("tint_unittests_src") {
+  deps = [ ":tint_unittests_core_src" ]
+
+  if (tint_build_spv_reader) {
+    deps += [ ":tint_unittests_spv_reader_src" ]
+  }
+
+  if (tint_build_spv_writer) {
+    deps += [ ":tint_unittests_spv_writer_src" ]
+  }
+
+  if (tint_build_wgsl_reader) {
+    deps += [ ":tint_unittests_wgsl_reader_src" ]
+  }
+
+  if (tint_build_wgsl_writer) {
+    deps += [ ":tint_unittests_wgsl_writer_src" ]
+  }
+
+  configs += [
+    ":tint_common_config",
+    ":tint_unittests_config",
+  ]
+
+  if (build_with_chromium) {
+    configs -= [ "//build/config/compiler:chromium_code" ]
+    configs += [ "//build/config/compiler:no_chromium_code" ]
+  }
+}
+
+test("tint_unittests") {
+  deps = [
+    ":gmock_and_gtest",
+    ":libtint",
+    ":tint_unittests_src",
+  ]
+
+  # TODO(rharrison): Use main() from chromium for chromium tree builds. This
+  # requires adding a file to //gpu like Dawn has done.
+
+  configs += [
+    ":tint_common_config",
+    ":tint_unittests_config",
+  ]
+
+  if (build_with_chromium) {
+    configs -= [ "//build/config/compiler:chromium_code" ]
+    configs += [ "//build/config/compiler:no_chromium_code" ]
+  }
+
+  testonly = true
+}
+
+###############################################################################
+# Samples - Executables exposing command line functionality
+###############################################################################
+
 config("tint_exe_config") {
   include_dirs = []
   if (tint_build_spv_reader || tint_build_spv_writer) {
@@ -363,7 +777,7 @@
   deps = [ ":libtint" ]
 
   if (tint_build_spv_reader || tint_build_spv_writer) {
-    deps += ["${tint_spirv_headers_dir}/:spv_headers" ]
+    deps += [ "${tint_spirv_headers_dir}/:spv_headers" ]
   }
 
   configs += [ ":tint_common_config" ]
@@ -374,7 +788,3 @@
     configs += [ "//build/config/compiler:no_chromium_code" ]
   }
 }
-
-group("tint_all") {
-  deps = [ ":tint_exe" ]
-}
diff --git a/DEPS b/DEPS
index 8cad279..a4e62d5 100644
--- a/DEPS
+++ b/DEPS
@@ -9,18 +9,16 @@
   'buildtools_revision': '74cfb57006f83cfe050817526db359d5c8a11628',
   'clang_revision': '3605577b67603ec5776afcfada9e0ff4ea05cf0e',
   'cpplint_revision': '305ac8725a166ed42e3f5dd3f80d6de2cf840ef1',
-  'googletest_revision': '482ac6ee63429af2aa9c44f4e6427873fb68fb1f',
+  'googletest_revision': 'dcc92d0ab6c4ce022162a23566d44f673251eee4',
   'spirv_headers_revision': 'f8bf11a0253a32375c32cad92c841237b96696c0',
   'spirv_tools_revision': '60104cd97446877dad8ed1010a635218937a2f18',
+  'testing_revision': 'e5ced5141379ee8ae28b4f93d3c02df039d2b052',
 }
 
 deps = {
   'third_party/cpplint': Var('chromium_git') + Var('github') +
       '/google/styleguide.git@' + Var('cpplint_revision'),
 
-  'third_party/googletest': Var('chromium_git') + Var('github') +
-      '/google/googletest.git@' + Var('googletest_revision'),
-
   'third_party/spirv-headers': Var('chromium_git') + Var('github') +
       '/KhronosGroup/SPIRV-Headers.git@' + Var('spirv_headers_revision'),
 
@@ -39,6 +37,13 @@
 
   'third_party/binutils': Var('chromium_git') +
       '/chromium/src/third_party/binutils@' + Var('binutils_revision'),
+
+  # Dependencies required for testing
+  'testing': Var('chromium_git') + '/chromium/src/testing@' +
+      Var('testing_revision'),
+
+  'third_party/googletest': Var('chromium_git') + Var('github') +
+      '/google/googletest.git@' + Var('googletest_revision'),
 }
 
 hooks = [
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9a1077b..9d2c2fe 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -402,6 +402,7 @@
     reader/wgsl/parser_impl_switch_body_test.cc
     reader/wgsl/parser_impl_switch_stmt_test.cc
     reader/wgsl/parser_impl_test.cc
+    reader/wgsl/parser_impl_test_helper.cc
     reader/wgsl/parser_impl_test_helper.h
     reader/wgsl/parser_impl_type_alias_test.cc
     reader/wgsl/parser_impl_type_decl_test.cc
diff --git a/src/ast/array_accessor_expression_test.cc b/src/ast/array_accessor_expression_test.cc
index 833e46f..a08a837 100644
--- a/src/ast/array_accessor_expression_test.cc
+++ b/src/ast/array_accessor_expression_test.cc
@@ -27,8 +27,8 @@
   auto ary = std::make_unique<IdentifierExpression>("ary");
   auto idx = std::make_unique<IdentifierExpression>("idx");
 
-  auto ary_ptr = ary.get();
-  auto idx_ptr = idx.get();
+  auto* ary_ptr = ary.get();
+  auto* idx_ptr = idx.get();
 
   ArrayAccessorExpression exp(std::move(ary), std::move(idx));
   ASSERT_EQ(exp.array(), ary_ptr);
@@ -40,8 +40,8 @@
 
   ArrayAccessorExpression exp(Source{20, 2}, std::move(ary), std::move(idx));
   auto src = exp.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(ArrayAccessorExpressionTest, IsArrayAccessor) {
diff --git a/src/ast/as_expression_test.cc b/src/ast/as_expression_test.cc
index e41c0ba..e29a89d 100644
--- a/src/ast/as_expression_test.cc
+++ b/src/ast/as_expression_test.cc
@@ -28,7 +28,7 @@
   type::F32Type f32;
   auto expr = std::make_unique<IdentifierExpression>("expr");
 
-  auto expr_ptr = expr.get();
+  auto* expr_ptr = expr.get();
 
   AsExpression exp(&f32, std::move(expr));
   ASSERT_EQ(exp.type(), &f32);
@@ -41,8 +41,8 @@
 
   AsExpression exp(Source{20, 2}, &f32, std::move(expr));
   auto src = exp.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(AsExpressionTest, IsAs) {
diff --git a/src/ast/assignment_statement_test.cc b/src/ast/assignment_statement_test.cc
index f8959e3..85a29d6 100644
--- a/src/ast/assignment_statement_test.cc
+++ b/src/ast/assignment_statement_test.cc
@@ -27,8 +27,8 @@
   auto lhs = std::make_unique<ast::IdentifierExpression>("lhs");
   auto rhs = std::make_unique<ast::IdentifierExpression>("rhs");
 
-  auto lhs_ptr = lhs.get();
-  auto rhs_ptr = rhs.get();
+  auto* lhs_ptr = lhs.get();
+  auto* rhs_ptr = rhs.get();
 
   AssignmentStatement stmt(std::move(lhs), std::move(rhs));
   EXPECT_EQ(stmt.lhs(), lhs_ptr);
@@ -41,8 +41,8 @@
 
   AssignmentStatement stmt(Source{20, 2}, std::move(lhs), std::move(rhs));
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(AssignmentStatementTest, IsAssign) {
diff --git a/src/ast/binary_expression_test.cc b/src/ast/binary_expression_test.cc
index 0ca73aa..b7c50b1 100644
--- a/src/ast/binary_expression_test.cc
+++ b/src/ast/binary_expression_test.cc
@@ -29,8 +29,8 @@
   auto lhs = std::make_unique<IdentifierExpression>("lhs");
   auto rhs = std::make_unique<IdentifierExpression>("rhs");
 
-  auto lhs_ptr = lhs.get();
-  auto rhs_ptr = rhs.get();
+  auto* lhs_ptr = lhs.get();
+  auto* rhs_ptr = rhs.get();
 
   BinaryExpression r(BinaryOp::kEqual, std::move(lhs), std::move(rhs));
   EXPECT_EQ(r.lhs(), lhs_ptr);
@@ -45,8 +45,8 @@
   BinaryExpression r(Source{20, 2}, BinaryOp::kEqual, std::move(lhs),
                      std::move(rhs));
   auto src = r.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(BinaryExpressionTest, IsBinaryal) {
diff --git a/src/ast/binding_decoration_test.cc b/src/ast/binding_decoration_test.cc
index 71fefdf..677fd69 100644
--- a/src/ast/binding_decoration_test.cc
+++ b/src/ast/binding_decoration_test.cc
@@ -24,7 +24,7 @@
 
 TEST_F(BindingDecorationTest, Creation) {
   BindingDecoration d{2};
-  EXPECT_EQ(2, d.value());
+  EXPECT_EQ(2u, d.value());
 }
 
 TEST_F(BindingDecorationTest, Is) {
diff --git a/src/ast/break_statement_test.cc b/src/ast/break_statement_test.cc
index 87ace59..49df1ba 100644
--- a/src/ast/break_statement_test.cc
+++ b/src/ast/break_statement_test.cc
@@ -32,7 +32,7 @@
 
 TEST_F(BreakStatementTest, CreationWithConditional) {
   auto expr = std::make_unique<IdentifierExpression>("expr");
-  auto expr_ptr = expr.get();
+  auto* expr_ptr = expr.get();
 
   BreakStatement stmt(StatementCondition::kIf, std::move(expr));
   EXPECT_EQ(stmt.condition(), StatementCondition::kIf);
@@ -42,8 +42,8 @@
 TEST_F(BreakStatementTest, Creation_WithSource) {
   BreakStatement stmt(Source{20, 2});
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(BreakStatementTest, Creation_WithSourceAndCondition) {
@@ -52,8 +52,8 @@
   BreakStatement stmt(Source{20, 2}, StatementCondition::kUnless,
                       std::move(expr));
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(BreakStatementTest, IsBreak) {
diff --git a/src/ast/call_expression_test.cc b/src/ast/call_expression_test.cc
index e88627f..a89441f 100644
--- a/src/ast/call_expression_test.cc
+++ b/src/ast/call_expression_test.cc
@@ -29,15 +29,15 @@
   params.push_back(std::make_unique<IdentifierExpression>("param1"));
   params.push_back(std::make_unique<IdentifierExpression>("param2"));
 
-  auto func_ptr = func.get();
-  auto param1_ptr = params[0].get();
-  auto param2_ptr = params[1].get();
+  auto* func_ptr = func.get();
+  auto* param1_ptr = params[0].get();
+  auto* param2_ptr = params[1].get();
 
   CallExpression stmt(std::move(func), std::move(params));
   EXPECT_EQ(stmt.func(), func_ptr);
 
   const auto& vec = stmt.params();
-  ASSERT_EQ(vec.size(), 2);
+  ASSERT_EQ(vec.size(), 2u);
   EXPECT_EQ(vec[0].get(), param1_ptr);
   EXPECT_EQ(vec[1].get(), param2_ptr);
 }
@@ -46,8 +46,8 @@
   auto func = std::make_unique<IdentifierExpression>("func");
   CallExpression stmt(Source{20, 2}, std::move(func), {});
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(CallExpressionTest, IsCall) {
diff --git a/src/ast/case_statement_test.cc b/src/ast/case_statement_test.cc
index b88b0fe..8aad2ba 100644
--- a/src/ast/case_statement_test.cc
+++ b/src/ast/case_statement_test.cc
@@ -32,12 +32,12 @@
   StatementList stmts;
   stmts.push_back(std::make_unique<NopStatement>());
 
-  auto bool_ptr = b.get();
-  auto nop_ptr = stmts[0].get();
+  auto* bool_ptr = b.get();
+  auto* nop_ptr = stmts[0].get();
 
   CaseStatement c(std::move(b), std::move(stmts));
   EXPECT_EQ(c.condition(), bool_ptr);
-  ASSERT_EQ(c.body().size(), 1);
+  ASSERT_EQ(c.body().size(), 1u);
   EXPECT_EQ(c.body()[0].get(), nop_ptr);
 }
 
@@ -49,8 +49,8 @@
 
   CaseStatement c(Source{20, 2}, std::move(b), std::move(stmts));
   auto src = c.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(CaseStatementTest, IsDefault_WithoutCondition) {
diff --git a/src/ast/cast_expression_test.cc b/src/ast/cast_expression_test.cc
index d7f9498..4fe7566 100644
--- a/src/ast/cast_expression_test.cc
+++ b/src/ast/cast_expression_test.cc
@@ -27,7 +27,7 @@
 TEST_F(CastExpressionTest, Creation) {
   type::F32Type f32;
   auto expr = std::make_unique<IdentifierExpression>("expr");
-  auto expr_ptr = expr.get();
+  auto* expr_ptr = expr.get();
 
   CastExpression c(&f32, std::move(expr));
   EXPECT_EQ(c.type(), &f32);
@@ -40,8 +40,8 @@
 
   CastExpression c(Source{20, 2}, &f32, std::move(expr));
   auto src = c.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(CastExpressionTest, IsCast) {
diff --git a/src/ast/continue_statement_test.cc b/src/ast/continue_statement_test.cc
index 5f4a88c..10026bd 100644
--- a/src/ast/continue_statement_test.cc
+++ b/src/ast/continue_statement_test.cc
@@ -32,7 +32,7 @@
 
 TEST_F(ContinueStatementTest, CreationWithConditional) {
   auto expr = std::make_unique<IdentifierExpression>("expr");
-  auto expr_ptr = expr.get();
+  auto* expr_ptr = expr.get();
 
   ContinueStatement stmt(StatementCondition::kIf, std::move(expr));
   EXPECT_EQ(stmt.condition(), StatementCondition::kIf);
@@ -42,8 +42,8 @@
 TEST_F(ContinueStatementTest, Creation_WithSource) {
   ContinueStatement stmt(Source{20, 2});
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(ContinueStatementTest, Creation_WithSourceAndCondition) {
@@ -52,8 +52,8 @@
   ContinueStatement stmt(Source{20, 2}, StatementCondition::kUnless,
                          std::move(expr));
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(ContinueStatementTest, IsContinue) {
diff --git a/src/ast/decorated_variable_test.cc b/src/ast/decorated_variable_test.cc
index 11954ab..01d39f0 100644
--- a/src/ast/decorated_variable_test.cc
+++ b/src/ast/decorated_variable_test.cc
@@ -37,8 +37,8 @@
   EXPECT_EQ(dv.name(), "my_var");
   EXPECT_EQ(dv.storage_class(), StorageClass::kFunction);
   EXPECT_EQ(dv.type(), &t);
-  EXPECT_EQ(dv.line(), 0);
-  EXPECT_EQ(dv.column(), 0);
+  EXPECT_EQ(dv.line(), 0u);
+  EXPECT_EQ(dv.column(), 0u);
 }
 
 TEST_F(DecoratedVariableTest, CreationWithSource) {
@@ -50,8 +50,8 @@
   EXPECT_EQ(dv.name(), "i");
   EXPECT_EQ(dv.storage_class(), StorageClass::kPrivate);
   EXPECT_EQ(dv.type(), &t);
-  EXPECT_EQ(dv.line(), 27);
-  EXPECT_EQ(dv.column(), 4);
+  EXPECT_EQ(dv.line(), 27u);
+  EXPECT_EQ(dv.column(), 4u);
 }
 
 TEST_F(DecoratedVariableTest, IsValid) {
diff --git a/src/ast/else_statement_test.cc b/src/ast/else_statement_test.cc
index bfa0c77..07ee8ec 100644
--- a/src/ast/else_statement_test.cc
+++ b/src/ast/else_statement_test.cc
@@ -34,20 +34,20 @@
   StatementList body;
   body.push_back(std::make_unique<NopStatement>());
 
-  auto cond_ptr = cond.get();
-  auto nop_ptr = body[0].get();
+  auto* cond_ptr = cond.get();
+  auto* nop_ptr = body[0].get();
 
   ElseStatement e(std::move(cond), std::move(body));
   EXPECT_EQ(e.condition(), cond_ptr);
-  ASSERT_EQ(e.body().size(), 1);
+  ASSERT_EQ(e.body().size(), 1u);
   EXPECT_EQ(e.body()[0].get(), nop_ptr);
 }
 
 TEST_F(ElseStatementTest, Creation_WithSource) {
   ElseStatement e(Source{20, 2}, {});
   auto src = e.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(ElseStatementTest, IsElse) {
diff --git a/src/ast/entry_point_test.cc b/src/ast/entry_point_test.cc
index 2dfb0b8..0f34fb9 100644
--- a/src/ast/entry_point_test.cc
+++ b/src/ast/entry_point_test.cc
@@ -30,8 +30,8 @@
   EXPECT_EQ(e.name(), "main");
   EXPECT_EQ(e.function_name(), "vtx_main");
   EXPECT_EQ(e.stage(), PipelineStage::kVertex);
-  EXPECT_EQ(e.line(), 0);
-  EXPECT_EQ(e.column(), 0);
+  EXPECT_EQ(e.line(), 0u);
+  EXPECT_EQ(e.column(), 0u);
 }
 
 TEST_F(EntryPointTest, CreationWithSource) {
@@ -41,8 +41,8 @@
   EXPECT_EQ(e.name(), "main");
   EXPECT_EQ(e.function_name(), "vtx_main");
   EXPECT_EQ(e.stage(), PipelineStage::kVertex);
-  EXPECT_EQ(e.line(), 27);
-  EXPECT_EQ(e.column(), 4);
+  EXPECT_EQ(e.line(), 27u);
+  EXPECT_EQ(e.column(), 4u);
 }
 
 TEST_F(EntryPointTest, CreationEmpty) {
@@ -56,8 +56,8 @@
   EXPECT_EQ(e.function_name(), "my_func");
   EXPECT_EQ(e.name(), "a_name");
   EXPECT_EQ(e.stage(), PipelineStage::kFragment);
-  EXPECT_EQ(e.line(), 27);
-  EXPECT_EQ(e.column(), 4);
+  EXPECT_EQ(e.line(), 27u);
+  EXPECT_EQ(e.column(), 4u);
 }
 
 TEST_F(EntryPointTest, IsValid) {
diff --git a/src/ast/fallthrough_statement_test.cc b/src/ast/fallthrough_statement_test.cc
index 632b940..c7dbe58 100644
--- a/src/ast/fallthrough_statement_test.cc
+++ b/src/ast/fallthrough_statement_test.cc
@@ -24,15 +24,15 @@
 
 TEST_F(FallthroughStatementTest, Creation) {
   FallthroughStatement stmt;
-  EXPECT_EQ(stmt.line(), 0);
-  EXPECT_EQ(stmt.column(), 0);
+  EXPECT_EQ(stmt.line(), 0u);
+  EXPECT_EQ(stmt.column(), 0u);
 }
 
 TEST_F(FallthroughStatementTest, Creation_WithSource) {
   FallthroughStatement stmt(Source{20, 2});
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(FallthroughStatementTest, IsFallthrough) {
diff --git a/src/ast/function_test.cc b/src/ast/function_test.cc
index adac67d..faae8d1 100644
--- a/src/ast/function_test.cc
+++ b/src/ast/function_test.cc
@@ -34,11 +34,11 @@
   VariableList params;
   params.push_back(
       std::make_unique<Variable>("var", StorageClass::kNone, &i32));
-  auto var_ptr = params[0].get();
+  auto* var_ptr = params[0].get();
 
   Function f("func", std::move(params), &void_type);
   EXPECT_EQ(f.name(), "func");
-  ASSERT_EQ(f.params().size(), 1);
+  ASSERT_EQ(f.params().size(), 1u);
   EXPECT_EQ(f.return_type(), &void_type);
   EXPECT_EQ(f.params()[0].get(), var_ptr);
 }
@@ -53,8 +53,8 @@
 
   Function f(Source{20, 2}, "func", std::move(params), &void_type);
   auto src = f.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(FunctionTest, IsValid) {
diff --git a/src/ast/identifier_expression_test.cc b/src/ast/identifier_expression_test.cc
index 3252ab3..44eeb9f 100644
--- a/src/ast/identifier_expression_test.cc
+++ b/src/ast/identifier_expression_test.cc
@@ -24,20 +24,20 @@
 
 TEST_F(IdentifierExpressionTest, Creation) {
   IdentifierExpression i("ident");
-  ASSERT_EQ(i.name().size(), 1);
+  ASSERT_EQ(i.name().size(), 1u);
   EXPECT_EQ(i.name()[0], "ident");
 }
 
 TEST_F(IdentifierExpressionTest, Creation_WithSource) {
   IdentifierExpression i(Source{20, 2}, {"ns1", "ns2", "ident"});
-  ASSERT_EQ(i.name().size(), 3);
+  ASSERT_EQ(i.name().size(), 3u);
   EXPECT_EQ(i.name()[0], "ns1");
   EXPECT_EQ(i.name()[1], "ns2");
   EXPECT_EQ(i.name()[2], "ident");
 
   auto src = i.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(IdentifierExpressionTest, IsIdentifier) {
diff --git a/src/ast/if_statement_test.cc b/src/ast/if_statement_test.cc
index 7a96899..8455613 100644
--- a/src/ast/if_statement_test.cc
+++ b/src/ast/if_statement_test.cc
@@ -30,12 +30,12 @@
   StatementList body;
   body.push_back(std::make_unique<NopStatement>());
 
-  auto cond_ptr = cond.get();
-  auto stmt_ptr = body[0].get();
+  auto* cond_ptr = cond.get();
+  auto* stmt_ptr = body[0].get();
 
   IfStatement stmt(std::move(cond), std::move(body));
   EXPECT_EQ(stmt.condition(), cond_ptr);
-  ASSERT_EQ(stmt.body().size(), 1);
+  ASSERT_EQ(stmt.body().size(), 1u);
   EXPECT_EQ(stmt.body()[0].get(), stmt_ptr);
 }
 
@@ -46,8 +46,8 @@
 
   IfStatement stmt(Source{20, 2}, std::move(cond), std::move(body));
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(IfStatementTest, IsIf) {
diff --git a/src/ast/import_test.cc b/src/ast/import_test.cc
index 0bde102..af77bab 100644
--- a/src/ast/import_test.cc
+++ b/src/ast/import_test.cc
@@ -29,8 +29,8 @@
 
   EXPECT_EQ(i.path(), "GLSL.std.430");
   EXPECT_EQ(i.name(), "std::glsl");
-  EXPECT_EQ(i.line(), 0);
-  EXPECT_EQ(i.column(), 0);
+  EXPECT_EQ(i.line(), 0u);
+  EXPECT_EQ(i.column(), 0u);
 }
 
 TEST_F(ImportTest, CreationWithSource) {
@@ -39,8 +39,8 @@
 
   EXPECT_EQ(i.path(), "GLSL.std.430");
   EXPECT_EQ(i.name(), "std::glsl");
-  EXPECT_EQ(i.line(), 27);
-  EXPECT_EQ(i.column(), 4);
+  EXPECT_EQ(i.line(), 27u);
+  EXPECT_EQ(i.column(), 4u);
 }
 
 TEST_F(ImportTest, CreationEmpty) {
@@ -52,8 +52,8 @@
 
   EXPECT_EQ(i.path(), "GLSL.std.430");
   EXPECT_EQ(i.name(), "std::glsl");
-  EXPECT_EQ(i.line(), 27);
-  EXPECT_EQ(i.column(), 4);
+  EXPECT_EQ(i.line(), 27u);
+  EXPECT_EQ(i.column(), 4u);
 }
 
 TEST_F(ImportTest, to_str) {
diff --git a/src/ast/kill_statement_test.cc b/src/ast/kill_statement_test.cc
index e75988a..653b6ad 100644
--- a/src/ast/kill_statement_test.cc
+++ b/src/ast/kill_statement_test.cc
@@ -26,14 +26,14 @@
 
 TEST_F(KillStatementTest, Creation) {
   KillStatement k;
-  EXPECT_EQ(k.line(), 0);
-  EXPECT_EQ(k.column(), 0);
+  EXPECT_EQ(k.line(), 0u);
+  EXPECT_EQ(k.column(), 0u);
 }
 
 TEST_F(KillStatementTest, Creation_WithSource) {
   KillStatement k(Source{20, 2});
-  EXPECT_EQ(k.line(), 20);
-  EXPECT_EQ(k.column(), 2);
+  EXPECT_EQ(k.line(), 20u);
+  EXPECT_EQ(k.column(), 2u);
 }
 
 TEST_F(KillStatementTest, IsKill) {
diff --git a/src/ast/location_decoration_test.cc b/src/ast/location_decoration_test.cc
index a5340e8..c0ed6b1 100644
--- a/src/ast/location_decoration_test.cc
+++ b/src/ast/location_decoration_test.cc
@@ -26,7 +26,7 @@
 
 TEST_F(LocationDecorationTest, Creation) {
   LocationDecoration d{2};
-  EXPECT_EQ(2, d.value());
+  EXPECT_EQ(2u, d.value());
 }
 
 TEST_F(LocationDecorationTest, Is) {
diff --git a/src/ast/loop_statement_test.cc b/src/ast/loop_statement_test.cc
index dad5c6b..a12b2f7 100644
--- a/src/ast/loop_statement_test.cc
+++ b/src/ast/loop_statement_test.cc
@@ -31,16 +31,16 @@
 TEST_F(LoopStatementTest, Creation) {
   StatementList body;
   body.push_back(std::make_unique<KillStatement>());
-  auto b_ptr = body[0].get();
+  auto* b_ptr = body[0].get();
 
   StatementList continuing;
   continuing.push_back(std::make_unique<NopStatement>());
-  auto c_ptr = continuing[0].get();
+  auto* c_ptr = continuing[0].get();
 
   LoopStatement l(std::move(body), std::move(continuing));
-  ASSERT_EQ(l.body().size(), 1);
+  ASSERT_EQ(l.body().size(), 1u);
   EXPECT_EQ(l.body()[0].get(), b_ptr);
-  ASSERT_EQ(l.continuing().size(), 1);
+  ASSERT_EQ(l.continuing().size(), 1u);
   EXPECT_EQ(l.continuing()[0].get(), c_ptr);
 }
 
@@ -53,8 +53,8 @@
 
   LoopStatement l(Source{20, 2}, std::move(body), std::move(continuing));
   auto src = l.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(LoopStatementTest, IsLoop) {
diff --git a/src/ast/member_accessor_expression_test.cc b/src/ast/member_accessor_expression_test.cc
index f42110b..888884e 100644
--- a/src/ast/member_accessor_expression_test.cc
+++ b/src/ast/member_accessor_expression_test.cc
@@ -29,8 +29,8 @@
   auto str = std::make_unique<IdentifierExpression>("structure");
   auto mem = std::make_unique<IdentifierExpression>("member");
 
-  auto str_ptr = str.get();
-  auto mem_ptr = mem.get();
+  auto* str_ptr = str.get();
+  auto* mem_ptr = mem.get();
 
   MemberAccessorExpression stmt(std::move(str), std::move(mem));
   EXPECT_EQ(stmt.structure(), str_ptr);
@@ -43,8 +43,8 @@
 
   MemberAccessorExpression stmt(Source{20, 2}, std::move(str), std::move(mem));
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(MemberAccessorExpressionTest, IsMemberAccessor) {
diff --git a/src/ast/module_test.cc b/src/ast/module_test.cc
index f9f5968..0e02c13 100644
--- a/src/ast/module_test.cc
+++ b/src/ast/module_test.cc
@@ -33,13 +33,13 @@
 TEST_F(ModuleTest, Creation) {
   Module m;
 
-  EXPECT_EQ(m.imports().size(), 0);
+  EXPECT_EQ(m.imports().size(), 0u);
 }
 
 TEST_F(ModuleTest, ToStrEmitsPreambleAndPostamble) {
   Module m;
   const auto str = m.to_str();
-  const auto expected = "Module{\n}\n";
+  auto* const expected = "Module{\n}\n";
   EXPECT_EQ(str, expected);
 }
 
@@ -49,7 +49,7 @@
   m.AddImport(std::make_unique<Import>("GLSL.std.430", "std::glsl"));
   m.AddImport(std::make_unique<Import>("OpenCL.debug.100", "std::debug"));
 
-  EXPECT_EQ(2, m.imports().size());
+  EXPECT_EQ(2u, m.imports().size());
   EXPECT_EQ("std::glsl", m.imports()[0]->name());
 }
 
@@ -70,7 +70,7 @@
   m.AddImport(std::move(i));
   m.AddImport(std::make_unique<Import>("OpenCL.debug.100", "std::debug"));
 
-  auto import = m.FindImportByName("std::glsl");
+  auto* import = m.FindImportByName("std::glsl");
   ASSERT_NE(nullptr, import);
   EXPECT_EQ(import->path(), "GLSL.std.430");
   EXPECT_EQ(import->name(), "std::glsl");
diff --git a/src/ast/nop_statement_test.cc b/src/ast/nop_statement_test.cc
index 502622d..b7dda99 100644
--- a/src/ast/nop_statement_test.cc
+++ b/src/ast/nop_statement_test.cc
@@ -26,14 +26,14 @@
 
 TEST_F(NopStatementTest, Creation) {
   NopStatement n;
-  EXPECT_EQ(n.line(), 0);
-  EXPECT_EQ(n.column(), 0);
+  EXPECT_EQ(n.line(), 0u);
+  EXPECT_EQ(n.column(), 0u);
 }
 
 TEST_F(NopStatementTest, Creation_WithSource) {
   NopStatement n(Source{20, 2});
-  EXPECT_EQ(n.line(), 20);
-  EXPECT_EQ(n.column(), 2);
+  EXPECT_EQ(n.line(), 20u);
+  EXPECT_EQ(n.column(), 2u);
 }
 
 TEST_F(NopStatementTest, IsNop) {
diff --git a/src/ast/return_statement_test.cc b/src/ast/return_statement_test.cc
index 3cd4a04..2477015 100644
--- a/src/ast/return_statement_test.cc
+++ b/src/ast/return_statement_test.cc
@@ -27,7 +27,7 @@
 
 TEST_F(ReturnStatementTest, Creation) {
   auto expr = std::make_unique<IdentifierExpression>("expr");
-  auto expr_ptr = expr.get();
+  auto* expr_ptr = expr.get();
 
   ReturnStatement r(std::move(expr));
   EXPECT_EQ(r.value(), expr_ptr);
@@ -36,8 +36,8 @@
 TEST_F(ReturnStatementTest, Creation_WithSource) {
   ReturnStatement r(Source{20, 2});
   auto src = r.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(ReturnStatementTest, IsReturn) {
diff --git a/src/ast/scalar_constructor_expression_test.cc b/src/ast/scalar_constructor_expression_test.cc
index 817905d..ea3dddc 100644
--- a/src/ast/scalar_constructor_expression_test.cc
+++ b/src/ast/scalar_constructor_expression_test.cc
@@ -27,7 +27,7 @@
 TEST_F(ScalarConstructorExpressionTest, Creation) {
   ast::type::BoolType bool_type;
   auto b = std::make_unique<BoolLiteral>(&bool_type, true);
-  auto b_ptr = b.get();
+  auto* b_ptr = b.get();
   ScalarConstructorExpression c(std::move(b));
   EXPECT_EQ(c.literal(), b_ptr);
 }
@@ -37,8 +37,8 @@
   auto b = std::make_unique<BoolLiteral>(&bool_type, true);
   ScalarConstructorExpression c(Source{20, 2}, std::move(b));
   auto src = c.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(ScalarConstructorExpressionTest, IsValid) {
diff --git a/src/ast/set_decoration_test.cc b/src/ast/set_decoration_test.cc
index 9b70c4e..5a90c9d 100644
--- a/src/ast/set_decoration_test.cc
+++ b/src/ast/set_decoration_test.cc
@@ -24,7 +24,7 @@
 
 TEST_F(SetDecorationTest, Creation) {
   SetDecoration d{2};
-  EXPECT_EQ(2, d.value());
+  EXPECT_EQ(2u, d.value());
 }
 
 TEST_F(SetDecorationTest, Is) {
diff --git a/src/ast/struct_member_offset_decoration_test.cc b/src/ast/struct_member_offset_decoration_test.cc
index a73b367..141fbe5 100644
--- a/src/ast/struct_member_offset_decoration_test.cc
+++ b/src/ast/struct_member_offset_decoration_test.cc
@@ -24,7 +24,7 @@
 
 TEST_F(StructMemberOffsetDecorationTest, Creation) {
   StructMemberOffsetDecoration d{2};
-  EXPECT_EQ(2, d.offset());
+  EXPECT_EQ(2u, d.offset());
 }
 
 TEST_F(StructMemberOffsetDecorationTest, Is) {
diff --git a/src/ast/struct_member_test.cc b/src/ast/struct_member_test.cc
index b6f3ded..c73a8a8 100644
--- a/src/ast/struct_member_test.cc
+++ b/src/ast/struct_member_test.cc
@@ -35,10 +35,10 @@
   StructMember st{"a", &i32, std::move(decorations)};
   EXPECT_EQ(st.name(), "a");
   EXPECT_EQ(st.type(), &i32);
-  EXPECT_EQ(st.decorations().size(), 1);
+  EXPECT_EQ(st.decorations().size(), 1u);
   EXPECT_TRUE(st.decorations()[0]->IsOffset());
-  EXPECT_EQ(st.line(), 0);
-  EXPECT_EQ(st.column(), 0);
+  EXPECT_EQ(st.line(), 0u);
+  EXPECT_EQ(st.column(), 0u);
 }
 
 TEST_F(StructMemberTest, CreationWithSource) {
@@ -48,9 +48,9 @@
   StructMember st{s, "a", &i32, {}};
   EXPECT_EQ(st.name(), "a");
   EXPECT_EQ(st.type(), &i32);
-  EXPECT_EQ(st.decorations().size(), 0);
-  EXPECT_EQ(st.line(), 27);
-  EXPECT_EQ(st.column(), 4);
+  EXPECT_EQ(st.decorations().size(), 0u);
+  EXPECT_EQ(st.line(), 27u);
+  EXPECT_EQ(st.column(), 4u);
 }
 
 TEST_F(StructMemberTest, IsValid) {
diff --git a/src/ast/struct_test.cc b/src/ast/struct_test.cc
index 15dbad9..0b416a2 100644
--- a/src/ast/struct_test.cc
+++ b/src/ast/struct_test.cc
@@ -36,10 +36,10 @@
       std::make_unique<StructMember>("a", &i32, StructMemberDecorationList()));
 
   Struct s{StructDecoration::kNone, std::move(members)};
-  EXPECT_EQ(s.members().size(), 1);
+  EXPECT_EQ(s.members().size(), 1u);
   EXPECT_EQ(s.decoration(), StructDecoration::kNone);
-  EXPECT_EQ(s.line(), 0);
-  EXPECT_EQ(s.column(), 0);
+  EXPECT_EQ(s.line(), 0u);
+  EXPECT_EQ(s.column(), 0u);
 }
 
 TEST_F(StructTest, CreationWithSource) {
@@ -50,10 +50,10 @@
       std::make_unique<StructMember>("a", &i32, StructMemberDecorationList()));
 
   Struct s{source, StructDecoration::kNone, std::move(members)};
-  EXPECT_EQ(s.members().size(), 1);
+  EXPECT_EQ(s.members().size(), 1u);
   EXPECT_EQ(s.decoration(), StructDecoration::kNone);
-  EXPECT_EQ(s.line(), 27);
-  EXPECT_EQ(s.column(), 4);
+  EXPECT_EQ(s.line(), 27u);
+  EXPECT_EQ(s.column(), 4u);
 }
 
 TEST_F(StructTest, IsValid) {
diff --git a/src/ast/switch_statement_test.cc b/src/ast/switch_statement_test.cc
index 08ea6f3..c4adb28 100644
--- a/src/ast/switch_statement_test.cc
+++ b/src/ast/switch_statement_test.cc
@@ -36,12 +36,12 @@
   body.push_back(
       std::make_unique<CaseStatement>(std::move(lit), StatementList()));
 
-  auto ident_ptr = ident.get();
-  auto case_ptr = body[0].get();
+  auto* ident_ptr = ident.get();
+  auto* case_ptr = body[0].get();
 
   SwitchStatement stmt(std::move(ident), std::move(body));
   EXPECT_EQ(stmt.condition(), ident_ptr);
-  ASSERT_EQ(stmt.body().size(), 1);
+  ASSERT_EQ(stmt.body().size(), 1u);
   EXPECT_EQ(stmt.body()[0].get(), case_ptr);
 }
 
@@ -50,8 +50,8 @@
 
   SwitchStatement stmt(Source{20, 2}, std::move(ident), CaseStatementList());
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(SwitchStatementTest, IsSwitch) {
diff --git a/src/ast/type/array_type_test.cc b/src/ast/type/array_type_test.cc
index 4751641..b7ff819 100644
--- a/src/ast/type/array_type_test.cc
+++ b/src/ast/type/array_type_test.cc
@@ -29,7 +29,7 @@
   U32Type u32;
   ArrayType arr{&u32, 3};
   EXPECT_EQ(arr.type(), &u32);
-  EXPECT_EQ(arr.size(), 3);
+  EXPECT_EQ(arr.size(), 3u);
   EXPECT_TRUE(arr.IsArray());
   EXPECT_FALSE(arr.IsRuntimeArray());
 }
@@ -38,7 +38,7 @@
   U32Type u32;
   ArrayType arr{&u32};
   EXPECT_EQ(arr.type(), &u32);
-  EXPECT_EQ(arr.size(), 0);
+  EXPECT_EQ(arr.size(), 0u);
   EXPECT_TRUE(arr.IsArray());
   EXPECT_TRUE(arr.IsRuntimeArray());
 }
diff --git a/src/ast/type/matrix_type_test.cc b/src/ast/type/matrix_type_test.cc
index 1babb7d..4fcd024 100644
--- a/src/ast/type/matrix_type_test.cc
+++ b/src/ast/type/matrix_type_test.cc
@@ -28,8 +28,8 @@
   I32Type i32;
   MatrixType m{&i32, 2, 4};
   EXPECT_EQ(m.type(), &i32);
-  EXPECT_EQ(m.rows(), 2);
-  EXPECT_EQ(m.columns(), 4);
+  EXPECT_EQ(m.rows(), 2u);
+  EXPECT_EQ(m.columns(), 4u);
 }
 
 TEST_F(MatrixTypeTest, Is) {
diff --git a/src/ast/type/struct_type_test.cc b/src/ast/type/struct_type_test.cc
index 6492a15..5c3c65e 100644
--- a/src/ast/type/struct_type_test.cc
+++ b/src/ast/type/struct_type_test.cc
@@ -28,7 +28,7 @@
 
 TEST_F(StructTypeTest, Creation) {
   auto impl = std::make_unique<Struct>();
-  auto ptr = impl.get();
+  auto* ptr = impl.get();
   StructType s{std::move(impl)};
   EXPECT_EQ(s.impl(), ptr);
 }
diff --git a/src/ast/type/vector_type_test.cc b/src/ast/type/vector_type_test.cc
index cd2ce3a..b4fd515 100644
--- a/src/ast/type/vector_type_test.cc
+++ b/src/ast/type/vector_type_test.cc
@@ -28,7 +28,7 @@
   I32Type i32;
   VectorType v{&i32, 2};
   EXPECT_EQ(v.type(), &i32);
-  EXPECT_EQ(v.size(), 2);
+  EXPECT_EQ(v.size(), 2u);
 }
 
 TEST_F(VectorTypeTest, Is) {
diff --git a/src/ast/type_constructor_expression_test.cc b/src/ast/type_constructor_expression_test.cc
index ad4e01a..28b3608 100644
--- a/src/ast/type_constructor_expression_test.cc
+++ b/src/ast/type_constructor_expression_test.cc
@@ -33,11 +33,11 @@
   type::F32Type f32;
   ExpressionList expr;
   expr.push_back(std::make_unique<IdentifierExpression>("expr"));
-  auto expr_ptr = expr[0].get();
+  auto* expr_ptr = expr[0].get();
 
   TypeConstructorExpression t(&f32, std::move(expr));
   EXPECT_EQ(t.type(), &f32);
-  ASSERT_EQ(t.values().size(), 1);
+  ASSERT_EQ(t.values().size(), 1u);
   EXPECT_EQ(t.values()[0].get(), expr_ptr);
 }
 
@@ -48,8 +48,8 @@
 
   TypeConstructorExpression t(Source{20, 2}, &f32, std::move(expr));
   auto src = t.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(TypeConstructorExpressionTest, IsTypeConstructor) {
diff --git a/src/ast/uint_literal_test.cc b/src/ast/uint_literal_test.cc
index d19811c..a1402b3 100644
--- a/src/ast/uint_literal_test.cc
+++ b/src/ast/uint_literal_test.cc
@@ -27,7 +27,7 @@
   ast::type::U32Type u32;
   UintLiteral u{&u32, 47};
   ASSERT_TRUE(u.IsUint());
-  EXPECT_EQ(u.value(), 47);
+  EXPECT_EQ(u.value(), 47u);
 }
 
 TEST_F(UintLiteralTest, Is) {
diff --git a/src/ast/unary_derivative_expression_test.cc b/src/ast/unary_derivative_expression_test.cc
index 6a9d3661..96d1e46 100644
--- a/src/ast/unary_derivative_expression_test.cc
+++ b/src/ast/unary_derivative_expression_test.cc
@@ -27,7 +27,7 @@
 
 TEST_F(UnaryDerivativeExpressionTest, Creation) {
   auto ident = std::make_unique<IdentifierExpression>("ident");
-  auto ident_ptr = ident.get();
+  auto* ident_ptr = ident.get();
 
   UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
                               DerivativeModifier::kCoarse, std::move(ident));
@@ -42,8 +42,8 @@
   UnaryDerivativeExpression d(Source{20, 2}, UnaryDerivative::kDpdy,
                               DerivativeModifier::kCoarse, std::move(ident));
   auto src = d.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(UnaryDerivativeExpressionTest, IsUnaryDerivative) {
diff --git a/src/ast/unary_method_expression_test.cc b/src/ast/unary_method_expression_test.cc
index 92f265e..1a2d9ed 100644
--- a/src/ast/unary_method_expression_test.cc
+++ b/src/ast/unary_method_expression_test.cc
@@ -30,11 +30,11 @@
   ExpressionList params;
   params.push_back(std::make_unique<IdentifierExpression>("ident"));
 
-  auto ident_ptr = params[0].get();
+  auto* ident_ptr = params[0].get();
 
   UnaryMethodExpression u(UnaryMethod::kAll, std::move(params));
   EXPECT_EQ(u.op(), UnaryMethod::kAll);
-  ASSERT_EQ(u.params().size(), 1);
+  ASSERT_EQ(u.params().size(), 1u);
   EXPECT_EQ(u.params()[0].get(), ident_ptr);
 }
 
@@ -44,8 +44,8 @@
 
   UnaryMethodExpression u(Source{20, 2}, UnaryMethod::kAll, std::move(params));
   auto src = u.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(UnaryMethodExpressionTest, IsUnaryMethod) {
diff --git a/src/ast/unary_op_expression_test.cc b/src/ast/unary_op_expression_test.cc
index 93462bb..1d5e319 100644
--- a/src/ast/unary_op_expression_test.cc
+++ b/src/ast/unary_op_expression_test.cc
@@ -27,7 +27,7 @@
 
 TEST_F(UnaryOpExpressionTest, Creation) {
   auto ident = std::make_unique<IdentifierExpression>("ident");
-  auto ident_ptr = ident.get();
+  auto* ident_ptr = ident.get();
 
   UnaryOpExpression u(UnaryOp::kNot, std::move(ident));
   EXPECT_EQ(u.op(), UnaryOp::kNot);
@@ -38,8 +38,8 @@
   auto ident = std::make_unique<IdentifierExpression>("ident");
   UnaryOpExpression u(Source{20, 2}, UnaryOp::kNot, std::move(ident));
   auto src = u.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(UnaryOpExpressionTest, IsUnaryOp) {
diff --git a/src/ast/unless_statement_test.cc b/src/ast/unless_statement_test.cc
index 6937f9b..45b7b7d 100644
--- a/src/ast/unless_statement_test.cc
+++ b/src/ast/unless_statement_test.cc
@@ -30,12 +30,12 @@
   StatementList body;
   body.push_back(std::make_unique<NopStatement>());
 
-  auto ident_ptr = ident.get();
-  auto nop_ptr = body[0].get();
+  auto* ident_ptr = ident.get();
+  auto* nop_ptr = body[0].get();
 
   UnlessStatement u(std::move(ident), std::move(body));
   EXPECT_EQ(u.condition(), ident_ptr);
-  ASSERT_EQ(u.body().size(), 1);
+  ASSERT_EQ(u.body().size(), 1u);
   EXPECT_EQ(u.body()[0].get(), nop_ptr);
 }
 
@@ -46,8 +46,8 @@
 
   UnlessStatement u(Source{20, 2}, std::move(ident), std::move(body));
   auto src = u.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(UnlessStatementTest, IsUnless) {
diff --git a/src/ast/variable_decl_statement_test.cc b/src/ast/variable_decl_statement_test.cc
index 84149c1..d96b07b 100644
--- a/src/ast/variable_decl_statement_test.cc
+++ b/src/ast/variable_decl_statement_test.cc
@@ -27,7 +27,7 @@
 TEST_F(VariableDeclStatementTest, Creation) {
   type::F32Type f32;
   auto var = std::make_unique<Variable>("a", StorageClass::kNone, &f32);
-  auto var_ptr = var.get();
+  auto* var_ptr = var.get();
 
   VariableDeclStatement stmt(std::move(var));
   EXPECT_EQ(stmt.variable(), var_ptr);
@@ -39,8 +39,8 @@
 
   VariableDeclStatement stmt(Source{20, 2}, std::move(var));
   auto src = stmt.source();
-  EXPECT_EQ(src.line, 20);
-  EXPECT_EQ(src.column, 2);
+  EXPECT_EQ(src.line, 20u);
+  EXPECT_EQ(src.column, 2u);
 }
 
 TEST_F(VariableDeclStatementTest, IsVariableDecl) {
diff --git a/src/ast/variable_test.cc b/src/ast/variable_test.cc
index 1e4b72c..fd0db76 100644
--- a/src/ast/variable_test.cc
+++ b/src/ast/variable_test.cc
@@ -32,8 +32,8 @@
   EXPECT_EQ(v.name(), "my_var");
   EXPECT_EQ(v.storage_class(), StorageClass::kFunction);
   EXPECT_EQ(v.type(), &t);
-  EXPECT_EQ(v.line(), 0);
-  EXPECT_EQ(v.column(), 0);
+  EXPECT_EQ(v.line(), 0u);
+  EXPECT_EQ(v.column(), 0u);
 }
 
 TEST_F(VariableTest, CreationWithSource) {
@@ -44,8 +44,8 @@
   EXPECT_EQ(v.name(), "i");
   EXPECT_EQ(v.storage_class(), StorageClass::kPrivate);
   EXPECT_EQ(v.type(), &t);
-  EXPECT_EQ(v.line(), 27);
-  EXPECT_EQ(v.column(), 4);
+  EXPECT_EQ(v.line(), 27u);
+  EXPECT_EQ(v.column(), 4u);
 }
 
 TEST_F(VariableTest, CreationEmpty) {
@@ -61,8 +61,8 @@
   EXPECT_EQ(v.name(), "a_var");
   EXPECT_EQ(v.storage_class(), StorageClass::kWorkgroup);
   EXPECT_EQ(v.type(), &t);
-  EXPECT_EQ(v.line(), 27);
-  EXPECT_EQ(v.column(), 4);
+  EXPECT_EQ(v.line(), 27u);
+  EXPECT_EQ(v.column(), 4u);
 }
 
 TEST_F(VariableTest, IsValid) {
diff --git a/src/reader/spirv/function_arithmetic_test.cc b/src/reader/spirv/function_arithmetic_test.cc
index b2945af..a0ccf6e 100644
--- a/src/reader/spirv/function_arithmetic_test.cc
+++ b/src/reader/spirv/function_arithmetic_test.cc
@@ -137,7 +137,7 @@
      OpReturn
      OpFunctionEnd
   )";
-  auto p = parser(test::Assemble(assembly));
+  auto* p = parser(test::Assemble(assembly));
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions())
       << p->error() << "\n"
       << assembly;
diff --git a/src/reader/spirv/function_decl_test.cc b/src/reader/spirv/function_decl_test.cc
index 75cc74f..20e5b1b 100644
--- a/src/reader/spirv/function_decl_test.cc
+++ b/src/reader/spirv/function_decl_test.cc
@@ -50,7 +50,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionDeclaration_VoidFunctionWithoutParams) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
      OpReturn
@@ -67,7 +67,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionDeclaration_NonVoidResultType) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %fn_ret_float = OpTypeFunction %float
      %100 = OpFunction %float None %fn_ret_float
      %entry = OpLabel
@@ -86,7 +86,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionDeclaration_MixedParamTypes) {
-  auto p = parser(test::Assemble(Names({"a", "b", "c"}) + CommonTypes() + R"(
+  auto* p = parser(test::Assemble(Names({"a", "b", "c"}) + CommonTypes() + R"(
      %fn_mixed_params = OpTypeFunction %float %uint %float %int
 
      %100 = OpFunction %void None %fn_mixed_params
@@ -125,7 +125,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionDeclaration_GenerateParamNames) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %fn_mixed_params = OpTypeFunction %float %uint %float %int
 
      %100 = OpFunction %void None %fn_mixed_params
diff --git a/src/reader/spirv/function_logical_test.cc b/src/reader/spirv/function_logical_test.cc
index 7f58959..a3e0b36 100644
--- a/src/reader/spirv/function_logical_test.cc
+++ b/src/reader/spirv/function_logical_test.cc
@@ -159,7 +159,7 @@
      OpReturn
      OpFunctionEnd
   )";
-  auto p = parser(test::Assemble(assembly));
+  auto* p = parser(test::Assemble(assembly));
   ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions())
       << p->error() << "\n"
       << assembly;
diff --git a/src/reader/spirv/function_memory_test.cc b/src/reader/spirv/function_memory_test.cc
index 9b96018..aafc6cb 100644
--- a/src/reader/spirv/function_memory_test.cc
+++ b/src/reader/spirv/function_memory_test.cc
@@ -29,7 +29,7 @@
 using ::testing::HasSubstr;
 
 TEST_F(SpvParserTest, EmitStatement_StoreBoolConst) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %ty = OpTypeBool
@@ -64,7 +64,7 @@
 }
 
 TEST_F(SpvParserTest, EmitStatement_StoreUintConst) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %ty = OpTypeInt 32 0
@@ -92,7 +92,7 @@
 }
 
 TEST_F(SpvParserTest, EmitStatement_StoreIntConst) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %ty = OpTypeInt 32 1
@@ -120,7 +120,7 @@
 }
 
 TEST_F(SpvParserTest, EmitStatement_StoreFloatConst) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %ty = OpTypeFloat 32
@@ -148,7 +148,7 @@
 }
 
 TEST_F(SpvParserTest, EmitStatement_LoadBool) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %ty = OpTypeBool
@@ -178,7 +178,7 @@
 }
 
 TEST_F(SpvParserTest, EmitStatement_LoadScalar) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %ty = OpTypeInt 32 0
@@ -218,7 +218,7 @@
 }
 
 TEST_F(SpvParserTest, EmitStatement_UseLoadedScalarTwice) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %ty = OpTypeInt 32 0
@@ -258,7 +258,7 @@
 }
 
 TEST_F(SpvParserTest, EmitStatement_StoreToModuleScopeVar) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %ty = OpTypeInt 32 0
diff --git a/src/reader/spirv/function_var_test.cc b/src/reader/spirv/function_var_test.cc
index c53c036..1f929a7 100644
--- a/src/reader/spirv/function_var_test.cc
+++ b/src/reader/spirv/function_var_test.cc
@@ -70,7 +70,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_AnonymousVars) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
      %1 = OpVariable %ptr_uint Function
@@ -108,7 +108,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_NamedVars) {
-  auto p = parser(test::Assemble(Names({"a", "b", "c"}) + CommonTypes() + R"(
+  auto* p = parser(test::Assemble(Names({"a", "b", "c"}) + CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
      %a = OpVariable %ptr_uint Function
@@ -146,7 +146,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_MixedTypes) {
-  auto p = parser(test::Assemble(Names({"a", "b", "c"}) + CommonTypes() + R"(
+  auto* p = parser(test::Assemble(Names({"a", "b", "c"}) + CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
      %a = OpVariable %ptr_uint Function
@@ -184,7 +184,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_ScalarInitializers) {
-  auto p = parser(
+  auto* p = parser(
       test::Assemble(Names({"a", "b", "c", "d", "e"}) + CommonTypes() + R"(
      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
@@ -254,7 +254,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_ScalarNullInitializers) {
-  auto p =
+  auto* p =
       parser(test::Assemble(Names({"a", "b", "c", "d"}) + CommonTypes() + R"(
      %null_bool = OpConstantNull %bool
      %null_int = OpConstantNull %int
@@ -318,7 +318,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_VectorInitializer) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %ptr = OpTypePointer Function %v2float
      %two = OpConstant %float 2.0
      %const = OpConstantComposite %v2float %float_1p5 %two
@@ -351,7 +351,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_MatrixInitializer) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %ptr = OpTypePointer Function %m3v2float
      %two = OpConstant %float 2.0
      %three = OpConstant %float 3.0
@@ -402,7 +402,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_ArrayInitializer) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %ptr = OpTypePointer Function %arr2uint
      %two = OpConstant %uint 2
      %const = OpConstantComposite %arr2uint %uint_1 %two
@@ -435,7 +435,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctionVariables_StructInitializer) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %ptr = OpTypePointer Function %strct
      %two = OpConstant %uint 2
      %arrconst = OpConstantComposite %arr2uint %uint_1 %two
diff --git a/src/reader/spirv/parser_impl_convert_member_decoration_test.cc b/src/reader/spirv/parser_impl_convert_member_decoration_test.cc
index d8351a8..19a93a4 100644
--- a/src/reader/spirv/parser_impl_convert_member_decoration_test.cc
+++ b/src/reader/spirv/parser_impl_convert_member_decoration_test.cc
@@ -32,7 +32,7 @@
 using ::testing::Eq;
 
 TEST_F(SpvParserTest, ConvertMemberDecoration_Empty) {
-  auto p = parser(std::vector<uint32_t>{});
+  auto* p = parser(std::vector<uint32_t>{});
 
   auto result = p->ConvertMemberDecoration({});
   EXPECT_EQ(result.get(), nullptr);
@@ -40,7 +40,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertMemberDecoration_OffsetWithoutOperand) {
-  auto p = parser(std::vector<uint32_t>{});
+  auto* p = parser(std::vector<uint32_t>{});
 
   auto result = p->ConvertMemberDecoration({SpvDecorationOffset});
   EXPECT_EQ(result.get(), nullptr);
@@ -50,7 +50,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertMemberDecoration_OffsetWithTooManyOperands) {
-  auto p = parser(std::vector<uint32_t>{});
+  auto* p = parser(std::vector<uint32_t>{});
 
   auto result = p->ConvertMemberDecoration({SpvDecorationOffset, 3, 4});
   EXPECT_EQ(result.get(), nullptr);
@@ -60,19 +60,19 @@
 }
 
 TEST_F(SpvParserTest, ConvertMemberDecoration_Offset) {
-  auto p = parser(std::vector<uint32_t>{});
+  auto* p = parser(std::vector<uint32_t>{});
 
   auto result = p->ConvertMemberDecoration({SpvDecorationOffset, 8});
   ASSERT_NE(result.get(), nullptr);
   EXPECT_TRUE(result->IsOffset());
   auto* offset_deco = result->AsOffset();
   ASSERT_NE(offset_deco, nullptr);
-  EXPECT_EQ(offset_deco->offset(), 8);
+  EXPECT_EQ(offset_deco->offset(), 8u);
   EXPECT_TRUE(p->error().empty());
 }
 
 TEST_F(SpvParserTest, ConvertMemberDecoration_UnhandledDecoration) {
-  auto p = parser(std::vector<uint32_t>{});
+  auto* p = parser(std::vector<uint32_t>{});
 
   auto result = p->ConvertMemberDecoration({12345678});
   EXPECT_EQ(result.get(), nullptr);
diff --git a/src/reader/spirv/parser_impl_convert_type_test.cc b/src/reader/spirv/parser_impl_convert_type_test.cc
index aa0fe09..75746ad 100644
--- a/src/reader/spirv/parser_impl_convert_type_test.cc
+++ b/src/reader/spirv/parser_impl_convert_type_test.cc
@@ -37,7 +37,7 @@
 using ::testing::Eq;
 
 TEST_F(SpvParserTest, ConvertType_PreservesExistingFailure) {
-  auto p = parser(std::vector<uint32_t>{});
+  auto* p = parser(std::vector<uint32_t>{});
   p->Fail() << "boing";
   auto* type = p->ConvertType(10);
   EXPECT_EQ(type, nullptr);
@@ -45,7 +45,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_RequiresInternalRepresntation) {
-  auto p = parser(std::vector<uint32_t>{});
+  auto* p = parser(std::vector<uint32_t>{});
   auto* type = p->ConvertType(10);
   EXPECT_EQ(type, nullptr);
   EXPECT_THAT(
@@ -54,7 +54,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_NotAnId) {
-  auto p = parser(test::Assemble("%1 = OpExtInstImport \"GLSL.std.450\""));
+  auto* p = parser(test::Assemble("%1 = OpExtInstImport \"GLSL.std.450\""));
   EXPECT_TRUE(p->BuildInternalModule());
 
   auto* type = p->ConvertType(10);
@@ -64,7 +64,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_IdExistsButIsNotAType) {
-  auto p = parser(test::Assemble("%1 = OpExtInstImport \"GLSL.std.450\""));
+  auto* p = parser(test::Assemble("%1 = OpExtInstImport \"GLSL.std.450\""));
   EXPECT_TRUE(p->BuildInternalModule());
 
   auto* type = p->ConvertType(1);
@@ -74,7 +74,7 @@
 
 TEST_F(SpvParserTest, ConvertType_UnhandledType) {
   // Pipes are an OpenCL type. Tint doesn't support them.
-  auto p = parser(test::Assemble("%70 = OpTypePipe WriteOnly"));
+  auto* p = parser(test::Assemble("%70 = OpTypePipe WriteOnly"));
   EXPECT_TRUE(p->BuildInternalModule());
 
   auto* type = p->ConvertType(70);
@@ -83,7 +83,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_Void) {
-  auto p = parser(test::Assemble("%1 = OpTypeVoid"));
+  auto* p = parser(test::Assemble("%1 = OpTypeVoid"));
   EXPECT_TRUE(p->BuildInternalModule());
 
   auto* type = p->ConvertType(1);
@@ -92,7 +92,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_Bool) {
-  auto p = parser(test::Assemble("%100 = OpTypeBool"));
+  auto* p = parser(test::Assemble("%100 = OpTypeBool"));
   EXPECT_TRUE(p->BuildInternalModule());
 
   auto* type = p->ConvertType(100);
@@ -101,7 +101,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_I32) {
-  auto p = parser(test::Assemble("%2 = OpTypeInt 32 1"));
+  auto* p = parser(test::Assemble("%2 = OpTypeInt 32 1"));
   EXPECT_TRUE(p->BuildInternalModule());
 
   auto* type = p->ConvertType(2);
@@ -110,7 +110,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_U32) {
-  auto p = parser(test::Assemble("%3 = OpTypeInt 32 0"));
+  auto* p = parser(test::Assemble("%3 = OpTypeInt 32 0"));
   EXPECT_TRUE(p->BuildInternalModule());
 
   auto* type = p->ConvertType(3);
@@ -119,7 +119,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_F32) {
-  auto p = parser(test::Assemble("%4 = OpTypeFloat 32"));
+  auto* p = parser(test::Assemble("%4 = OpTypeFloat 32"));
   EXPECT_TRUE(p->BuildInternalModule());
 
   auto* type = p->ConvertType(4);
@@ -128,7 +128,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_BadIntWidth) {
-  auto p = parser(test::Assemble("%5 = OpTypeInt 17 1"));
+  auto* p = parser(test::Assemble("%5 = OpTypeInt 17 1"));
   EXPECT_TRUE(p->BuildInternalModule());
 
   auto* type = p->ConvertType(5);
@@ -137,7 +137,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_BadFloatWidth) {
-  auto p = parser(test::Assemble("%6 = OpTypeFloat 19"));
+  auto* p = parser(test::Assemble("%6 = OpTypeFloat 19"));
   EXPECT_TRUE(p->BuildInternalModule());
 
   auto* type = p->ConvertType(6);
@@ -146,7 +146,7 @@
 }
 
 TEST_F(SpvParserTest, DISABLED_ConvertType_InvalidVectorElement) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %5 = OpTypePipe ReadOnly
     %20 = OpTypeVector %5 2
   )"));
@@ -158,7 +158,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_VecOverF32) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %float = OpTypeFloat 32
     %20 = OpTypeVector %float 2
     %30 = OpTypeVector %float 3
@@ -185,7 +185,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_VecOverI32) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %int = OpTypeInt 32 1
     %20 = OpTypeVector %int 2
     %30 = OpTypeVector %int 3
@@ -212,7 +212,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_VecOverU32) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %uint = OpTypeInt 32 0
     %20 = OpTypeVector %uint 2
     %30 = OpTypeVector %uint 3
@@ -239,7 +239,7 @@
 }
 
 TEST_F(SpvParserTest, DISABLED_ConvertType_InvalidMatrixElement) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %5 = OpTypePipe ReadOnly
     %10 = OpTypeVector %5 2
     %20 = OpTypeMatrix %10 2
@@ -253,7 +253,7 @@
 
 TEST_F(SpvParserTest, ConvertType_MatrixOverF32) {
   // Matrices are only defined over floats.
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %float = OpTypeFloat 32
     %v2 = OpTypeVector %float 2
     %v3 = OpTypeVector %float 3
@@ -275,62 +275,62 @@
   auto* m22 = p->ConvertType(22);
   EXPECT_TRUE(m22->IsMatrix());
   EXPECT_TRUE(m22->AsMatrix()->type()->IsF32());
-  EXPECT_EQ(m22->AsMatrix()->rows(), 2);
-  EXPECT_EQ(m22->AsMatrix()->columns(), 2);
+  EXPECT_EQ(m22->AsMatrix()->rows(), 2u);
+  EXPECT_EQ(m22->AsMatrix()->columns(), 2u);
 
   auto* m23 = p->ConvertType(23);
   EXPECT_TRUE(m23->IsMatrix());
   EXPECT_TRUE(m23->AsMatrix()->type()->IsF32());
-  EXPECT_EQ(m23->AsMatrix()->rows(), 2);
-  EXPECT_EQ(m23->AsMatrix()->columns(), 3);
+  EXPECT_EQ(m23->AsMatrix()->rows(), 2u);
+  EXPECT_EQ(m23->AsMatrix()->columns(), 3u);
 
   auto* m24 = p->ConvertType(24);
   EXPECT_TRUE(m24->IsMatrix());
   EXPECT_TRUE(m24->AsMatrix()->type()->IsF32());
-  EXPECT_EQ(m24->AsMatrix()->rows(), 2);
-  EXPECT_EQ(m24->AsMatrix()->columns(), 4);
+  EXPECT_EQ(m24->AsMatrix()->rows(), 2u);
+  EXPECT_EQ(m24->AsMatrix()->columns(), 4u);
 
   auto* m32 = p->ConvertType(32);
   EXPECT_TRUE(m32->IsMatrix());
   EXPECT_TRUE(m32->AsMatrix()->type()->IsF32());
-  EXPECT_EQ(m32->AsMatrix()->rows(), 3);
-  EXPECT_EQ(m32->AsMatrix()->columns(), 2);
+  EXPECT_EQ(m32->AsMatrix()->rows(), 3u);
+  EXPECT_EQ(m32->AsMatrix()->columns(), 2u);
 
   auto* m33 = p->ConvertType(33);
   EXPECT_TRUE(m33->IsMatrix());
   EXPECT_TRUE(m33->AsMatrix()->type()->IsF32());
-  EXPECT_EQ(m33->AsMatrix()->rows(), 3);
-  EXPECT_EQ(m33->AsMatrix()->columns(), 3);
+  EXPECT_EQ(m33->AsMatrix()->rows(), 3u);
+  EXPECT_EQ(m33->AsMatrix()->columns(), 3u);
 
   auto* m34 = p->ConvertType(34);
   EXPECT_TRUE(m34->IsMatrix());
   EXPECT_TRUE(m34->AsMatrix()->type()->IsF32());
-  EXPECT_EQ(m34->AsMatrix()->rows(), 3);
-  EXPECT_EQ(m34->AsMatrix()->columns(), 4);
+  EXPECT_EQ(m34->AsMatrix()->rows(), 3u);
+  EXPECT_EQ(m34->AsMatrix()->columns(), 4u);
 
   auto* m42 = p->ConvertType(42);
   EXPECT_TRUE(m42->IsMatrix());
   EXPECT_TRUE(m42->AsMatrix()->type()->IsF32());
-  EXPECT_EQ(m42->AsMatrix()->rows(), 4);
-  EXPECT_EQ(m42->AsMatrix()->columns(), 2);
+  EXPECT_EQ(m42->AsMatrix()->rows(), 4u);
+  EXPECT_EQ(m42->AsMatrix()->columns(), 2u);
 
   auto* m43 = p->ConvertType(43);
   EXPECT_TRUE(m43->IsMatrix());
   EXPECT_TRUE(m43->AsMatrix()->type()->IsF32());
-  EXPECT_EQ(m43->AsMatrix()->rows(), 4);
-  EXPECT_EQ(m43->AsMatrix()->columns(), 3);
+  EXPECT_EQ(m43->AsMatrix()->rows(), 4u);
+  EXPECT_EQ(m43->AsMatrix()->columns(), 3u);
 
   auto* m44 = p->ConvertType(44);
   EXPECT_TRUE(m44->IsMatrix());
   EXPECT_TRUE(m44->AsMatrix()->type()->IsF32());
-  EXPECT_EQ(m44->AsMatrix()->rows(), 4);
-  EXPECT_EQ(m44->AsMatrix()->columns(), 4);
+  EXPECT_EQ(m44->AsMatrix()->rows(), 4u);
+  EXPECT_EQ(m44->AsMatrix()->columns(), 4u);
 
   EXPECT_TRUE(p->error().empty());
 }
 
 TEST_F(SpvParserTest, ConvertType_RuntimeArray) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %uint = OpTypeInt 32 0
     %10 = OpTypeRuntimeArray %uint
   )"));
@@ -350,7 +350,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_Array) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %uint = OpTypeInt 32 0
     %uint_42 = OpConstant %uint 42
     %10 = OpTypeArray %uint %uint_42
@@ -371,7 +371,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_ArrayBadLengthIsSpecConstantValue) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpDecorate %uint_42 SpecId 12
     %uint = OpTypeInt 32 0
     %uint_42 = OpSpecConstant %uint 42
@@ -386,7 +386,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_ArrayBadLengthIsSpecConstantExpr) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %uint = OpTypeInt 32 0
     %uint_42 = OpConstant %uint 42
     %sum = OpSpecConstantOp %uint IAdd %uint_42 %uint_42
@@ -405,7 +405,7 @@
 // optimizer representation doesn't handle it and asserts out instead.
 
 TEST_F(SpvParserTest, ConvertType_ArrayBadTooBig) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %uint64 = OpTypeInt 64 0
     %uint64_big = OpConstant %uint64 5000000000
     %10 = OpTypeArray %uint64 %uint64_big
@@ -420,7 +420,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_StructTwoMembers) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %uint = OpTypeInt 32 0
     %float = OpTypeFloat 32
     %10 = OpTypeStruct %uint %float
@@ -441,7 +441,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_StructWithBlockDecoration) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpDecorate %10 Block
     %uint = OpTypeInt 32 0
     %10 = OpTypeStruct %uint
@@ -461,7 +461,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_StructWithMemberDecorations) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpMemberDecorate %10 0 Offset 0
     OpMemberDecorate %10 1 Offset 8
     OpMemberDecorate %10 2 Offset 16
@@ -493,7 +493,7 @@
 
 TEST_F(SpvParserTest, ConvertType_InvalidPointeetype) {
   // Disallow pointer-to-function
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %void = OpTypeVoid
   %42 = OpTypeFunction %void
   %3 = OpTypePointer Input %42
@@ -508,7 +508,7 @@
 
 TEST_F(SpvParserTest, DISABLED_ConvertType_InvalidStorageClass) {
   // Disallow invalid storage class
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %1 = OpTypeFloat 32
   %3 = OpTypePointer !999 %1   ; Special syntax to inject 999 as the storage class
   )"));
@@ -517,7 +517,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_PointerInput) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %3 = OpTypePointer Input %float
   )"));
@@ -533,7 +533,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_PointerOutput) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %3 = OpTypePointer Output %float
   )"));
@@ -549,7 +549,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_PointerUniform) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %3 = OpTypePointer Uniform %float
   )"));
@@ -565,7 +565,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_PointerWorkgroup) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %3 = OpTypePointer Workgroup %float
   )"));
@@ -581,7 +581,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_PointerUniformConstant) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %3 = OpTypePointer UniformConstant %float
   )"));
@@ -597,7 +597,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_PointerStorageBuffer) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %3 = OpTypePointer StorageBuffer %float
   )"));
@@ -613,7 +613,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_PointerImage) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %3 = OpTypePointer Image %float
   )"));
@@ -629,7 +629,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_PointerPushConstant) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %3 = OpTypePointer PushConstant %float
   )"));
@@ -645,7 +645,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_PointerPrivate) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %3 = OpTypePointer Private %float
   )"));
@@ -661,7 +661,7 @@
 }
 
 TEST_F(SpvParserTest, ConvertType_PointerFunction) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %3 = OpTypePointer Function %float
   )"));
@@ -678,7 +678,7 @@
 
 TEST_F(SpvParserTest, ConvertType_PointerToPointer) {
   // FYI:  The reader suports pointer-to-pointer even while WebGPU does not.
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
   %float = OpTypeFloat 32
   %42 = OpTypePointer Output %float
   %3 = OpTypePointer Input %42
diff --git a/src/reader/spirv/parser_impl_entry_point_test.cc b/src/reader/spirv/parser_impl_entry_point_test.cc
index c216b3b..998f0cf 100644
--- a/src/reader/spirv/parser_impl_entry_point_test.cc
+++ b/src/reader/spirv/parser_impl_entry_point_test.cc
@@ -35,7 +35,7 @@
 }
 
 TEST_F(SpvParserTest, EntryPoint_NoEntryPoint) {
-  auto p = parser(test::Assemble(""));
+  auto* p = parser(test::Assemble(""));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   const auto module_ast = p->module().to_str();
@@ -43,7 +43,7 @@
 }
 
 TEST_F(SpvParserTest, EntryPoint_Vertex) {
-  auto p = parser(test::Assemble(MakeEntryPoint("Vertex", "foobar")));
+  auto* p = parser(test::Assemble(MakeEntryPoint("Vertex", "foobar")));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   const auto module_str = p->module().to_str();
@@ -51,7 +51,7 @@
 }
 
 TEST_F(SpvParserTest, EntryPoint_Fragment) {
-  auto p = parser(test::Assemble(MakeEntryPoint("Fragment", "blitz")));
+  auto* p = parser(test::Assemble(MakeEntryPoint("Fragment", "blitz")));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   const auto module_str = p->module().to_str();
@@ -59,7 +59,7 @@
 }
 
 TEST_F(SpvParserTest, EntryPoint_Compute) {
-  auto p = parser(test::Assemble(MakeEntryPoint("GLCompute", "sort")));
+  auto* p = parser(test::Assemble(MakeEntryPoint("GLCompute", "sort")));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   const auto module_str = p->module().to_str();
@@ -67,9 +67,9 @@
 }
 
 TEST_F(SpvParserTest, EntryPoint_MultiNameConflict) {
-  auto p = parser(test::Assemble(MakeEntryPoint("GLCompute", "work", "40") +
-                                 MakeEntryPoint("Vertex", "work", "50") +
-                                 MakeEntryPoint("Fragment", "work", "60")));
+  auto* p = parser(test::Assemble(MakeEntryPoint("GLCompute", "work", "40") +
+                                  MakeEntryPoint("Vertex", "work", "50") +
+                                  MakeEntryPoint("Fragment", "work", "60")));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   const auto module_str = p->module().to_str();
@@ -79,7 +79,7 @@
 }
 
 TEST_F(SpvParserTest, EntryPoint_NameIsSanitized) {
-  auto p = parser(test::Assemble(MakeEntryPoint("GLCompute", ".1234")));
+  auto* p = parser(test::Assemble(MakeEntryPoint("GLCompute", ".1234")));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   const auto module_str = p->module().to_str();
diff --git a/src/reader/spirv/parser_impl_function_decl_test.cc b/src/reader/spirv/parser_impl_function_decl_test.cc
index 6e29906..ab6f5ab 100644
--- a/src/reader/spirv/parser_impl_function_decl_test.cc
+++ b/src/reader/spirv/parser_impl_function_decl_test.cc
@@ -50,7 +50,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctions_NoFunctions) {
-  auto p = parser(test::Assemble(CommonTypes()));
+  auto* p = parser(test::Assemble(CommonTypes()));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   const auto module_ast = p->module().to_str();
@@ -58,7 +58,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctions_FunctionWithoutBody) {
-  auto p = parser(test::Assemble(Names({"main"}) + CommonTypes() + R"(
+  auto* p = parser(test::Assemble(Names({"main"}) + CommonTypes() + R"(
      %main = OpFunction %void None %voidfn
      OpFunctionEnd
   )"));
@@ -69,7 +69,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctions_VoidFunctionWithoutParams) {
-  auto p = parser(test::Assemble(Names({"main"}) + CommonTypes() + R"(
+  auto* p = parser(test::Assemble(Names({"main"}) + CommonTypes() + R"(
      %main = OpFunction %void None %voidfn
      %entry = OpLabel
      OpReturn
@@ -85,7 +85,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctions_CalleePrecedesCaller) {
-  auto p = parser(
+  auto* p = parser(
       test::Assemble(Names({"root", "branch", "leaf"}) + CommonTypes() + R"(
      %root = OpFunction %void None %voidfn
      %root_entry = OpLabel
@@ -123,7 +123,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctions_NonVoidResultType) {
-  auto p = parser(test::Assemble(Names({"ret_float"}) + CommonTypes() + R"(
+  auto* p = parser(test::Assemble(Names({"ret_float"}) + CommonTypes() + R"(
      %fn_ret_float = OpTypeFunction %float
 
      %ret_float = OpFunction %float None %fn_ret_float
@@ -142,8 +142,8 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctions_MixedParamTypes) {
-  auto p = parser(test::Assemble(Names({"mixed_params", "a", "b", "c"}) +
-                                 CommonTypes() + R"(
+  auto* p = parser(test::Assemble(Names({"mixed_params", "a", "b", "c"}) +
+                                  CommonTypes() + R"(
      %fn_mixed_params = OpTypeFunction %float %uint %float %int
 
      %mixed_params = OpFunction %void None %fn_mixed_params
@@ -181,7 +181,7 @@
 }
 
 TEST_F(SpvParserTest, EmitFunctions_GenerateParamNames) {
-  auto p = parser(test::Assemble(Names({"mixed_params"}) + CommonTypes() + R"(
+  auto* p = parser(test::Assemble(Names({"mixed_params"}) + CommonTypes() + R"(
      %fn_mixed_params = OpTypeFunction %float %uint %float %int
 
      %mixed_params = OpFunction %void None %fn_mixed_params
diff --git a/src/reader/spirv/parser_impl_get_decorations_test.cc b/src/reader/spirv/parser_impl_get_decorations_test.cc
index 113a7a7..542332c 100644
--- a/src/reader/spirv/parser_impl_get_decorations_test.cc
+++ b/src/reader/spirv/parser_impl_get_decorations_test.cc
@@ -27,7 +27,7 @@
 using ::testing::UnorderedElementsAre;
 
 TEST_F(SpvParserTest, GetDecorationsFor_NotAnId) {
-  auto p = parser(test::Assemble(""));
+  auto* p = parser(test::Assemble(""));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   auto decorations = p->GetDecorationsFor(42);
   EXPECT_TRUE(decorations.empty());
@@ -35,7 +35,7 @@
 }
 
 TEST_F(SpvParserTest, GetDecorationsFor_NoDecorations) {
-  auto p = parser(test::Assemble("%1 = OpTypeVoid"));
+  auto* p = parser(test::Assemble("%1 = OpTypeVoid"));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   auto decorations = p->GetDecorationsFor(1);
   EXPECT_TRUE(decorations.empty());
@@ -43,7 +43,7 @@
 }
 
 TEST_F(SpvParserTest, GetDecorationsFor_OneDecoration) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpDecorate %10 Block
     %float = OpTypeFloat 32
     %10 = OpTypeStruct %float
@@ -56,7 +56,7 @@
 }
 
 TEST_F(SpvParserTest, GetDecorationsFor_MultiDecoration) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpDecorate %5 RelaxedPrecision
     OpDecorate %5 Location 7      ; Invalid case made up for test
     %float = OpTypeFloat 32
@@ -71,7 +71,7 @@
 }
 
 TEST_F(SpvParserTest, GetDecorationsForMember_NotAnId) {
-  auto p = parser(test::Assemble(""));
+  auto* p = parser(test::Assemble(""));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   auto decorations = p->GetDecorationsForMember(42, 9);
   EXPECT_TRUE(decorations.empty());
@@ -79,7 +79,7 @@
 }
 
 TEST_F(SpvParserTest, GetDecorationsForMember_NotAStruct) {
-  auto p = parser(test::Assemble("%1 = OpTypeVoid"));
+  auto* p = parser(test::Assemble("%1 = OpTypeVoid"));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   auto decorations = p->GetDecorationsFor(1);
   EXPECT_TRUE(decorations.empty());
@@ -87,7 +87,7 @@
 }
 
 TEST_F(SpvParserTest, GetDecorationsForMember_MemberWithoutDecoration) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %uint = OpTypeInt 32 0
     %10 = OpTypeStruct %uint
   )"));
@@ -99,7 +99,7 @@
 
 // TODO(dneto): Enable when ArrayStride is handled
 TEST_F(SpvParserTest, DISABLED_GetDecorationsForMember_OneDecoration) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpMemberDecorate %10 1 ArrayStride 12
     %uint = OpTypeInt 32 0
     %uint_2 = OpConstant %uint 2
@@ -117,7 +117,7 @@
 // crbug.com/tint/30 for ArrayStride
 // crbug.com/tint/31 for matrix layout
 TEST_F(SpvParserTest, DISABLED_GetDecorationsForMember_MultiDecoration) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpMemberDecorate %50 1 RelaxedPrecision
     OpMemberDecorate %50 2 ArrayStride 16
     OpMemberDecorate %50 2 MatrixStride 8
diff --git a/src/reader/spirv/parser_impl_import_test.cc b/src/reader/spirv/parser_impl_import_test.cc
index 4febd6e..afa78a3 100644
--- a/src/reader/spirv/parser_impl_import_test.cc
+++ b/src/reader/spirv/parser_impl_import_test.cc
@@ -32,7 +32,7 @@
 using ::testing::UnorderedElementsAre;
 
 TEST_F(SpvParserTest, Import_NoImport) {
-  auto p = parser(test::Assemble("%1 = OpTypeVoid"));
+  auto* p = parser(test::Assemble("%1 = OpTypeVoid"));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   const auto module_ast = p->module().to_str();
@@ -40,7 +40,7 @@
 }
 
 TEST_F(SpvParserTest, Import_ImportGlslStd450) {
-  auto p = parser(test::Assemble(R"(%1 = OpExtInstImport "GLSL.std.450")"));
+  auto* p = parser(test::Assemble(R"(%1 = OpExtInstImport "GLSL.std.450")"));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   EXPECT_THAT(p->glsl_std_450_imports(), ElementsAre(1));
@@ -49,7 +49,7 @@
 }
 
 TEST_F(SpvParserTest, Import_ImportGlslStd450Twice) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %1  = OpExtInstImport "GLSL.std.450"
     %42 = OpExtInstImport "GLSL.std.450"
   )"));
@@ -57,7 +57,7 @@
   EXPECT_TRUE(p->error().empty());
   EXPECT_THAT(p->glsl_std_450_imports(), UnorderedElementsAre(1, 42));
   const auto module = p->module();
-  EXPECT_EQ(module.imports().size(), 1);
+  EXPECT_EQ(module.imports().size(), 1u);
   const auto module_ast = module.to_str();
   // TODO(dneto): Use a matcher to show there is only one import.
   EXPECT_THAT(module_ast, HasSubstr(R"(Import{"GLSL.std.450" as std::glsl})"));
diff --git a/src/reader/spirv/parser_impl_module_var_test.cc b/src/reader/spirv/parser_impl_module_var_test.cc
index 547ae00..eb60d25 100644
--- a/src/reader/spirv/parser_impl_module_var_test.cc
+++ b/src/reader/spirv/parser_impl_module_var_test.cc
@@ -59,7 +59,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_NoVar) {
-  auto p = parser(test::Assemble(""));
+  auto* p = parser(test::Assemble(""));
   EXPECT_TRUE(p->BuildAndParseInternalModule());
   EXPECT_TRUE(p->error().empty());
   const auto module_ast = p->module().to_str();
@@ -67,7 +67,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_BadStorageClass) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %float = OpTypeFloat 32
     %ptr = OpTypePointer CrossWorkgroup %float
     %52 = OpVariable %ptr CrossWorkgroup
@@ -81,7 +81,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_BadPointerType) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %float = OpTypeFloat 32
     %fn_ty = OpTypeFunction %float
     %3 = OpTypePointer Private %fn_ty
@@ -97,7 +97,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_AnonWorkgroupVar) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %float = OpTypeFloat 32
     %ptr = OpTypePointer Workgroup %float
     %52 = OpVariable %ptr Workgroup
@@ -115,7 +115,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_NamedWorkgroupVar) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpName %52 "the_counter"
     %float = OpTypeFloat 32
     %ptr = OpTypePointer Workgroup %float
@@ -134,7 +134,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_PrivateVar) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpName %52 "my_own_private_idaho"
     %float = OpTypeFloat 32
     %ptr = OpTypePointer Private %float
@@ -153,7 +153,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_BuiltinVerteIndex) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpDecorate %52 BuiltIn VertexIndex
     %uint = OpTypeInt 32 0
     %ptr = OpTypePointer Input %uint
@@ -175,7 +175,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_ScalarInitializers) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %1 = OpVariable %ptr_bool Private %true
      %2 = OpVariable %ptr_bool Private %false
      %3 = OpVariable %ptr_int Private %int_m1
@@ -228,7 +228,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_ScalarNullInitializers) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %null_bool = OpConstantNull %bool
      %null_int = OpConstantNull %int
      %null_uint = OpConstantNull %uint
@@ -277,7 +277,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_VectorInitializer) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %ptr = OpTypePointer Private %v2float
      %two = OpConstant %float 2.0
      %const = OpConstantComposite %v2float %float_1p5 %two
@@ -301,7 +301,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_MatrixInitializer) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %ptr = OpTypePointer Private %m3v2float
      %two = OpConstant %float 2.0
      %three = OpConstant %float 3.0
@@ -343,7 +343,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_ArrayInitializer) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %ptr = OpTypePointer Private %arr2uint
      %two = OpConstant %uint 2
      %const = OpConstantComposite %arr2uint %uint_1 %two
@@ -367,7 +367,7 @@
 }
 
 TEST_F(SpvParserTest, ModuleScopeVar_StructInitializer) {
-  auto p = parser(test::Assemble(CommonTypes() + R"(
+  auto* p = parser(test::Assemble(CommonTypes() + R"(
      %ptr = OpTypePointer Private %strct
      %two = OpConstant %uint 2
      %arrconst = OpConstantComposite %arr2uint %uint_1 %two
diff --git a/src/reader/spirv/parser_impl_named_types_test.cc b/src/reader/spirv/parser_impl_named_types_test.cc
index cebfa10..0c6ba73 100644
--- a/src/reader/spirv/parser_impl_named_types_test.cc
+++ b/src/reader/spirv/parser_impl_named_types_test.cc
@@ -35,7 +35,7 @@
 using ::testing::HasSubstr;
 
 TEST_F(SpvParserTest, NamedTypes_AnonStruct) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %uint = OpTypeInt 32 0
     %s = OpTypeStruct %uint %uint
   )"));
@@ -44,7 +44,7 @@
 }
 
 TEST_F(SpvParserTest, NamedTypes_NamedStruct) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpName %s "mystruct"
     %uint = OpTypeInt 32 0
     %s = OpTypeStruct %uint %uint
@@ -55,7 +55,7 @@
 
 // TODO(dneto): Enable this when array types can have ArrayStride
 TEST_F(SpvParserTest, DISABLED_NamedTypes_AnonArrayWithDecoration) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpDecorate %arr ArrayStride 16
     %uint = OpTypeInt 32 0
     %uint_3 = OpConstant %uint 3
@@ -69,7 +69,7 @@
 // an OpName?
 
 TEST_F(SpvParserTest, NamedTypes_AnonRTArray) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     %uint = OpTypeInt 32 0
     %arr = OpTypeRuntimeArray %uint
   )"));
@@ -78,7 +78,7 @@
 }
 
 TEST_F(SpvParserTest, NamedTypes_NamedRTArray) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
     OpName %arr "myrtarr"
     %uint = OpTypeInt 32 0
     %arr = OpTypeRuntimeArray %uint
diff --git a/src/reader/spirv/parser_impl_test.cc b/src/reader/spirv/parser_impl_test.cc
index 94e944e..fe8114a 100644
--- a/src/reader/spirv/parser_impl_test.cc
+++ b/src/reader/spirv/parser_impl_test.cc
@@ -30,14 +30,14 @@
 
 TEST_F(SpvParserTest, Impl_Uint32VecEmpty) {
   std::vector<uint32_t> data;
-  auto p = parser(data);
+  auto* p = parser(data);
   EXPECT_FALSE(p->Parse());
   // TODO(dneto): What message?
 }
 
 TEST_F(SpvParserTest, Impl_InvalidModuleFails) {
   auto invalid_spv = test::Assemble("%ty = OpTypeInt 3 0");
-  auto p = parser(invalid_spv);
+  auto* p = parser(invalid_spv);
   EXPECT_FALSE(p->Parse());
   EXPECT_THAT(
       p->error(),
diff --git a/src/reader/spirv/parser_impl_test_helper.h b/src/reader/spirv/parser_impl_test_helper.h
index 4e98d26..18132ef 100644
--- a/src/reader/spirv/parser_impl_test_helper.h
+++ b/src/reader/spirv/parser_impl_test_helper.h
@@ -37,10 +37,10 @@
   ~SpvParserTestBase() = default;
 
   /// Sets up the test helper
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
   /// Tears down the test helper
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   /// Retrieves the parser from the helper
   /// @param input the SPIR-V binary to parse
diff --git a/src/reader/spirv/parser_impl_user_name_test.cc b/src/reader/spirv/parser_impl_user_name_test.cc
index ebe2761..acbe71e 100644
--- a/src/reader/spirv/parser_impl_user_name_test.cc
+++ b/src/reader/spirv/parser_impl_user_name_test.cc
@@ -28,7 +28,7 @@
 using ::testing::Eq;
 
 TEST_F(SpvParserTest, UserName_RespectOpName) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      OpName %1 "the_void_type"
      %1 = OpTypeVoid
   )"));
@@ -37,7 +37,7 @@
 }
 
 TEST_F(SpvParserTest, UserName_DistinguishDuplicateSuggestion) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      OpName %1 "vanilla"
      OpName %2 "vanilla"
      %1 = OpTypeVoid
@@ -49,7 +49,7 @@
 }
 
 TEST_F(SpvParserTest, UserName_RespectOpMemberName) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      OpMemberName %3 0 "strawberry"
      OpMemberName %3 1 "vanilla"
      OpMemberName %3 2 "chocolate"
@@ -63,7 +63,7 @@
 }
 
 TEST_F(SpvParserTest, UserName_SynthesizeMemberNames) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      %2 = OpTypeInt 32 0
      %3 = OpTypeStruct %2 %2 %2
   )"));
@@ -74,7 +74,7 @@
 }
 
 TEST_F(SpvParserTest, UserName_MemberNamesMixUserAndSynthesized) {
-  auto p = parser(test::Assemble(R"(
+  auto* p = parser(test::Assemble(R"(
      OpMemberName %3 1 "vanilla"
      %2 = OpTypeInt 32 0
      %3 = OpTypeStruct %2 %2 %2
diff --git a/src/reader/wgsl/lexer_test.cc b/src/reader/wgsl/lexer_test.cc
index 29b5ee2..3d7027f 100644
--- a/src/reader/wgsl/lexer_test.cc
+++ b/src/reader/wgsl/lexer_test.cc
@@ -36,8 +36,8 @@
 
   auto t = l.next();
   EXPECT_TRUE(t.IsIdentifier());
-  EXPECT_EQ(t.line(), 2);
-  EXPECT_EQ(t.column(), 6);
+  EXPECT_EQ(t.line(), 2u);
+  EXPECT_EQ(t.column(), 6u);
   EXPECT_EQ(t.to_str(), "ident");
 
   t = l.next();
@@ -52,14 +52,14 @@
 
   auto t = l.next();
   EXPECT_TRUE(t.IsIdentifier());
-  EXPECT_EQ(t.line(), 2);
-  EXPECT_EQ(t.column(), 1);
+  EXPECT_EQ(t.line(), 2u);
+  EXPECT_EQ(t.column(), 1u);
   EXPECT_EQ(t.to_str(), "ident1");
 
   t = l.next();
   EXPECT_TRUE(t.IsIdentifier());
-  EXPECT_EQ(t.line(), 4);
-  EXPECT_EQ(t.column(), 2);
+  EXPECT_EQ(t.line(), 4u);
+  EXPECT_EQ(t.column(), 2u);
   EXPECT_EQ(t.to_str(), "ident2");
 
   t = l.next();
@@ -72,20 +72,20 @@
   auto t = l.next();
   EXPECT_TRUE(t.IsIdentifier());
   EXPECT_EQ(t.to_str(), "id");
-  EXPECT_EQ(1, t.line());
-  EXPECT_EQ(1, t.column());
+  EXPECT_EQ(1u, t.line());
+  EXPECT_EQ(1u, t.column());
 
   t = l.next();
   EXPECT_TRUE(t.IsStringLiteral());
   EXPECT_EQ(t.to_str(), "this is string content");
-  EXPECT_EQ(1, t.line());
-  EXPECT_EQ(4, t.column());
+  EXPECT_EQ(1u, t.line());
+  EXPECT_EQ(4u, t.column());
 
   t = l.next();
   EXPECT_TRUE(t.IsIdentifier());
   EXPECT_EQ(t.to_str(), "id2");
-  EXPECT_EQ(1, t.line());
-  EXPECT_EQ(29, t.column());
+  EXPECT_EQ(1u, t.line());
+  EXPECT_EQ(29u, t.column());
 }
 
 TEST_F(LexerTest, StringTest_Unterminated) {
@@ -94,8 +94,8 @@
   auto t = l.next();
   EXPECT_TRUE(t.IsIdentifier());
   EXPECT_EQ(t.to_str(), "id");
-  EXPECT_EQ(1, t.line());
-  EXPECT_EQ(1, t.column());
+  EXPECT_EQ(1u, t.line());
+  EXPECT_EQ(1u, t.column());
 
   t = l.next();
   EXPECT_TRUE(t.IsStringLiteral());
@@ -121,8 +121,8 @@
   auto t = l.next();
   EXPECT_TRUE(t.IsFloatLiteral());
   EXPECT_EQ(t.to_f32(), params.result);
-  EXPECT_EQ(1, t.line());
-  EXPECT_EQ(1, t.column());
+  EXPECT_EQ(1u, t.line());
+  EXPECT_EQ(1u, t.column());
 
   t = l.next();
   EXPECT_TRUE(t.IsEof());
@@ -170,8 +170,8 @@
 
   auto t = l.next();
   EXPECT_TRUE(t.IsIdentifier());
-  EXPECT_EQ(t.line(), 1);
-  EXPECT_EQ(t.column(), 1);
+  EXPECT_EQ(t.line(), 1u);
+  EXPECT_EQ(t.column(), 1u);
   EXPECT_EQ(t.to_str(), GetParam());
 }
 INSTANTIATE_TEST_SUITE_P(
@@ -202,8 +202,8 @@
 
   auto t = l.next();
   EXPECT_TRUE(t.IsIntLiteral());
-  EXPECT_EQ(t.line(), 1);
-  EXPECT_EQ(t.column(), 1);
+  EXPECT_EQ(t.line(), 1u);
+  EXPECT_EQ(t.column(), 1u);
   EXPECT_EQ(t.to_i32(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
@@ -246,8 +246,8 @@
 
   auto t = l.next();
   EXPECT_TRUE(t.IsUintLiteral());
-  EXPECT_EQ(t.line(), 1);
-  EXPECT_EQ(t.column(), 1);
+  EXPECT_EQ(t.line(), 1u);
+  EXPECT_EQ(t.column(), 1u);
   EXPECT_EQ(t.to_u32(), params.result);
 }
 INSTANTIATE_TEST_SUITE_P(
@@ -284,8 +284,8 @@
   auto t = l.next();
   EXPECT_TRUE(t.IsUintLiteral());
   EXPECT_EQ(t.to_u32(), params.result);
-  EXPECT_EQ(1, t.line());
-  EXPECT_EQ(1, t.column());
+  EXPECT_EQ(1u, t.line());
+  EXPECT_EQ(1u, t.column());
 }
 INSTANTIATE_TEST_SUITE_P(LexerTest,
                          IntegerTest_Unsigned,
@@ -310,8 +310,8 @@
   auto t = l.next();
   EXPECT_TRUE(t.IsIntLiteral());
   EXPECT_EQ(t.to_i32(), params.result);
-  EXPECT_EQ(1, t.line());
-  EXPECT_EQ(1, t.column());
+  EXPECT_EQ(1u, t.line());
+  EXPECT_EQ(1u, t.column());
 }
 INSTANTIATE_TEST_SUITE_P(
     LexerTest,
@@ -350,8 +350,8 @@
 
   auto t = l.next();
   EXPECT_TRUE(t.Is(params.type));
-  EXPECT_EQ(1, t.line());
-  EXPECT_EQ(1, t.column());
+  EXPECT_EQ(1u, t.line());
+  EXPECT_EQ(1u, t.column());
 
   t = l.next();
   EXPECT_EQ(1 + std::string(params.input).size(), t.column());
@@ -399,8 +399,8 @@
 
   auto t = l.next();
   EXPECT_TRUE(t.Is(params.type));
-  EXPECT_EQ(1, t.line());
-  EXPECT_EQ(1, t.column());
+  EXPECT_EQ(1u, t.line());
+  EXPECT_EQ(1u, t.column());
 
   t = l.next();
   EXPECT_EQ(1 + std::string(params.input).size(), t.column());
@@ -500,7 +500,7 @@
 
 using KeywordTest_Reserved = testing::TestWithParam<const char*>;
 TEST_P(KeywordTest_Reserved, Parses) {
-  auto keyword = GetParam();
+  auto* keyword = GetParam();
   Lexer l(keyword);
 
   auto t = l.next();
diff --git a/src/reader/wgsl/parser_impl_additive_expression_test.cc b/src/reader/wgsl/parser_impl_additive_expression_test.cc
index 38d92ea..25c772a 100644
--- a/src/reader/wgsl/parser_impl_additive_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_additive_expression_test.cc
@@ -26,58 +26,58 @@
 namespace {
 
 TEST_F(ParserImplTest, AdditiveExpression_Parses_Plus) {
-  auto p = parser("a + true");
+  auto* p = parser("a + true");
   auto e = p->additive_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kAdd, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, AdditiveExpression_Parses_Minus) {
-  auto p = parser("a - true");
+  auto* p = parser("a - true");
   auto e = p->additive_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kSubtract, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, AdditiveExpression_InvalidLHS) {
-  auto p = parser("if (a) {} + true");
+  auto* p = parser("if (a) {} + true");
   auto e = p->additive_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, AdditiveExpression_InvalidRHS) {
-  auto p = parser("true + if (a) {}");
+  auto* p = parser("true + if (a) {}");
   auto e = p->additive_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -85,7 +85,7 @@
 }
 
 TEST_F(ParserImplTest, AdditiveExpression_NoOr_ReturnsLHS) {
-  auto p = parser("a true");
+  auto* p = parser("a true");
   auto e = p->additive_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_and_expression_test.cc b/src/reader/wgsl/parser_impl_and_expression_test.cc
index 49ef84a..d708267 100644
--- a/src/reader/wgsl/parser_impl_and_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_and_expression_test.cc
@@ -26,36 +26,36 @@
 namespace {
 
 TEST_F(ParserImplTest, AndExpression_Parses) {
-  auto p = parser("a & true");
+  auto* p = parser("a & true");
   auto e = p->and_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kAnd, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, AndExpression_InvalidLHS) {
-  auto p = parser("if (a) {} & true");
+  auto* p = parser("if (a) {} & true");
   auto e = p->and_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, AndExpression_InvalidRHS) {
-  auto p = parser("true & if (a) {}");
+  auto* p = parser("true & if (a) {}");
   auto e = p->and_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -63,7 +63,7 @@
 }
 
 TEST_F(ParserImplTest, AndExpression_NoOr_ReturnsLHS) {
-  auto p = parser("a true");
+  auto* p = parser("a true");
   auto e = p->and_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_argument_expression_list_test.cc b/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
index 650ff96..4061b11 100644
--- a/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
+++ b/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
@@ -29,34 +29,34 @@
 namespace {
 
 TEST_F(ParserImplTest, ArgumentExpressionList_Parses) {
-  auto p = parser("a");
+  auto* p = parser("a");
   auto e = p->argument_expression_list();
   ASSERT_FALSE(p->has_error()) << p->error();
 
-  ASSERT_EQ(e.size(), 1);
+  ASSERT_EQ(e.size(), 1u);
   ASSERT_TRUE(e[0]->IsIdentifier());
 }
 
 TEST_F(ParserImplTest, ArgumentExpressionList_ParsesMultiple) {
-  auto p = parser("a, -33, 1+2");
+  auto* p = parser("a, -33, 1+2");
   auto e = p->argument_expression_list();
   ASSERT_FALSE(p->has_error()) << p->error();
 
-  ASSERT_EQ(e.size(), 3);
+  ASSERT_EQ(e.size(), 3u);
   ASSERT_TRUE(e[0]->IsIdentifier());
   ASSERT_TRUE(e[1]->IsConstructor());
   ASSERT_TRUE(e[2]->IsBinary());
 }
 
 TEST_F(ParserImplTest, ArgumentExpressionList_HandlesMissingExpression) {
-  auto p = parser("a, ");
+  auto* p = parser("a, ");
   auto e = p->argument_expression_list();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:4: unable to parse argument expression after comma");
 }
 
 TEST_F(ParserImplTest, ArgumentExpressionList_HandlesInvalidExpression) {
-  auto p = parser("if(a) {}");
+  auto* p = parser("if(a) {}");
   auto e = p->argument_expression_list();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:1: unable to parse argument expression");
diff --git a/src/reader/wgsl/parser_impl_assignment_stmt_test.cc b/src/reader/wgsl/parser_impl_assignment_stmt_test.cc
index b4cc88d..581b62b 100644
--- a/src/reader/wgsl/parser_impl_assignment_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_assignment_stmt_test.cc
@@ -29,7 +29,7 @@
 namespace {
 
 TEST_F(ParserImplTest, AssignmentStmt_Parses_ToVariable) {
-  auto p = parser("a = 123");
+  auto* p = parser("a = 123");
   auto e = p->assignment_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -39,21 +39,21 @@
   ASSERT_NE(e->rhs(), nullptr);
 
   ASSERT_TRUE(e->lhs()->IsIdentifier());
-  auto ident = e->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = e->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(e->rhs()->IsConstructor());
   ASSERT_TRUE(e->rhs()->AsConstructor()->IsScalarConstructor());
 
-  auto init = e->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = e->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_NE(init->literal(), nullptr);
   ASSERT_TRUE(init->literal()->IsInt());
   EXPECT_EQ(init->literal()->AsInt()->value(), 123);
 }
 
 TEST_F(ParserImplTest, AssignmentStmt_Parses_ToMember) {
-  auto p = parser("a.b.c[2].d = 123");
+  auto* p = parser("a.b.c[2].d = 123");
   auto e = p->assignment_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -64,21 +64,21 @@
 
   ASSERT_TRUE(e->rhs()->IsConstructor());
   ASSERT_TRUE(e->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = e->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = e->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_NE(init->literal(), nullptr);
   ASSERT_TRUE(init->literal()->IsInt());
   EXPECT_EQ(init->literal()->AsInt()->value(), 123);
 
   ASSERT_TRUE(e->lhs()->IsMemberAccessor());
-  auto mem = e->lhs()->AsMemberAccessor();
+  auto* mem = e->lhs()->AsMemberAccessor();
 
   ASSERT_TRUE(mem->member()->IsIdentifier());
-  auto ident = mem->member()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = mem->member()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "d");
 
   ASSERT_TRUE(mem->structure()->IsArrayAccessor());
-  auto ary = mem->structure()->AsArrayAccessor();
+  auto* ary = mem->structure()->AsArrayAccessor();
 
   ASSERT_TRUE(ary->idx_expr()->IsConstructor());
   ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
@@ -91,7 +91,7 @@
   mem = ary->array()->AsMemberAccessor();
   ASSERT_TRUE(mem->member()->IsIdentifier());
   ident = mem->member()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "c");
 
   ASSERT_TRUE(mem->structure()->IsMemberAccessor());
@@ -99,17 +99,17 @@
 
   ASSERT_TRUE(mem->structure()->IsIdentifier());
   ident = mem->structure()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(mem->member()->IsIdentifier());
   ident = mem->member()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "b");
 }
 
 TEST_F(ParserImplTest, AssignmentStmt_MissingEqual) {
-  auto p = parser("a.b.c[2].d 123");
+  auto* p = parser("a.b.c[2].d 123");
   auto e = p->assignment_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -117,14 +117,14 @@
 }
 
 TEST_F(ParserImplTest, AssignmentStmt_InvalidLHS) {
-  auto p = parser("if (true) {} = 123");
+  auto* p = parser("if (true) {} = 123");
   auto e = p->assignment_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, AssignmentStmt_InvalidRHS) {
-  auto p = parser("a.b.c[2].d = if (true) {}");
+  auto* p = parser("a.b.c[2].d = if (true) {}");
   auto e = p->assignment_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_body_stmt_test.cc b/src/reader/wgsl/parser_impl_body_stmt_test.cc
index a92a001..6f16508 100644
--- a/src/reader/wgsl/parser_impl_body_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_body_stmt_test.cc
@@ -22,35 +22,35 @@
 namespace {
 
 TEST_F(ParserImplTest, BodyStmt) {
-  auto p = parser(R"({
+  auto* p = parser(R"({
   kill;
   nop;
   return 1 + b / 2;
 })");
   auto e = p->body_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_EQ(e.size(), 3);
+  ASSERT_EQ(e.size(), 3u);
   EXPECT_TRUE(e[0]->IsKill());
   EXPECT_TRUE(e[1]->IsNop());
   EXPECT_TRUE(e[2]->IsReturn());
 }
 
 TEST_F(ParserImplTest, BodyStmt_Empty) {
-  auto p = parser("{}");
+  auto* p = parser("{}");
   auto e = p->body_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
-  EXPECT_EQ(e.size(), 0);
+  EXPECT_EQ(e.size(), 0u);
 }
 
 TEST_F(ParserImplTest, BodyStmt_InvalidStmt) {
-  auto p = parser("{fn main() -> void {}}");
+  auto* p = parser("{fn main() -> void {}}");
   auto e = p->body_stmt();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:2: missing }");
 }
 
 TEST_F(ParserImplTest, BodyStmt_MissingRightParen) {
-  auto p = parser("{return;");
+  auto* p = parser("{return;");
   auto e = p->body_stmt();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:9: missing }");
diff --git a/src/reader/wgsl/parser_impl_break_stmt_test.cc b/src/reader/wgsl/parser_impl_break_stmt_test.cc
index 688c5b8..45ff183 100644
--- a/src/reader/wgsl/parser_impl_break_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_break_stmt_test.cc
@@ -25,7 +25,7 @@
 namespace {
 
 TEST_F(ParserImplTest, BreakStmt) {
-  auto p = parser("break");
+  auto* p = parser("break");
   auto e = p->break_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -35,7 +35,7 @@
 }
 
 TEST_F(ParserImplTest, BreakStmt_WithIf) {
-  auto p = parser("break if (a == b)");
+  auto* p = parser("break if (a == b)");
   auto e = p->break_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -46,7 +46,7 @@
 }
 
 TEST_F(ParserImplTest, BreakStmt_WithUnless) {
-  auto p = parser("break unless (a == b)");
+  auto* p = parser("break unless (a == b)");
   auto e = p->break_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -57,7 +57,7 @@
 }
 
 TEST_F(ParserImplTest, BreakStmt_InvalidRHS) {
-  auto p = parser("break if (a = b)");
+  auto* p = parser("break if (a = b)");
   auto e = p->break_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -65,7 +65,7 @@
 }
 
 TEST_F(ParserImplTest, BreakStmt_MissingRHS) {
-  auto p = parser("break if");
+  auto* p = parser("break if");
   auto e = p->break_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_builtin_decoration_test.cc b/src/reader/wgsl/parser_impl_builtin_decoration_test.cc
index 47cb2f8..7a4cb92 100644
--- a/src/reader/wgsl/parser_impl_builtin_decoration_test.cc
+++ b/src/reader/wgsl/parser_impl_builtin_decoration_test.cc
@@ -36,9 +36,9 @@
   BuiltinTest() = default;
   ~BuiltinTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -52,7 +52,7 @@
 
 TEST_P(BuiltinTest, Parses) {
   auto params = GetParam();
-  auto p = parser(params.input);
+  auto* p = parser(params.input);
 
   auto builtin = p->builtin_decoration();
   ASSERT_FALSE(p->has_error());
@@ -79,7 +79,7 @@
                     ast::Builtin::kGlobalInvocationId}));
 
 TEST_F(ParserImplTest, BuiltinDecoration_NoMatch) {
-  auto p = parser("not-a-builtin");
+  auto* p = parser("not-a-builtin");
   auto builtin = p->builtin_decoration();
   ASSERT_EQ(builtin, ast::Builtin::kNone);
 
diff --git a/src/reader/wgsl/parser_impl_case_body_test.cc b/src/reader/wgsl/parser_impl_case_body_test.cc
index d02a599..8196c5b 100644
--- a/src/reader/wgsl/parser_impl_case_body_test.cc
+++ b/src/reader/wgsl/parser_impl_case_body_test.cc
@@ -22,45 +22,45 @@
 namespace {
 
 TEST_F(ParserImplTest, CaseBody_Empty) {
-  auto p = parser("");
+  auto* p = parser("");
   auto e = p->case_body();
   ASSERT_FALSE(p->has_error()) << p->error();
-  EXPECT_EQ(e.size(), 0);
+  EXPECT_EQ(e.size(), 0u);
 }
 
 TEST_F(ParserImplTest, CaseBody_Statements) {
-  auto p = parser(R"(
+  auto* p = parser(R"(
   var a: i32;
   a = 2;)");
 
   auto e = p->case_body();
   ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_EQ(e.size(), 2);
+  ASSERT_EQ(e.size(), 2u);
   EXPECT_TRUE(e[0]->IsVariableDecl());
   EXPECT_TRUE(e[1]->IsAssign());
 }
 
 TEST_F(ParserImplTest, CaseBody_InvalidStatement) {
-  auto p = parser("a =");
+  auto* p = parser("a =");
   auto e = p->case_body();
   ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(e.size(), 0);
+  EXPECT_EQ(e.size(), 0u);
   EXPECT_EQ(p->error(), "1:4: unable to parse right side of assignment");
 }
 
 TEST_F(ParserImplTest, CaseBody_Fallthrough) {
-  auto p = parser("fallthrough;");
+  auto* p = parser("fallthrough;");
   auto e = p->case_body();
   ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_EQ(e.size(), 1);
+  ASSERT_EQ(e.size(), 1u);
   EXPECT_TRUE(e[0]->IsFallthrough());
 }
 
 TEST_F(ParserImplTest, CaseBody_Fallthrough_MissingSemicolon) {
-  auto p = parser("fallthrough");
+  auto* p = parser("fallthrough");
   auto e = p->case_body();
   ASSERT_TRUE(p->has_error());
-  EXPECT_EQ(e.size(), 0);
+  EXPECT_EQ(e.size(), 0u);
   EXPECT_EQ(p->error(), "1:12: missing ;");
 }
 
diff --git a/src/reader/wgsl/parser_impl_const_expr_test.cc b/src/reader/wgsl/parser_impl_const_expr_test.cc
index ca18fcf..4f4ecbc 100644
--- a/src/reader/wgsl/parser_impl_const_expr_test.cc
+++ b/src/reader/wgsl/parser_impl_const_expr_test.cc
@@ -27,23 +27,23 @@
 namespace {
 
 TEST_F(ParserImplTest, ConstExpr_TypeDecl) {
-  auto p = parser("vec2<f32>(1., 2.)");
+  auto* p = parser("vec2<f32>(1., 2.)");
   auto e = p->const_expr();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsConstructor());
   ASSERT_TRUE(e->AsConstructor()->IsTypeConstructor());
 
-  auto t = e->AsConstructor()->AsTypeConstructor();
+  auto* t = e->AsConstructor()->AsTypeConstructor();
   ASSERT_TRUE(t->type()->IsVector());
-  EXPECT_EQ(t->type()->AsVector()->size(), 2);
+  EXPECT_EQ(t->type()->AsVector()->size(), 2u);
 
-  ASSERT_EQ(t->values().size(), 2);
+  ASSERT_EQ(t->values().size(), 2u);
   auto& v = t->values();
 
   ASSERT_TRUE(v[0]->IsConstructor());
   ASSERT_TRUE(v[0]->AsConstructor()->IsScalarConstructor());
-  auto c = v[0]->AsConstructor()->AsScalarConstructor();
+  auto* c = v[0]->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(c->literal()->IsFloat());
   EXPECT_FLOAT_EQ(c->literal()->AsFloat()->value(), 1.);
 
@@ -55,7 +55,7 @@
 }
 
 TEST_F(ParserImplTest, ConstExpr_TypeDecl_MissingRightParen) {
-  auto p = parser("vec2<f32>(1., 2.");
+  auto* p = parser("vec2<f32>(1., 2.");
   auto e = p->const_expr();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -63,7 +63,7 @@
 }
 
 TEST_F(ParserImplTest, ConstExpr_TypeDecl_MissingLeftParen) {
-  auto p = parser("vec2<f32> 1., 2.)");
+  auto* p = parser("vec2<f32> 1., 2.)");
   auto e = p->const_expr();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -71,7 +71,7 @@
 }
 
 TEST_F(ParserImplTest, ConstExpr_TypeDecl_HangingComma) {
-  auto p = parser("vec2<f32>(1.,)");
+  auto* p = parser("vec2<f32>(1.,)");
   auto e = p->const_expr();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -79,7 +79,7 @@
 }
 
 TEST_F(ParserImplTest, ConstExpr_TypeDecl_MissingComma) {
-  auto p = parser("vec2<f32>(1. 2.");
+  auto* p = parser("vec2<f32>(1. 2.");
   auto e = p->const_expr();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -87,7 +87,7 @@
 }
 
 TEST_F(ParserImplTest, ConstExpr_MissingExpr) {
-  auto p = parser("vec2<f32>()");
+  auto* p = parser("vec2<f32>()");
   auto e = p->const_expr();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -95,7 +95,7 @@
 }
 
 TEST_F(ParserImplTest, ConstExpr_InvalidExpr) {
-  auto p = parser("vec2<f32>(1., if(a) {})");
+  auto* p = parser("vec2<f32>(1., if(a) {})");
   auto e = p->const_expr();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -103,19 +103,19 @@
 }
 
 TEST_F(ParserImplTest, ConstExpr_ConstLiteral) {
-  auto p = parser("true");
+  auto* p = parser("true");
   auto e = p->const_expr();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsConstructor());
   ASSERT_TRUE(e->AsConstructor()->IsScalarConstructor());
-  auto c = e->AsConstructor()->AsScalarConstructor();
+  auto* c = e->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(c->literal()->IsBool());
   EXPECT_TRUE(c->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, ConstExpr_ConstLiteral_Invalid) {
-  auto p = parser("invalid");
+  auto* p = parser("invalid");
   auto e = p->const_expr();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_const_literal_test.cc b/src/reader/wgsl/parser_impl_const_literal_test.cc
index ed474d9..fec1ad9 100644
--- a/src/reader/wgsl/parser_impl_const_literal_test.cc
+++ b/src/reader/wgsl/parser_impl_const_literal_test.cc
@@ -26,7 +26,7 @@
 namespace {
 
 TEST_F(ParserImplTest, ConstLiteral_Int) {
-  auto p = parser("-234");
+  auto* p = parser("-234");
   auto c = p->const_literal();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(c, nullptr);
@@ -35,7 +35,7 @@
 }
 
 TEST_F(ParserImplTest, ConstLiteral_Uint) {
-  auto p = parser("234u");
+  auto* p = parser("234u");
   auto c = p->const_literal();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(c, nullptr);
@@ -44,7 +44,7 @@
 }
 
 TEST_F(ParserImplTest, ConstLiteral_Float) {
-  auto p = parser("234.e12");
+  auto* p = parser("234.e12");
   auto c = p->const_literal();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(c, nullptr);
@@ -53,13 +53,13 @@
 }
 
 TEST_F(ParserImplTest, ConstLiteral_InvalidFloat) {
-  auto p = parser("1.2e+256");
+  auto* p = parser("1.2e+256");
   auto c = p->const_literal();
   ASSERT_EQ(c, nullptr);
 }
 
 TEST_F(ParserImplTest, ConstLiteral_True) {
-  auto p = parser("true");
+  auto* p = parser("true");
   auto c = p->const_literal();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(c, nullptr);
@@ -68,7 +68,7 @@
 }
 
 TEST_F(ParserImplTest, ConstLiteral_False) {
-  auto p = parser("false");
+  auto* p = parser("false");
   auto c = p->const_literal();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(c, nullptr);
@@ -77,7 +77,7 @@
 }
 
 TEST_F(ParserImplTest, ConstLiteral_NoMatch) {
-  auto p = parser("another-token");
+  auto* p = parser("another-token");
   auto c = p->const_literal();
   ASSERT_FALSE(p->has_error());
   ASSERT_EQ(c, nullptr);
diff --git a/src/reader/wgsl/parser_impl_continue_stmt_test.cc b/src/reader/wgsl/parser_impl_continue_stmt_test.cc
index f1e05c2..9a7b6fa 100644
--- a/src/reader/wgsl/parser_impl_continue_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_continue_stmt_test.cc
@@ -25,7 +25,7 @@
 namespace {
 
 TEST_F(ParserImplTest, ContinueStmt) {
-  auto p = parser("continue");
+  auto* p = parser("continue");
   auto e = p->continue_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -35,7 +35,7 @@
 }
 
 TEST_F(ParserImplTest, ContinueStmt_WithIf) {
-  auto p = parser("continue if (a == b)");
+  auto* p = parser("continue if (a == b)");
   auto e = p->continue_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -46,7 +46,7 @@
 }
 
 TEST_F(ParserImplTest, ContinueStmt_WithUnless) {
-  auto p = parser("continue unless (a == b)");
+  auto* p = parser("continue unless (a == b)");
   auto e = p->continue_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -57,7 +57,7 @@
 }
 
 TEST_F(ParserImplTest, ContinueStmt_InvalidRHS) {
-  auto p = parser("continue if (a = b)");
+  auto* p = parser("continue if (a = b)");
   auto e = p->continue_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -65,7 +65,7 @@
 }
 
 TEST_F(ParserImplTest, ContinueStmt_MissingRHS) {
-  auto p = parser("continue if");
+  auto* p = parser("continue if");
   auto e = p->continue_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_continuing_stmt_test.cc b/src/reader/wgsl/parser_impl_continuing_stmt_test.cc
index b83fcf8..c996c84 100644
--- a/src/reader/wgsl/parser_impl_continuing_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_continuing_stmt_test.cc
@@ -22,18 +22,18 @@
 namespace {
 
 TEST_F(ParserImplTest, ContinuingStmt) {
-  auto p = parser("continuing { nop; }");
+  auto* p = parser("continuing { nop; }");
   auto e = p->continuing_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_EQ(e.size(), 1);
+  ASSERT_EQ(e.size(), 1u);
   ASSERT_TRUE(e[0]->IsNop());
 }
 
 TEST_F(ParserImplTest, ContinuingStmt_InvalidBody) {
-  auto p = parser("continuing { nop }");
+  auto* p = parser("continuing { nop }");
   auto e = p->continuing_stmt();
   ASSERT_TRUE(p->has_error());
-  ASSERT_EQ(e.size(), 0);
+  ASSERT_EQ(e.size(), 0u);
   EXPECT_EQ(p->error(), "1:18: missing ;");
 }
 
diff --git a/src/reader/wgsl/parser_impl_derivative_modifier_test.cc b/src/reader/wgsl/parser_impl_derivative_modifier_test.cc
index 72e88f4..a559258 100644
--- a/src/reader/wgsl/parser_impl_derivative_modifier_test.cc
+++ b/src/reader/wgsl/parser_impl_derivative_modifier_test.cc
@@ -38,9 +38,9 @@
   DerivativeModifierTest() = default;
   ~DerivativeModifierTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -54,7 +54,7 @@
 
 TEST_P(DerivativeModifierTest, Parses) {
   auto params = GetParam();
-  auto p = parser(params.input);
+  auto* p = parser(params.input);
 
   auto mod = p->derivative_modifier();
   ASSERT_FALSE(p->has_error());
@@ -71,7 +71,7 @@
         DerivativeModifierData{"coarse", ast::DerivativeModifier::kCoarse}));
 
 TEST_F(ParserImplTest, DerivativeModifier_NoMatch) {
-  auto p = parser("not-a-modifier");
+  auto* p = parser("not-a-modifier");
   auto stage = p->derivative_modifier();
   ASSERT_EQ(stage, ast::DerivativeModifier::kNone);
 
diff --git a/src/reader/wgsl/parser_impl_else_stmt_test.cc b/src/reader/wgsl/parser_impl_else_stmt_test.cc
index 6de2169..377f997 100644
--- a/src/reader/wgsl/parser_impl_else_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_else_stmt_test.cc
@@ -23,17 +23,17 @@
 namespace {
 
 TEST_F(ParserImplTest, ElseStmt) {
-  auto p = parser("else { a = b; c = d; }");
+  auto* p = parser("else { a = b; c = d; }");
   auto e = p->else_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsElse());
   ASSERT_EQ(e->condition(), nullptr);
-  EXPECT_EQ(e->body().size(), 2);
+  EXPECT_EQ(e->body().size(), 2u);
 }
 
 TEST_F(ParserImplTest, ElseStmt_InvalidBody) {
-  auto p = parser("else { fn main() -> void {}}");
+  auto* p = parser("else { fn main() -> void {}}");
   auto e = p->else_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -41,7 +41,7 @@
 }
 
 TEST_F(ParserImplTest, ElseStmt_MissingBody) {
-  auto p = parser("else");
+  auto* p = parser("else");
   auto e = p->else_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_elseif_stmt_test.cc b/src/reader/wgsl/parser_impl_elseif_stmt_test.cc
index 147b3d4..578006c 100644
--- a/src/reader/wgsl/parser_impl_elseif_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_elseif_stmt_test.cc
@@ -23,43 +23,43 @@
 namespace {
 
 TEST_F(ParserImplTest, ElseIfStmt) {
-  auto p = parser("elseif (a == 4) { a = b; c = d; }");
+  auto* p = parser("elseif (a == 4) { a = b; c = d; }");
   auto e = p->elseif_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_EQ(e.size(), 1);
+  ASSERT_EQ(e.size(), 1u);
 
   ASSERT_TRUE(e[0]->IsElse());
   ASSERT_NE(e[0]->condition(), nullptr);
   ASSERT_TRUE(e[0]->condition()->IsBinary());
-  EXPECT_EQ(e[0]->body().size(), 2);
+  EXPECT_EQ(e[0]->body().size(), 2u);
 }
 
 TEST_F(ParserImplTest, ElseIfStmt_Multiple) {
-  auto p = parser("elseif (a == 4) { a = b; c = d; } elseif(c) { d = 2; }");
+  auto* p = parser("elseif (a == 4) { a = b; c = d; } elseif(c) { d = 2; }");
   auto e = p->elseif_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_EQ(e.size(), 2);
+  ASSERT_EQ(e.size(), 2u);
 
   ASSERT_TRUE(e[0]->IsElse());
   ASSERT_NE(e[0]->condition(), nullptr);
   ASSERT_TRUE(e[0]->condition()->IsBinary());
-  EXPECT_EQ(e[0]->body().size(), 2);
+  EXPECT_EQ(e[0]->body().size(), 2u);
 
   ASSERT_TRUE(e[1]->IsElse());
   ASSERT_NE(e[1]->condition(), nullptr);
   ASSERT_TRUE(e[1]->condition()->IsIdentifier());
-  EXPECT_EQ(e[1]->body().size(), 1);
+  EXPECT_EQ(e[1]->body().size(), 1u);
 }
 
 TEST_F(ParserImplTest, ElseIfStmt_InvalidBody) {
-  auto p = parser("elseif (true) { fn main() -> void {}}");
+  auto* p = parser("elseif (true) { fn main() -> void {}}");
   auto e = p->elseif_stmt();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:17: missing }");
 }
 
 TEST_F(ParserImplTest, ElseIfStmt_MissingBody) {
-  auto p = parser("elseif (true)");
+  auto* p = parser("elseif (true)");
   auto e = p->elseif_stmt();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:14: missing {");
diff --git a/src/reader/wgsl/parser_impl_entry_point_decl_test.cc b/src/reader/wgsl/parser_impl_entry_point_decl_test.cc
index 774cc7f..ede75b3 100644
--- a/src/reader/wgsl/parser_impl_entry_point_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_entry_point_decl_test.cc
@@ -23,7 +23,7 @@
 namespace {
 
 TEST_F(ParserImplTest, EntryPoint_Parses) {
-  auto p = parser("entry_point fragment = main");
+  auto* p = parser("entry_point fragment = main");
   auto e = p->entry_point_decl();
   ASSERT_NE(e, nullptr);
   ASSERT_FALSE(p->has_error());
@@ -33,7 +33,7 @@
 }
 
 TEST_F(ParserImplTest, EntryPoint_ParsesWithStringName) {
-  auto p = parser(R"(entry_point vertex as "main" = vtx_main)");
+  auto* p = parser(R"(entry_point vertex as "main" = vtx_main)");
   auto e = p->entry_point_decl();
   ASSERT_NE(e, nullptr);
   ASSERT_FALSE(p->has_error());
@@ -43,7 +43,7 @@
 }
 
 TEST_F(ParserImplTest, EntryPoint_ParsesWithIdentName) {
-  auto p = parser(R"(entry_point vertex as main = vtx_main)");
+  auto* p = parser(R"(entry_point vertex as main = vtx_main)");
   auto e = p->entry_point_decl();
   ASSERT_NE(e, nullptr);
   ASSERT_FALSE(p->has_error());
@@ -53,7 +53,7 @@
 }
 
 TEST_F(ParserImplTest, EntryPoint_MissingFnName) {
-  auto p = parser(R"(entry_point vertex as main =)");
+  auto* p = parser(R"(entry_point vertex as main =)");
   auto e = p->entry_point_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -61,7 +61,7 @@
 }
 
 TEST_F(ParserImplTest, EntryPoint_InvalidFnName) {
-  auto p = parser(R"(entry_point vertex as main = 123)");
+  auto* p = parser(R"(entry_point vertex as main = 123)");
   auto e = p->entry_point_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -69,7 +69,7 @@
 }
 
 TEST_F(ParserImplTest, EntryPoint_MissingEqual) {
-  auto p = parser(R"(entry_point vertex as main vtx_main)");
+  auto* p = parser(R"(entry_point vertex as main vtx_main)");
   auto e = p->entry_point_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -77,7 +77,7 @@
 }
 
 TEST_F(ParserImplTest, EntryPoint_MissingName) {
-  auto p = parser(R"(entry_point vertex as = vtx_main)");
+  auto* p = parser(R"(entry_point vertex as = vtx_main)");
   auto e = p->entry_point_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -85,7 +85,7 @@
 }
 
 TEST_F(ParserImplTest, EntryPoint_InvalidName) {
-  auto p = parser(R"(entry_point vertex as 123 = vtx_main)");
+  auto* p = parser(R"(entry_point vertex as 123 = vtx_main)");
   auto e = p->entry_point_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -93,7 +93,7 @@
 }
 
 TEST_F(ParserImplTest, EntryPoint_MissingStageWithIdent) {
-  auto p = parser(R"(entry_point as 123 = vtx_main)");
+  auto* p = parser(R"(entry_point as 123 = vtx_main)");
   auto e = p->entry_point_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -101,7 +101,7 @@
 }
 
 TEST_F(ParserImplTest, EntryPoint_MissingStage) {
-  auto p = parser(R"(entry_point = vtx_main)");
+  auto* p = parser(R"(entry_point = vtx_main)");
   auto e = p->entry_point_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -109,7 +109,7 @@
 }
 
 TEST_F(ParserImplTest, EntryPoint_InvalidStage) {
-  auto p = parser(R"(entry_point invalid = vtx_main)");
+  auto* p = parser(R"(entry_point invalid = vtx_main)");
   auto e = p->entry_point_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_equality_expression_test.cc b/src/reader/wgsl/parser_impl_equality_expression_test.cc
index 39a83b6..c427e6c 100644
--- a/src/reader/wgsl/parser_impl_equality_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_equality_expression_test.cc
@@ -26,58 +26,58 @@
 namespace {
 
 TEST_F(ParserImplTest, EqualityExpression_Parses_Equal) {
-  auto p = parser("a == true");
+  auto* p = parser("a == true");
   auto e = p->equality_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kEqual, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, EqualityExpression_Parses_NotEqual) {
-  auto p = parser("a != true");
+  auto* p = parser("a != true");
   auto e = p->equality_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kNotEqual, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, EqualityExpression_InvalidLHS) {
-  auto p = parser("if (a) {} == true");
+  auto* p = parser("if (a) {} == true");
   auto e = p->equality_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, EqualityExpression_InvalidRHS) {
-  auto p = parser("true == if (a) {}");
+  auto* p = parser("true == if (a) {}");
   auto e = p->equality_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -85,7 +85,7 @@
 }
 
 TEST_F(ParserImplTest, EqualityExpression_NoOr_ReturnsLHS) {
-  auto p = parser("a true");
+  auto* p = parser("a true");
   auto e = p->equality_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_exclusive_or_expression_test.cc b/src/reader/wgsl/parser_impl_exclusive_or_expression_test.cc
index bb4d21b..1e2d120 100644
--- a/src/reader/wgsl/parser_impl_exclusive_or_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_exclusive_or_expression_test.cc
@@ -26,36 +26,36 @@
 namespace {
 
 TEST_F(ParserImplTest, ExclusiveOrExpression_Parses) {
-  auto p = parser("a ^ true");
+  auto* p = parser("a ^ true");
   auto e = p->exclusive_or_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kXor, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, ExclusiveOrExpression_InvalidLHS) {
-  auto p = parser("if (a) {} ^ true");
+  auto* p = parser("if (a) {} ^ true");
   auto e = p->exclusive_or_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, ExclusiveOrExpression_InvalidRHS) {
-  auto p = parser("true ^ if (a) {}");
+  auto* p = parser("true ^ if (a) {}");
   auto e = p->exclusive_or_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -63,7 +63,7 @@
 }
 
 TEST_F(ParserImplTest, ExclusiveOrExpression_NoOr_ReturnsLHS) {
-  auto p = parser("a true");
+  auto* p = parser("a true");
   auto e = p->exclusive_or_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_function_decl_test.cc b/src/reader/wgsl/parser_impl_function_decl_test.cc
index be9b2e0..271634e 100644
--- a/src/reader/wgsl/parser_impl_function_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_function_decl_test.cc
@@ -24,7 +24,7 @@
 namespace {
 
 TEST_F(ParserImplTest, FunctionDecl) {
-  auto p = parser("fn main(a : i32, b : f32) -> void { return; }");
+  auto* p = parser("fn main(a : i32, b : f32) -> void { return; }");
   auto f = p->function_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(f, nullptr);
@@ -33,19 +33,19 @@
   ASSERT_NE(f->return_type(), nullptr);
   EXPECT_TRUE(f->return_type()->IsVoid());
 
-  ASSERT_EQ(f->params().size(), 2);
+  ASSERT_EQ(f->params().size(), 2u);
   EXPECT_EQ(f->params()[0]->name(), "a");
   EXPECT_EQ(f->params()[1]->name(), "b");
 
   ASSERT_NE(f->return_type(), nullptr);
   EXPECT_TRUE(f->return_type()->IsVoid());
 
-  ASSERT_EQ(f->body().size(), 1);
+  ASSERT_EQ(f->body().size(), 1u);
   EXPECT_TRUE(f->body()[0]->IsReturn());
 }
 
 TEST_F(ParserImplTest, FunctionDecl_InvalidHeader) {
-  auto p = parser("fn main() -> { }");
+  auto* p = parser("fn main() -> { }");
   auto f = p->function_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(f, nullptr);
@@ -53,7 +53,7 @@
 }
 
 TEST_F(ParserImplTest, FunctionDecl_InvalidBody) {
-  auto p = parser("fn main() -> void { return }");
+  auto* p = parser("fn main() -> void { return }");
   auto f = p->function_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(f, nullptr);
diff --git a/src/reader/wgsl/parser_impl_function_header_test.cc b/src/reader/wgsl/parser_impl_function_header_test.cc
index 94b9886..2b482f8 100644
--- a/src/reader/wgsl/parser_impl_function_header_test.cc
+++ b/src/reader/wgsl/parser_impl_function_header_test.cc
@@ -24,20 +24,20 @@
 namespace {
 
 TEST_F(ParserImplTest, FunctionHeader) {
-  auto p = parser("fn main(a : i32, b: f32) -> void");
+  auto* p = parser("fn main(a : i32, b: f32) -> void");
   auto f = p->function_header();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(f, nullptr);
 
   EXPECT_EQ(f->name(), "main");
-  ASSERT_EQ(f->params().size(), 2);
+  ASSERT_EQ(f->params().size(), 2u);
   EXPECT_EQ(f->params()[0]->name(), "a");
   EXPECT_EQ(f->params()[1]->name(), "b");
   EXPECT_TRUE(f->return_type()->IsVoid());
 }
 
 TEST_F(ParserImplTest, FunctionHeader_MissingIdent) {
-  auto p = parser("fn () ->");
+  auto* p = parser("fn () ->");
   auto f = p->function_header();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(f, nullptr);
@@ -45,7 +45,7 @@
 }
 
 TEST_F(ParserImplTest, FunctionHeader_InvalidIdent) {
-  auto p = parser("fn 133main() -> i32");
+  auto* p = parser("fn 133main() -> i32");
   auto f = p->function_header();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(f, nullptr);
@@ -53,7 +53,7 @@
 }
 
 TEST_F(ParserImplTest, FunctionHeader_MissingParenLeft) {
-  auto p = parser("fn main) -> i32");
+  auto* p = parser("fn main) -> i32");
   auto f = p->function_header();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(f, nullptr);
@@ -61,7 +61,7 @@
 }
 
 TEST_F(ParserImplTest, FunctionHeader_InvalidParamList) {
-  auto p = parser("fn main(a :i32,) -> i32");
+  auto* p = parser("fn main(a :i32,) -> i32");
   auto f = p->function_header();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(f, nullptr);
@@ -69,7 +69,7 @@
 }
 
 TEST_F(ParserImplTest, FunctionHeader_MissingParenRight) {
-  auto p = parser("fn main( -> i32");
+  auto* p = parser("fn main( -> i32");
   auto f = p->function_header();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(f, nullptr);
@@ -77,7 +77,7 @@
 }
 
 TEST_F(ParserImplTest, FunctionHeader_MissingArrow) {
-  auto p = parser("fn main() i32");
+  auto* p = parser("fn main() i32");
   auto f = p->function_header();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(f, nullptr);
@@ -85,7 +85,7 @@
 }
 
 TEST_F(ParserImplTest, FunctionHeader_InvalidReturnType) {
-  auto p = parser("fn main() -> invalid");
+  auto* p = parser("fn main() -> invalid");
   auto f = p->function_header();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(f, nullptr);
@@ -93,7 +93,7 @@
 }
 
 TEST_F(ParserImplTest, FunctionHeader_MissingReturnType) {
-  auto p = parser("fn main() ->");
+  auto* p = parser("fn main() ->");
   auto f = p->function_header();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(f, nullptr);
diff --git a/src/reader/wgsl/parser_impl_function_type_decl_test.cc b/src/reader/wgsl/parser_impl_function_type_decl_test.cc
index 7a9e737..c5e4e16 100644
--- a/src/reader/wgsl/parser_impl_function_type_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_function_type_decl_test.cc
@@ -28,27 +28,27 @@
 namespace {
 
 TEST_F(ParserImplTest, FunctionTypeDecl_Void) {
-  auto v = tm()->Get(std::make_unique<ast::type::VoidType>());
+  auto* v = tm()->Get(std::make_unique<ast::type::VoidType>());
 
-  auto p = parser("void");
-  auto e = p->function_type_decl();
+  auto* p = parser("void");
+  auto* e = p->function_type_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, v);
 }
 
 TEST_F(ParserImplTest, FunctionTypeDecl_Type) {
-  auto f32 = tm()->Get(std::make_unique<ast::type::F32Type>());
-  auto vec2 = tm()->Get(std::make_unique<ast::type::VectorType>(f32, 2));
+  auto* f32 = tm()->Get(std::make_unique<ast::type::F32Type>());
+  auto* vec2 = tm()->Get(std::make_unique<ast::type::VectorType>(f32, 2));
 
-  auto p = parser("vec2<f32>");
-  auto e = p->function_type_decl();
+  auto* p = parser("vec2<f32>");
+  auto* e = p->function_type_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, vec2);
 }
 
 TEST_F(ParserImplTest, FunctionTypeDecl_InvalidType) {
-  auto p = parser("vec2<invalid>");
-  auto e = p->function_type_decl();
+  auto* p = parser("vec2<invalid>");
+  auto* e = p->function_type_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
   EXPECT_EQ(p->error(), "1:6: unknown type alias 'invalid'");
diff --git a/src/reader/wgsl/parser_impl_global_constant_decl_test.cc b/src/reader/wgsl/parser_impl_global_constant_decl_test.cc
index 3f53a04..c9abe0a 100644
--- a/src/reader/wgsl/parser_impl_global_constant_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_global_constant_decl_test.cc
@@ -24,7 +24,7 @@
 namespace {
 
 TEST_F(ParserImplTest, GlobalConstantDecl) {
-  auto p = parser("const a : f32 = 1.");
+  auto* p = parser("const a : f32 = 1.");
   auto e = p->global_constant_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -39,7 +39,7 @@
 }
 
 TEST_F(ParserImplTest, GlobalConstantDecl_MissingEqual) {
-  auto p = parser("const a: f32 1.");
+  auto* p = parser("const a: f32 1.");
   auto e = p->global_constant_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -47,7 +47,7 @@
 }
 
 TEST_F(ParserImplTest, GlobalConstantDecl_InvalidVariable) {
-  auto p = parser("const a: invalid = 1.");
+  auto* p = parser("const a: invalid = 1.");
   auto e = p->global_constant_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -55,7 +55,7 @@
 }
 
 TEST_F(ParserImplTest, GlobalConstantDecl_InvalidExpression) {
-  auto p = parser("const a: f32 = if (a) {}");
+  auto* p = parser("const a: f32 = if (a) {}");
   auto e = p->global_constant_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -63,7 +63,7 @@
 }
 
 TEST_F(ParserImplTest, GlobalConstantDecl_MissingExpression) {
-  auto p = parser("const a: f32 =");
+  auto* p = parser("const a: f32 =");
   auto e = p->global_constant_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_global_decl_test.cc b/src/reader/wgsl/parser_impl_global_decl_test.cc
index 188a658..489f07d 100644
--- a/src/reader/wgsl/parser_impl_global_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_global_decl_test.cc
@@ -22,18 +22,18 @@
 namespace {
 
 TEST_F(ParserImplTest, GlobalDecl_Semicolon) {
-  auto p = parser(";");
+  auto* p = parser(";");
   p->global_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
 }
 
 TEST_F(ParserImplTest, GlobalDecl_Import) {
-  auto p = parser(R"(import "GLSL.std.430" as glsl;)");
+  auto* p = parser(R"(import "GLSL.std.430" as glsl;)");
   p->global_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
 
   auto m = p->module();
-  ASSERT_EQ(1, m.imports().size());
+  ASSERT_EQ(1u, m.imports().size());
 
   const auto& import = m.imports()[0];
   EXPECT_EQ("GLSL.std.430", import->path());
@@ -41,7 +41,7 @@
 }
 
 TEST_F(ParserImplTest, GlobalDecl_Import_Invalid) {
-  auto p = parser(R"(import as glsl;)");
+  auto* p = parser(R"(import as glsl;)");
   p->global_decl();
 
   ASSERT_TRUE(p->has_error());
@@ -49,7 +49,7 @@
 }
 
 TEST_F(ParserImplTest, GlobalDecl_Import_Invalid_MissingSemicolon) {
-  auto p = parser(R"(import "GLSL.std.430" as glsl)");
+  auto* p = parser(R"(import "GLSL.std.430" as glsl)");
   p->global_decl();
 
   ASSERT_TRUE(p->has_error());
@@ -57,117 +57,117 @@
 }
 
 TEST_F(ParserImplTest, GlobalDecl_GlobalVariable) {
-  auto p = parser("var<out> a : vec2<i32> = vec2<i32>(1, 2);");
+  auto* p = parser("var<out> a : vec2<i32> = vec2<i32>(1, 2);");
   p->global_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
 
   auto m = p->module();
-  ASSERT_EQ(m.global_variables().size(), 1);
+  ASSERT_EQ(m.global_variables().size(), 1u);
 
-  auto v = m.global_variables()[0].get();
+  auto* v = m.global_variables()[0].get();
   EXPECT_EQ(v->name(), "a");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_GlobalVariable_Invalid) {
-  auto p = parser("var<out> a : vec2<invalid>;");
+  auto* p = parser("var<out> a : vec2<invalid>;");
   p->global_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:19: unknown type alias 'invalid'");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_GlobalVariable_MissingSemicolon) {
-  auto p = parser("var<out> a : vec2<i32>");
+  auto* p = parser("var<out> a : vec2<i32>");
   p->global_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:23: missing ';' for variable declaration");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_GlobalConstant) {
-  auto p = parser("const a : i32 = 2;");
+  auto* p = parser("const a : i32 = 2;");
   p->global_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
 
   auto m = p->module();
-  ASSERT_EQ(m.global_variables().size(), 1);
+  ASSERT_EQ(m.global_variables().size(), 1u);
 
-  auto v = m.global_variables()[0].get();
+  auto* v = m.global_variables()[0].get();
   EXPECT_EQ(v->name(), "a");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_GlobalConstant_Invalid) {
-  auto p = parser("const a : vec2<i32>;");
+  auto* p = parser("const a : vec2<i32>;");
   p->global_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:20: missing = for const declaration");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_GlobalConstant_MissingSemicolon) {
-  auto p = parser("const a : vec2<i32> = vec2<i32>(1, 2)");
+  auto* p = parser("const a : vec2<i32> = vec2<i32>(1, 2)");
   p->global_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:38: missing ';' for constant declaration");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_EntryPoint) {
-  auto p = parser("entry_point vertex = main;");
+  auto* p = parser("entry_point vertex = main;");
   p->global_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
 
   auto m = p->module();
-  ASSERT_EQ(m.entry_points().size(), 1);
+  ASSERT_EQ(m.entry_points().size(), 1u);
   EXPECT_EQ(m.entry_points()[0]->name(), "main");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_EntryPoint_Invalid) {
-  auto p = parser("entry_point main;");
+  auto* p = parser("entry_point main;");
   p->global_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:13: missing pipeline stage for entry point");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_EntryPoint_MissingSemicolon) {
-  auto p = parser("entry_point vertex = main");
+  auto* p = parser("entry_point vertex = main");
   p->global_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:26: missing ';' for entry point");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_TypeAlias) {
-  auto p = parser("type A = i32;");
+  auto* p = parser("type A = i32;");
   p->global_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
 
   auto m = p->module();
-  ASSERT_EQ(m.alias_types().size(), 1);
+  ASSERT_EQ(m.alias_types().size(), 1u);
   EXPECT_EQ(m.alias_types()[0]->name(), "A");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_TypeAlias_Invalid) {
-  auto p = parser("type A = invalid;");
+  auto* p = parser("type A = invalid;");
   p->global_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:10: unknown type alias 'invalid'");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_TypeAlias_MissingSemicolon) {
-  auto p = parser("type A = i32");
+  auto* p = parser("type A = i32");
   p->global_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:13: missing ';' for type alias");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_Function) {
-  auto p = parser("fn main() -> void { return; }");
+  auto* p = parser("fn main() -> void { return; }");
   p->global_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
 
   auto m = p->module();
-  ASSERT_EQ(m.functions().size(), 1);
+  ASSERT_EQ(m.functions().size(), 1u);
   EXPECT_EQ(m.functions()[0]->name(), "main");
 }
 
 TEST_F(ParserImplTest, GlobalDecl_Function_Invalid) {
-  auto p = parser("fn main() -> { return; }");
+  auto* p = parser("fn main() -> { return; }");
   p->global_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:14: unable to determine function return type");
diff --git a/src/reader/wgsl/parser_impl_global_variable_decl_test.cc b/src/reader/wgsl/parser_impl_global_variable_decl_test.cc
index d7ff3c6..fa1aad6 100644
--- a/src/reader/wgsl/parser_impl_global_variable_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_global_variable_decl_test.cc
@@ -24,7 +24,7 @@
 namespace {
 
 TEST_F(ParserImplTest, GlobalVariableDecl_WithoutConstructor) {
-  auto p = parser("var<out> a : f32");
+  auto* p = parser("var<out> a : f32");
   auto e = p->global_variable_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -38,7 +38,7 @@
 }
 
 TEST_F(ParserImplTest, GlobalVariableDecl_WithConstructor) {
-  auto p = parser("var<out> a : f32 = 1.");
+  auto* p = parser("var<out> a : f32 = 1.");
   auto e = p->global_variable_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -55,7 +55,7 @@
 }
 
 TEST_F(ParserImplTest, GlobalVariableDecl_WithDecoration) {
-  auto p = parser("[[binding 2, set 1]] var<out> a : f32");
+  auto* p = parser("[[binding 2, set 1]] var<out> a : f32");
   auto e = p->global_variable_decl();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -69,16 +69,16 @@
   ASSERT_EQ(e->constructor(), nullptr);
 
   ASSERT_TRUE(e->IsDecorated());
-  auto v = e->AsDecorated();
+  auto* v = e->AsDecorated();
 
   auto& decos = v->decorations();
-  ASSERT_EQ(decos.size(), 2);
+  ASSERT_EQ(decos.size(), 2u);
   ASSERT_TRUE(decos[0]->IsBinding());
   ASSERT_TRUE(decos[1]->IsSet());
 }
 
 TEST_F(ParserImplTest, GlobalVariableDecl_InvalidDecoration) {
-  auto p = parser("[[binding]] var<out> a : f32");
+  auto* p = parser("[[binding]] var<out> a : f32");
   auto e = p->global_variable_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -86,7 +86,7 @@
 }
 
 TEST_F(ParserImplTest, GlobalVariableDecl_InvalidConstExpr) {
-  auto p = parser("var<out> a : f32 = if (a) {}");
+  auto* p = parser("var<out> a : f32 = if (a) {}");
   auto e = p->global_variable_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -94,7 +94,7 @@
 }
 
 TEST_F(ParserImplTest, GlobalVariableDecl_InvalidVariableDecl) {
-  auto p = parser("var<invalid> a : f32;");
+  auto* p = parser("var<invalid> a : f32;");
   auto e = p->global_variable_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_if_stmt_test.cc b/src/reader/wgsl/parser_impl_if_stmt_test.cc
index 56bd415..71173ad 100644
--- a/src/reader/wgsl/parser_impl_if_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_if_stmt_test.cc
@@ -24,7 +24,7 @@
 namespace {
 
 TEST_F(ParserImplTest, IfStmt) {
-  auto p = parser("if (a == 4) { a = b; c = d; }");
+  auto* p = parser("if (a == 4) { a = b; c = d; }");
   auto e = p->if_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -32,12 +32,13 @@
   ASSERT_TRUE(e->IsIf());
   ASSERT_NE(e->condition(), nullptr);
   ASSERT_TRUE(e->condition()->IsBinary());
-  EXPECT_EQ(e->body().size(), 2);
-  EXPECT_EQ(e->else_statements().size(), 0);
+  EXPECT_EQ(e->body().size(), 2u);
+  EXPECT_EQ(e->else_statements().size(), 0u);
 }
 
 TEST_F(ParserImplTest, IfStmt_WithElse) {
-  auto p = parser("if (a == 4) { a = b; c = d; } elseif(c) { d = 2; } else {}");
+  auto* p =
+      parser("if (a == 4) { a = b; c = d; } elseif(c) { d = 2; } else {}");
   auto e = p->if_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -45,19 +46,19 @@
   ASSERT_TRUE(e->IsIf());
   ASSERT_NE(e->condition(), nullptr);
   ASSERT_TRUE(e->condition()->IsBinary());
-  EXPECT_EQ(e->body().size(), 2);
+  EXPECT_EQ(e->body().size(), 2u);
 
-  ASSERT_EQ(e->else_statements().size(), 2);
+  ASSERT_EQ(e->else_statements().size(), 2u);
   ASSERT_NE(e->else_statements()[0]->condition(), nullptr);
   ASSERT_TRUE(e->else_statements()[0]->condition()->IsIdentifier());
-  EXPECT_EQ(e->else_statements()[0]->body().size(), 1);
+  EXPECT_EQ(e->else_statements()[0]->body().size(), 1u);
 
   ASSERT_EQ(e->else_statements()[1]->condition(), nullptr);
-  EXPECT_EQ(e->else_statements()[1]->body().size(), 0);
+  EXPECT_EQ(e->else_statements()[1]->body().size(), 0u);
 }
 
 TEST_F(ParserImplTest, IfStmt_InvalidCondition) {
-  auto p = parser("if (a = 3) {}");
+  auto* p = parser("if (a = 3) {}");
   auto e = p->if_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -65,7 +66,7 @@
 }
 
 TEST_F(ParserImplTest, IfStmt_MissingCondition) {
-  auto p = parser("if {}");
+  auto* p = parser("if {}");
   auto e = p->if_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -73,7 +74,7 @@
 }
 
 TEST_F(ParserImplTest, IfStmt_InvalidBody) {
-  auto p = parser("if (a) { fn main() -> void {}}");
+  auto* p = parser("if (a) { fn main() -> void {}}");
   auto e = p->if_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -81,7 +82,7 @@
 }
 
 TEST_F(ParserImplTest, IfStmt_MissingBody) {
-  auto p = parser("if (a)");
+  auto* p = parser("if (a)");
   auto e = p->if_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -89,7 +90,7 @@
 }
 
 TEST_F(ParserImplTest, IfStmt_InvalidElseif) {
-  auto p = parser("if (a) {} elseif (a) { fn main() -> a{}}");
+  auto* p = parser("if (a) {} elseif (a) { fn main() -> a{}}");
   auto e = p->if_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -97,7 +98,7 @@
 }
 
 TEST_F(ParserImplTest, IfStmt_InvalidElse) {
-  auto p = parser("if (a) {} else { fn main() -> a{}}");
+  auto* p = parser("if (a) {} else { fn main() -> a{}}");
   auto e = p->if_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_import_decl_test.cc b/src/reader/wgsl/parser_impl_import_decl_test.cc
index 5fc4f04..abf4582 100644
--- a/src/reader/wgsl/parser_impl_import_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_import_decl_test.cc
@@ -22,7 +22,7 @@
 namespace {
 
 TEST_F(ParserImplTest, ImportDecl_Import) {
-  auto p = parser(R"(import "GLSL.std.450" as glsl)");
+  auto* p = parser(R"(import "GLSL.std.450" as glsl)");
 
   auto import = p->import_decl();
   ASSERT_NE(import, nullptr);
@@ -30,12 +30,12 @@
 
   EXPECT_EQ("GLSL.std.450", import->path());
   EXPECT_EQ("glsl", import->name());
-  EXPECT_EQ(1, import->line());
-  EXPECT_EQ(1, import->column());
+  EXPECT_EQ(1u, import->line());
+  EXPECT_EQ(1u, import->column());
 }
 
 TEST_F(ParserImplTest, ImportDecl_Import_WithNamespace) {
-  auto p = parser(R"(import "GLSL.std.450" as std::glsl)");
+  auto* p = parser(R"(import "GLSL.std.450" as std::glsl)");
   auto import = p->import_decl();
   ASSERT_NE(import, nullptr);
   ASSERT_FALSE(p->has_error()) << p->error();
@@ -43,7 +43,7 @@
 }
 
 TEST_F(ParserImplTest, ImportDecl_Invalid_MissingPath) {
-  auto p = parser(R"(import as glsl)");
+  auto* p = parser(R"(import as glsl)");
   auto import = p->import_decl();
   ASSERT_EQ(import, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -51,7 +51,7 @@
 }
 
 TEST_F(ParserImplTest, ImportDecl_Invalid_EmptyPath) {
-  auto p = parser(R"(import "" as glsl)");
+  auto* p = parser(R"(import "" as glsl)");
   auto import = p->import_decl();
   ASSERT_EQ(import, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -59,7 +59,7 @@
 }
 
 TEST_F(ParserImplTest, ImportDecl_Invalid_NameMissingTerminatingIdentifier) {
-  auto p = parser(R"(import "GLSL.std.450" as glsl::)");
+  auto* p = parser(R"(import "GLSL.std.450" as glsl::)");
   auto import = p->import_decl();
   ASSERT_EQ(import, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -67,7 +67,7 @@
 }
 
 TEST_F(ParserImplTest, ImportDecl_Invalid_NameInvalid) {
-  auto p = parser(R"(import "GLSL.std.450" as 12glsl)");
+  auto* p = parser(R"(import "GLSL.std.450" as 12glsl)");
   auto import = p->import_decl();
   ASSERT_EQ(import, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -75,7 +75,7 @@
 }
 
 TEST_F(ParserImplTest, ImportDecl_Invalid_MissingName) {
-  auto p = parser(R"(import "GLSL.std.450" as)");
+  auto* p = parser(R"(import "GLSL.std.450" as)");
   auto import = p->import_decl();
   ASSERT_EQ(import, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -83,7 +83,7 @@
 }
 
 TEST_F(ParserImplTest, ImportDecl_Invalid_MissingAs) {
-  auto p = parser(R"(import "GLSL.std.450" glsl)");
+  auto* p = parser(R"(import "GLSL.std.450" glsl)");
   auto import = p->import_decl();
   ASSERT_EQ(import, nullptr);
   ASSERT_TRUE(p->has_error());
diff --git a/src/reader/wgsl/parser_impl_inclusive_or_expression_test.cc b/src/reader/wgsl/parser_impl_inclusive_or_expression_test.cc
index bbbe778..3311e74 100644
--- a/src/reader/wgsl/parser_impl_inclusive_or_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_inclusive_or_expression_test.cc
@@ -26,36 +26,36 @@
 namespace {
 
 TEST_F(ParserImplTest, InclusiveOrExpression_Parses) {
-  auto p = parser("a | true");
+  auto* p = parser("a | true");
   auto e = p->inclusive_or_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kOr, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, InclusiveOrExpression_InvalidLHS) {
-  auto p = parser("if (a) {} | true");
+  auto* p = parser("if (a) {} | true");
   auto e = p->inclusive_or_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, InclusiveOrExpression_InvalidRHS) {
-  auto p = parser("true | if (a) {}");
+  auto* p = parser("true | if (a) {}");
   auto e = p->inclusive_or_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -63,7 +63,7 @@
 }
 
 TEST_F(ParserImplTest, InclusiveOrExpression_NoOr_ReturnsLHS) {
-  auto p = parser("a true");
+  auto* p = parser("a true");
   auto e = p->inclusive_or_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_logical_and_expression_test.cc b/src/reader/wgsl/parser_impl_logical_and_expression_test.cc
index 9c7029e..6434e0a 100644
--- a/src/reader/wgsl/parser_impl_logical_and_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_logical_and_expression_test.cc
@@ -26,36 +26,36 @@
 namespace {
 
 TEST_F(ParserImplTest, LogicalAndExpression_Parses) {
-  auto p = parser("a && true");
+  auto* p = parser("a && true");
   auto e = p->logical_and_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kLogicalAnd, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, LogicalAndExpression_InvalidLHS) {
-  auto p = parser("if (a) {} && true");
+  auto* p = parser("if (a) {} && true");
   auto e = p->logical_and_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, LogicalAndExpression_InvalidRHS) {
-  auto p = parser("true && if (a) {}");
+  auto* p = parser("true && if (a) {}");
   auto e = p->logical_and_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -63,7 +63,7 @@
 }
 
 TEST_F(ParserImplTest, LogicalAndExpression_NoOr_ReturnsLHS) {
-  auto p = parser("a true");
+  auto* p = parser("a true");
   auto e = p->logical_and_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_logical_or_expression_test.cc b/src/reader/wgsl/parser_impl_logical_or_expression_test.cc
index bc19f61..63e1c64 100644
--- a/src/reader/wgsl/parser_impl_logical_or_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_logical_or_expression_test.cc
@@ -26,36 +26,36 @@
 namespace {
 
 TEST_F(ParserImplTest, LogicalOrExpression_Parses) {
-  auto p = parser("a || true");
+  auto* p = parser("a || true");
   auto e = p->logical_or_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kLogicalOr, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, LogicalOrExpression_InvalidLHS) {
-  auto p = parser("if (a) {} || true");
+  auto* p = parser("if (a) {} || true");
   auto e = p->logical_or_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, LogicalOrExpression_InvalidRHS) {
-  auto p = parser("true || if (a) {}");
+  auto* p = parser("true || if (a) {}");
   auto e = p->logical_or_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -63,7 +63,7 @@
 }
 
 TEST_F(ParserImplTest, LogicalOrExpression_NoOr_ReturnsLHS) {
-  auto p = parser("a true");
+  auto* p = parser("a true");
   auto e = p->logical_or_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_loop_stmt_test.cc b/src/reader/wgsl/parser_impl_loop_stmt_test.cc
index 434ace5..ea7a245 100644
--- a/src/reader/wgsl/parser_impl_loop_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_loop_stmt_test.cc
@@ -22,51 +22,51 @@
 namespace {
 
 TEST_F(ParserImplTest, LoopStmt_BodyNoContinuing) {
-  auto p = parser("loop { nop; }");
+  auto* p = parser("loop { nop; }");
   auto e = p->loop_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
-  ASSERT_EQ(e->body().size(), 1);
+  ASSERT_EQ(e->body().size(), 1u);
   EXPECT_TRUE(e->body()[0]->IsNop());
 
-  EXPECT_EQ(e->continuing().size(), 0);
+  EXPECT_EQ(e->continuing().size(), 0u);
 }
 
 TEST_F(ParserImplTest, LoopStmt_BodyWithContinuing) {
-  auto p = parser("loop { nop; continuing { kill; }}");
+  auto* p = parser("loop { nop; continuing { kill; }}");
   auto e = p->loop_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
-  ASSERT_EQ(e->body().size(), 1);
+  ASSERT_EQ(e->body().size(), 1u);
   EXPECT_TRUE(e->body()[0]->IsNop());
 
-  EXPECT_EQ(e->continuing().size(), 1);
+  EXPECT_EQ(e->continuing().size(), 1u);
   EXPECT_TRUE(e->continuing()[0]->IsKill());
 }
 
 TEST_F(ParserImplTest, LoopStmt_NoBodyNoContinuing) {
-  auto p = parser("loop { }");
+  auto* p = parser("loop { }");
   auto e = p->loop_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
-  ASSERT_EQ(e->body().size(), 0);
-  ASSERT_EQ(e->continuing().size(), 0);
+  ASSERT_EQ(e->body().size(), 0u);
+  ASSERT_EQ(e->continuing().size(), 0u);
 }
 
 TEST_F(ParserImplTest, LoopStmt_NoBodyWithContinuing) {
-  auto p = parser("loop { continuing { kill; }}");
+  auto* p = parser("loop { continuing { kill; }}");
   auto e = p->loop_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
-  ASSERT_EQ(e->body().size(), 0);
-  ASSERT_EQ(e->continuing().size(), 1);
+  ASSERT_EQ(e->body().size(), 0u);
+  ASSERT_EQ(e->continuing().size(), 1u);
   EXPECT_TRUE(e->continuing()[0]->IsKill());
 }
 
 TEST_F(ParserImplTest, LoopStmt_MissingBracketLeft) {
-  auto p = parser("loop kill; }");
+  auto* p = parser("loop kill; }");
   auto e = p->loop_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -74,7 +74,7 @@
 }
 
 TEST_F(ParserImplTest, LoopStmt_MissingBracketRight) {
-  auto p = parser("loop { kill; ");
+  auto* p = parser("loop { kill; ");
   auto e = p->loop_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -82,7 +82,7 @@
 }
 
 TEST_F(ParserImplTest, LoopStmt_InvalidStatements) {
-  auto p = parser("loop { kill }");
+  auto* p = parser("loop { kill }");
   auto e = p->loop_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -90,7 +90,7 @@
 }
 
 TEST_F(ParserImplTest, LoopStmt_InvalidContinuing) {
-  auto p = parser("loop { continuing { kill }}");
+  auto* p = parser("loop { continuing { kill }}");
   auto e = p->loop_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_multiplicative_expression_test.cc b/src/reader/wgsl/parser_impl_multiplicative_expression_test.cc
index cba8fc1..22a9dfc 100644
--- a/src/reader/wgsl/parser_impl_multiplicative_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_multiplicative_expression_test.cc
@@ -26,80 +26,80 @@
 namespace {
 
 TEST_F(ParserImplTest, MultiplicativeExpression_Parses_Multiply) {
-  auto p = parser("a * true");
+  auto* p = parser("a * true");
   auto e = p->multiplicative_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kMultiply, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, MultiplicativeExpression_Parses_Divide) {
-  auto p = parser("a / true");
+  auto* p = parser("a / true");
   auto e = p->multiplicative_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kDivide, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, MultiplicativeExpression_Parses_Modulo) {
-  auto p = parser("a % true");
+  auto* p = parser("a % true");
   auto e = p->multiplicative_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kModulo, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, MultiplicativeExpression_InvalidLHS) {
-  auto p = parser("if (a) {} * true");
+  auto* p = parser("if (a) {} * true");
   auto e = p->multiplicative_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, MultiplicativeExpression_InvalidRHS) {
-  auto p = parser("true * if (a) {}");
+  auto* p = parser("true * if (a) {}");
   auto e = p->multiplicative_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -107,7 +107,7 @@
 }
 
 TEST_F(ParserImplTest, MultiplicativeExpression_NoOr_ReturnsLHS) {
-  auto p = parser("a true");
+  auto* p = parser("a true");
   auto e = p->multiplicative_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_param_list_test.cc b/src/reader/wgsl/parser_impl_param_list_test.cc
index f337f65..ca8c38e 100644
--- a/src/reader/wgsl/parser_impl_param_list_test.cc
+++ b/src/reader/wgsl/parser_impl_param_list_test.cc
@@ -29,26 +29,26 @@
 namespace {
 
 TEST_F(ParserImplTest, ParamList_Single) {
-  auto i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
+  auto* i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
 
-  auto p = parser("a : i32");
+  auto* p = parser("a : i32");
   auto e = p->param_list();
   ASSERT_FALSE(p->has_error()) << p->error();
-  EXPECT_EQ(e.size(), 1);
+  EXPECT_EQ(e.size(), 1u);
 
   EXPECT_EQ(e[0]->name(), "a");
   EXPECT_EQ(e[0]->type(), i32);
 }
 
 TEST_F(ParserImplTest, ParamList_Multiple) {
-  auto i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
-  auto f32 = tm()->Get(std::make_unique<ast::type::F32Type>());
-  auto vec2 = tm()->Get(std::make_unique<ast::type::VectorType>(f32, 2));
+  auto* i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
+  auto* f32 = tm()->Get(std::make_unique<ast::type::F32Type>());
+  auto* vec2 = tm()->Get(std::make_unique<ast::type::VectorType>(f32, 2));
 
-  auto p = parser("a : i32, b: f32, c: vec2<f32>");
+  auto* p = parser("a : i32, b: f32, c: vec2<f32>");
   auto e = p->param_list();
   ASSERT_FALSE(p->has_error()) << p->error();
-  EXPECT_EQ(e.size(), 3);
+  EXPECT_EQ(e.size(), 3u);
 
   EXPECT_EQ(e[0]->name(), "a");
   EXPECT_EQ(e[0]->type(), i32);
@@ -61,14 +61,14 @@
 }
 
 TEST_F(ParserImplTest, ParamList_Empty) {
-  auto p = parser("");
+  auto* p = parser("");
   auto e = p->param_list();
   ASSERT_FALSE(p->has_error()) << p->error();
-  EXPECT_EQ(e.size(), 0);
+  EXPECT_EQ(e.size(), 0u);
 }
 
 TEST_F(ParserImplTest, ParamList_HangingComma) {
-  auto p = parser("a : i32,");
+  auto* p = parser("a : i32,");
   auto e = p->param_list();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:8: found , but no variable declaration");
diff --git a/src/reader/wgsl/parser_impl_paren_rhs_stmt_test.cc b/src/reader/wgsl/parser_impl_paren_rhs_stmt_test.cc
index fde1394..0610446 100644
--- a/src/reader/wgsl/parser_impl_paren_rhs_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_paren_rhs_stmt_test.cc
@@ -22,7 +22,7 @@
 namespace {
 
 TEST_F(ParserImplTest, ParenRhsStmt) {
-  auto p = parser("(a + b)");
+  auto* p = parser("(a + b)");
   auto e = p->paren_rhs_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -30,7 +30,7 @@
 }
 
 TEST_F(ParserImplTest, ParenRhsStmt_MissingLeftParen) {
-  auto p = parser("true)");
+  auto* p = parser("true)");
   auto e = p->paren_rhs_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -38,7 +38,7 @@
 }
 
 TEST_F(ParserImplTest, ParenRhsStmt_MissingRightParen) {
-  auto p = parser("(true");
+  auto* p = parser("(true");
   auto e = p->paren_rhs_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -46,7 +46,7 @@
 }
 
 TEST_F(ParserImplTest, ParenRhsStmt_InvalidExpression) {
-  auto p = parser("(if (a() {})");
+  auto* p = parser("(if (a() {})");
   auto e = p->paren_rhs_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -54,7 +54,7 @@
 }
 
 TEST_F(ParserImplTest, ParenRhsStmt_MissingExpression) {
-  auto p = parser("()");
+  auto* p = parser("()");
   auto e = p->paren_rhs_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_pipeline_stage_test.cc b/src/reader/wgsl/parser_impl_pipeline_stage_test.cc
index b566534..19bac5c 100644
--- a/src/reader/wgsl/parser_impl_pipeline_stage_test.cc
+++ b/src/reader/wgsl/parser_impl_pipeline_stage_test.cc
@@ -36,9 +36,9 @@
   PipelineStageTest() = default;
   ~PipelineStageTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -52,7 +52,7 @@
 
 TEST_P(PipelineStageTest, Parses) {
   auto params = GetParam();
-  auto p = parser(params.input);
+  auto* p = parser(params.input);
 
   auto stage = p->pipeline_stage();
   ASSERT_FALSE(p->has_error());
@@ -70,7 +70,7 @@
         PipelineStageData{"compute", ast::PipelineStage::kCompute}));
 
 TEST_F(ParserImplTest, PipelineStage_NoMatch) {
-  auto p = parser("not-a-stage");
+  auto* p = parser("not-a-stage");
   auto stage = p->pipeline_stage();
   ASSERT_EQ(stage, ast::PipelineStage::kNone);
 
diff --git a/src/reader/wgsl/parser_impl_postfix_expression_test.cc b/src/reader/wgsl/parser_impl_postfix_expression_test.cc
index 66380cb..5b7be35 100644
--- a/src/reader/wgsl/parser_impl_postfix_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_postfix_expression_test.cc
@@ -31,45 +31,45 @@
 namespace {
 
 TEST_F(ParserImplTest, PostfixExpression_Array_ConstantIndex) {
-  auto p = parser("a[1]");
+  auto* p = parser("a[1]");
   auto e = p->postfix_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsArrayAccessor());
-  auto ary = e->AsArrayAccessor();
+  auto* ary = e->AsArrayAccessor();
 
   ASSERT_TRUE(ary->array()->IsIdentifier());
-  auto ident = ary->array()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = ary->array()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(ary->idx_expr()->IsConstructor());
   ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
-  auto c = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+  auto* c = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(c->literal()->IsInt());
   EXPECT_EQ(c->literal()->AsInt()->value(), 1);
 }
 
 TEST_F(ParserImplTest, PostfixExpression_Array_ExpressionIndex) {
-  auto p = parser("a[1 + b / 4]");
+  auto* p = parser("a[1 + b / 4]");
   auto e = p->postfix_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsArrayAccessor());
-  auto ary = e->AsArrayAccessor();
+  auto* ary = e->AsArrayAccessor();
 
   ASSERT_TRUE(ary->array()->IsIdentifier());
-  auto ident = ary->array()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = ary->array()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(ary->idx_expr()->IsBinary());
 }
 
 TEST_F(ParserImplTest, PostfixExpression_Array_MissingIndex) {
-  auto p = parser("a[]");
+  auto* p = parser("a[]");
   auto e = p->postfix_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -77,7 +77,7 @@
 }
 
 TEST_F(ParserImplTest, PostfixExpression_Array_MissingRightBrace) {
-  auto p = parser("a[1");
+  auto* p = parser("a[1");
   auto e = p->postfix_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -85,7 +85,7 @@
 }
 
 TEST_F(ParserImplTest, PostfixExpression_Array_InvalidIndex) {
-  auto p = parser("a[if(a() {})]");
+  auto* p = parser("a[if(a() {})]");
   auto e = p->postfix_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -93,45 +93,45 @@
 }
 
 TEST_F(ParserImplTest, PostfixExpression_Call_Empty) {
-  auto p = parser("a()");
+  auto* p = parser("a()");
   auto e = p->postfix_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsCall());
-  auto c = e->AsCall();
+  auto* c = e->AsCall();
 
   ASSERT_TRUE(c->func()->IsIdentifier());
-  auto func = c->func()->AsIdentifier();
-  ASSERT_EQ(func->name().size(), 1);
+  auto* func = c->func()->AsIdentifier();
+  ASSERT_EQ(func->name().size(), 1u);
   EXPECT_EQ(func->name()[0], "a");
 
-  EXPECT_EQ(c->params().size(), 0);
+  EXPECT_EQ(c->params().size(), 0u);
 }
 
 TEST_F(ParserImplTest, PostfixExpression_Call_WithArgs) {
-  auto p = parser("std::test(1, b, 2 + 3 / b)");
+  auto* p = parser("std::test(1, b, 2 + 3 / b)");
   auto e = p->postfix_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsCall());
-  auto c = e->AsCall();
+  auto* c = e->AsCall();
 
   ASSERT_TRUE(c->func()->IsIdentifier());
-  auto func = c->func()->AsIdentifier();
-  ASSERT_EQ(func->name().size(), 2);
+  auto* func = c->func()->AsIdentifier();
+  ASSERT_EQ(func->name().size(), 2u);
   EXPECT_EQ(func->name()[0], "std");
   EXPECT_EQ(func->name()[1], "test");
 
-  EXPECT_EQ(c->params().size(), 3);
+  EXPECT_EQ(c->params().size(), 3u);
   EXPECT_TRUE(c->params()[0]->IsConstructor());
   EXPECT_TRUE(c->params()[1]->IsIdentifier());
   EXPECT_TRUE(c->params()[2]->IsBinary());
 }
 
 TEST_F(ParserImplTest, PostfixExpression_Call_InvalidArg) {
-  auto p = parser("a(if(a) {})");
+  auto* p = parser("a(if(a) {})");
   auto e = p->postfix_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -139,7 +139,7 @@
 }
 
 TEST_F(ParserImplTest, PostfixExpression_Call_HangingComma) {
-  auto p = parser("a(b, )");
+  auto* p = parser("a(b, )");
   auto e = p->postfix_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -147,7 +147,7 @@
 }
 
 TEST_F(ParserImplTest, PostfixExpression_Call_MissingRightParen) {
-  auto p = parser("a(");
+  auto* p = parser("a(");
   auto e = p->postfix_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -155,24 +155,24 @@
 }
 
 TEST_F(ParserImplTest, PostfixExpression_MemberAccessor) {
-  auto p = parser("a.b");
+  auto* p = parser("a.b");
   auto e = p->postfix_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsMemberAccessor());
 
-  auto m = e->AsMemberAccessor();
+  auto* m = e->AsMemberAccessor();
   ASSERT_TRUE(m->structure()->IsIdentifier());
-  ASSERT_EQ(m->structure()->AsIdentifier()->name().size(), 1);
+  ASSERT_EQ(m->structure()->AsIdentifier()->name().size(), 1u);
   EXPECT_EQ(m->structure()->AsIdentifier()->name()[0], "a");
 
   ASSERT_TRUE(m->member()->IsIdentifier());
-  ASSERT_EQ(m->member()->AsIdentifier()->name().size(), 1);
+  ASSERT_EQ(m->member()->AsIdentifier()->name().size(), 1u);
   EXPECT_EQ(m->member()->AsIdentifier()->name()[0], "b");
 }
 
 TEST_F(ParserImplTest, PostfixExpression_MemberAccesssor_InvalidIdent) {
-  auto p = parser("a.if");
+  auto* p = parser("a.if");
   auto e = p->postfix_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -180,7 +180,7 @@
 }
 
 TEST_F(ParserImplTest, PostfixExpression_MemberAccessor_MissingIdent) {
-  auto p = parser("a.");
+  auto* p = parser("a.");
   auto e = p->postfix_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -188,7 +188,7 @@
 }
 
 TEST_F(ParserImplTest, PostfixExpression_NonMatch_returnLHS) {
-  auto p = parser("a b");
+  auto* p = parser("a b");
   auto e = p->postfix_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_primary_expression_test.cc b/src/reader/wgsl/parser_impl_primary_expression_test.cc
index ae0c9c3..29f11a3 100644
--- a/src/reader/wgsl/parser_impl_primary_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_primary_expression_test.cc
@@ -36,24 +36,24 @@
 namespace {
 
 TEST_F(ParserImplTest, PrimaryExpression_Ident) {
-  auto p = parser("a");
+  auto* p = parser("a");
   auto e = p->primary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsIdentifier());
-  auto ident = e->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = e->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_Ident_WithNamespace) {
-  auto p = parser("a::b::c::d");
+  auto* p = parser("a::b::c::d");
   auto e = p->primary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsIdentifier());
-  auto ident = e->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 4);
+  auto* ident = e->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 4u);
   EXPECT_EQ(ident->name()[0], "a");
   EXPECT_EQ(ident->name()[1], "b");
   EXPECT_EQ(ident->name()[2], "c");
@@ -61,7 +61,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_Ident_MissingIdent) {
-  auto p = parser("a::");
+  auto* p = parser("a::");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -69,19 +69,19 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_TypeDecl) {
-  auto p = parser("vec4<i32>(1, 2, 3, 4))");
+  auto* p = parser("vec4<i32>(1, 2, 3, 4))");
   auto e = p->primary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsConstructor());
   ASSERT_TRUE(e->AsConstructor()->IsTypeConstructor());
-  auto ty = e->AsConstructor()->AsTypeConstructor();
+  auto* ty = e->AsConstructor()->AsTypeConstructor();
 
-  ASSERT_EQ(ty->values().size(), 4);
+  ASSERT_EQ(ty->values().size(), 4u);
   const auto& val = ty->values();
   ASSERT_TRUE(val[0]->IsConstructor());
   ASSERT_TRUE(val[0]->AsConstructor()->IsScalarConstructor());
-  auto ident = val[0]->AsConstructor()->AsScalarConstructor();
+  auto* ident = val[0]->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(ident->literal()->IsInt());
   EXPECT_EQ(ident->literal()->AsInt()->value(), 1);
 
@@ -105,7 +105,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_TypeDecl_InvalidTypeDecl) {
-  auto p = parser("vec4<if>(2., 3., 4., 5.)");
+  auto* p = parser("vec4<if>(2., 3., 4., 5.)");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -113,7 +113,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_TypeDecl_MissingLeftParen) {
-  auto p = parser("vec4<f32> 2., 3., 4., 5.)");
+  auto* p = parser("vec4<f32> 2., 3., 4., 5.)");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -121,7 +121,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_TypeDecl_MissingRightParen) {
-  auto p = parser("vec4<f32>(2., 3., 4., 5.");
+  auto* p = parser("vec4<f32>(2., 3., 4., 5.");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -129,7 +129,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_TypeDecl_InvalidValue) {
-  auto p = parser("i32(if(a) {})");
+  auto* p = parser("i32(if(a) {})");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -137,19 +137,19 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_ConstLiteral_True) {
-  auto p = parser("true");
+  auto* p = parser("true");
   auto e = p->primary_expression();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsConstructor());
   ASSERT_TRUE(e->AsConstructor()->IsScalarConstructor());
-  auto init = e->AsConstructor()->AsScalarConstructor();
+  auto* init = e->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   EXPECT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_ParenExpr) {
-  auto p = parser("(a == b)");
+  auto* p = parser("(a == b)");
   auto e = p->primary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -157,7 +157,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_ParenExpr_MissingRightParen) {
-  auto p = parser("(a == b");
+  auto* p = parser("(a == b");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -165,7 +165,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_ParenExpr_MissingExpr) {
-  auto p = parser("()");
+  auto* p = parser("()");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -173,7 +173,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_ParenExpr_InvalidExpr) {
-  auto p = parser("(if (a) {})");
+  auto* p = parser("(if (a) {})");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -181,15 +181,15 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_Cast) {
-  auto f32_type = tm()->Get(std::make_unique<ast::type::F32Type>());
+  auto* f32_type = tm()->Get(std::make_unique<ast::type::F32Type>());
 
-  auto p = parser("cast<f32>(1)");
+  auto* p = parser("cast<f32>(1)");
   auto e = p->primary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsCast());
 
-  auto c = e->AsCast();
+  auto* c = e->AsCast();
   ASSERT_EQ(c->type(), f32_type);
 
   ASSERT_TRUE(c->expr()->IsConstructor());
@@ -197,7 +197,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_Cast_MissingGreaterThan) {
-  auto p = parser("cast<f32(1)");
+  auto* p = parser("cast<f32(1)");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -205,7 +205,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_Cast_MissingType) {
-  auto p = parser("cast<>(1)");
+  auto* p = parser("cast<>(1)");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -213,7 +213,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_Cast_InvalidType) {
-  auto p = parser("cast<invalid>(1)");
+  auto* p = parser("cast<invalid>(1)");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -221,7 +221,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_Cast_MissingLeftParen) {
-  auto p = parser("cast<f32>1)");
+  auto* p = parser("cast<f32>1)");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -229,7 +229,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_Cast_MissingRightParen) {
-  auto p = parser("cast<f32>(1");
+  auto* p = parser("cast<f32>(1");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -237,7 +237,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_Cast_MissingExpression) {
-  auto p = parser("cast<f32>()");
+  auto* p = parser("cast<f32>()");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -245,7 +245,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_Cast_InvalidExpression) {
-  auto p = parser("cast<f32>(if (a) {})");
+  auto* p = parser("cast<f32>(if (a) {})");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -253,15 +253,15 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_As) {
-  auto f32_type = tm()->Get(std::make_unique<ast::type::F32Type>());
+  auto* f32_type = tm()->Get(std::make_unique<ast::type::F32Type>());
 
-  auto p = parser("as<f32>(1)");
+  auto* p = parser("as<f32>(1)");
   auto e = p->primary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsAs());
 
-  auto c = e->AsAs();
+  auto* c = e->AsAs();
   ASSERT_EQ(c->type(), f32_type);
 
   ASSERT_TRUE(c->expr()->IsConstructor());
@@ -269,7 +269,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_As_MissingGreaterThan) {
-  auto p = parser("as<f32(1)");
+  auto* p = parser("as<f32(1)");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -277,7 +277,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_As_MissingType) {
-  auto p = parser("as<>(1)");
+  auto* p = parser("as<>(1)");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -285,7 +285,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_As_InvalidType) {
-  auto p = parser("as<invalid>(1)");
+  auto* p = parser("as<invalid>(1)");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -293,7 +293,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_As_MissingLeftParen) {
-  auto p = parser("as<f32>1)");
+  auto* p = parser("as<f32>1)");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -301,7 +301,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_As_MissingRightParen) {
-  auto p = parser("as<f32>(1");
+  auto* p = parser("as<f32>(1");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -309,7 +309,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_As_MissingExpression) {
-  auto p = parser("as<f32>()");
+  auto* p = parser("as<f32>()");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -317,7 +317,7 @@
 }
 
 TEST_F(ParserImplTest, PrimaryExpression_As_InvalidExpression) {
-  auto p = parser("as<f32>(if (a) {})");
+  auto* p = parser("as<f32>(if (a) {})");
   auto e = p->primary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_relational_expression_test.cc b/src/reader/wgsl/parser_impl_relational_expression_test.cc
index 1b4ab29..1151977 100644
--- a/src/reader/wgsl/parser_impl_relational_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_relational_expression_test.cc
@@ -26,102 +26,102 @@
 namespace {
 
 TEST_F(ParserImplTest, RelationalExpression_Parses_LessThan) {
-  auto p = parser("a < true");
+  auto* p = parser("a < true");
   auto e = p->relational_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kLessThan, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, RelationalExpression_Parses_GreaterThan) {
-  auto p = parser("a > true");
+  auto* p = parser("a > true");
   auto e = p->relational_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kGreaterThan, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, RelationalExpression_Parses_LessThanEqual) {
-  auto p = parser("a <= true");
+  auto* p = parser("a <= true");
   auto e = p->relational_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kLessThanEqual, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, RelationalExpression_Parses_GreaterThanEqual) {
-  auto p = parser("a >= true");
+  auto* p = parser("a >= true");
   auto e = p->relational_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kGreaterThanEqual, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, RelationalExpression_InvalidLHS) {
-  auto p = parser("if (a) {} < true");
+  auto* p = parser("if (a) {} < true");
   auto e = p->relational_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, RelationalExpression_InvalidRHS) {
-  auto p = parser("true < if (a) {}");
+  auto* p = parser("true < if (a) {}");
   auto e = p->relational_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -129,7 +129,7 @@
 }
 
 TEST_F(ParserImplTest, RelationalExpression_NoOr_ReturnsLHS) {
-  auto p = parser("a true");
+  auto* p = parser("a true");
   auto e = p->relational_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_shift_expression_test.cc b/src/reader/wgsl/parser_impl_shift_expression_test.cc
index 60c99ad..f6e8351 100644
--- a/src/reader/wgsl/parser_impl_shift_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_shift_expression_test.cc
@@ -26,80 +26,80 @@
 namespace {
 
 TEST_F(ParserImplTest, ShiftExpression_Parses_ShiftLeft) {
-  auto p = parser("a << true");
+  auto* p = parser("a << true");
   auto e = p->shift_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kShiftLeft, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, ShiftExpression_Parses_ShiftRight) {
-  auto p = parser("a >> true");
+  auto* p = parser("a >> true");
   auto e = p->shift_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kShiftRight, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, ShiftExpression_Parses_ShiftRightArith) {
-  auto p = parser("a >>> true");
+  auto* p = parser("a >>> true");
   auto e = p->shift_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsBinary());
-  auto rel = e->AsBinary();
+  auto* rel = e->AsBinary();
   EXPECT_EQ(ast::BinaryOp::kShiftRightArith, rel->op());
 
   ASSERT_TRUE(rel->lhs()->IsIdentifier());
-  auto ident = rel->lhs()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = rel->lhs()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(rel->rhs()->IsConstructor());
   ASSERT_TRUE(rel->rhs()->AsConstructor()->IsScalarConstructor());
-  auto init = rel->rhs()->AsConstructor()->AsScalarConstructor();
+  auto* init = rel->rhs()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsBool());
   ASSERT_TRUE(init->literal()->AsBool()->IsTrue());
 }
 
 TEST_F(ParserImplTest, ShiftExpression_InvalidLHS) {
-  auto p = parser("if (a) {} << true");
+  auto* p = parser("if (a) {} << true");
   auto e = p->shift_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, ShiftExpression_InvalidRHS) {
-  auto p = parser("true << if (a) {}");
+  auto* p = parser("true << if (a) {}");
   auto e = p->shift_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -107,7 +107,7 @@
 }
 
 TEST_F(ParserImplTest, ShiftExpression_NoOr_ReturnsLHS) {
-  auto p = parser("a true");
+  auto* p = parser("a true");
   auto e = p->shift_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_statement_test.cc b/src/reader/wgsl/parser_impl_statement_test.cc
index 29ad4f8..f123437 100644
--- a/src/reader/wgsl/parser_impl_statement_test.cc
+++ b/src/reader/wgsl/parser_impl_statement_test.cc
@@ -24,7 +24,7 @@
 namespace {
 
 TEST_F(ParserImplTest, Statement) {
-  auto p = parser("return;");
+  auto* p = parser("return;");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -32,37 +32,37 @@
 }
 
 TEST_F(ParserImplTest, Statement_Semicolon) {
-  auto p = parser(";");
+  auto* p = parser(";");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_EQ(e, nullptr);
 }
 
 TEST_F(ParserImplTest, Statement_Return_NoValue) {
-  auto p = parser("return;");
+  auto* p = parser("return;");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsReturn());
-  auto ret = e->AsReturn();
+  auto* ret = e->AsReturn();
   ASSERT_EQ(ret->value(), nullptr);
 }
 
 TEST_F(ParserImplTest, Statement_Return_Value) {
-  auto p = parser("return a + b * (.1 - .2);");
+  auto* p = parser("return a + b * (.1 - .2);");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsReturn());
-  auto ret = e->AsReturn();
+  auto* ret = e->AsReturn();
   ASSERT_NE(ret->value(), nullptr);
   EXPECT_TRUE(ret->value()->IsBinary());
 }
 
 TEST_F(ParserImplTest, Statement_Return_MissingSemi) {
-  auto p = parser("return");
+  auto* p = parser("return");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -70,7 +70,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Return_Invalid) {
-  auto p = parser("return if(a) {};");
+  auto* p = parser("return if(a) {};");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -78,7 +78,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_If) {
-  auto p = parser("if (a) {}");
+  auto* p = parser("if (a) {}");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -86,7 +86,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_If_Invalid) {
-  auto p = parser("if (a) { fn main() -> {}}");
+  auto* p = parser("if (a) { fn main() -> {}}");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -94,7 +94,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Unless) {
-  auto p = parser("unless (a) {}");
+  auto* p = parser("unless (a) {}");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -102,7 +102,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Unless_Invalid) {
-  auto p = parser("unless () {}");
+  auto* p = parser("unless () {}");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -110,7 +110,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Variable) {
-  auto p = parser("var a : i32 = 1;");
+  auto* p = parser("var a : i32 = 1;");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -118,7 +118,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Variable_Invalid) {
-  auto p = parser("var a : i32 =;");
+  auto* p = parser("var a : i32 =;");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -126,7 +126,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Variable_MissingSemicolon) {
-  auto p = parser("var a : i32");
+  auto* p = parser("var a : i32");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -134,7 +134,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Switch) {
-  auto p = parser("switch (a) {}");
+  auto* p = parser("switch (a) {}");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -142,7 +142,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Switch_Invalid) {
-  auto p = parser("switch (a) { case: {}}");
+  auto* p = parser("switch (a) { case: {}}");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -150,7 +150,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Loop) {
-  auto p = parser("loop {}");
+  auto* p = parser("loop {}");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -158,7 +158,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Loop_Invalid) {
-  auto p = parser("loop kill; }");
+  auto* p = parser("loop kill; }");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -166,7 +166,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Assignment) {
-  auto p = parser("a = b;");
+  auto* p = parser("a = b;");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -174,7 +174,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Assignment_Invalid) {
-  auto p = parser("a = if(b) {};");
+  auto* p = parser("a = if(b) {};");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -182,7 +182,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Assignment_MissingSemicolon) {
-  auto p = parser("a = b");
+  auto* p = parser("a = b");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -190,7 +190,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Break) {
-  auto p = parser("break;");
+  auto* p = parser("break;");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -198,7 +198,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Break_Invalid) {
-  auto p = parser("break if (a = b);");
+  auto* p = parser("break if (a = b);");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -206,7 +206,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Break_MissingSemicolon) {
-  auto p = parser("break if (a == b)");
+  auto* p = parser("break if (a == b)");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -214,7 +214,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Continue) {
-  auto p = parser("continue;");
+  auto* p = parser("continue;");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -222,7 +222,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Continue_Invalid) {
-  auto p = parser("continue if (a = b);");
+  auto* p = parser("continue if (a = b);");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -230,7 +230,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Continue_MissingSemicolon) {
-  auto p = parser("continue if (a == b)");
+  auto* p = parser("continue if (a == b)");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -238,7 +238,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Kill) {
-  auto p = parser("kill;");
+  auto* p = parser("kill;");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   EXPECT_NE(e, nullptr);
@@ -246,7 +246,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Kill_MissingSemicolon) {
-  auto p = parser("kill");
+  auto* p = parser("kill");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(e, nullptr);
@@ -254,7 +254,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Nop) {
-  auto p = parser("nop;");
+  auto* p = parser("nop;");
   auto e = p->statement();
   ASSERT_FALSE(p->has_error()) << p->error();
   EXPECT_NE(e, nullptr);
@@ -262,7 +262,7 @@
 }
 
 TEST_F(ParserImplTest, Statement_Nop_MissingSemicolon) {
-  auto p = parser("nop");
+  auto* p = parser("nop");
   auto e = p->statement();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_statements_test.cc b/src/reader/wgsl/parser_impl_statements_test.cc
index 8a07abc..3e6a959 100644
--- a/src/reader/wgsl/parser_impl_statements_test.cc
+++ b/src/reader/wgsl/parser_impl_statements_test.cc
@@ -23,20 +23,20 @@
 namespace {
 
 TEST_F(ParserImplTest, Statements) {
-  auto p = parser("nop; kill; return;");
+  auto* p = parser("nop; kill; return;");
   auto e = p->statements();
   ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_EQ(e.size(), 3);
+  ASSERT_EQ(e.size(), 3u);
   EXPECT_TRUE(e[0]->IsNop());
   EXPECT_TRUE(e[1]->IsKill());
   EXPECT_TRUE(e[2]->IsReturn());
 }
 
 TEST_F(ParserImplTest, Statements_Empty) {
-  auto p = parser("");
+  auto* p = parser("");
   auto e = p->statements();
   ASSERT_FALSE(p->has_error()) << p->error();
-  ASSERT_EQ(e.size(), 0);
+  ASSERT_EQ(e.size(), 0u);
 }
 
 }  // namespace
diff --git a/src/reader/wgsl/parser_impl_storage_class_test.cc b/src/reader/wgsl/parser_impl_storage_class_test.cc
index 923dd76..8a827ef 100644
--- a/src/reader/wgsl/parser_impl_storage_class_test.cc
+++ b/src/reader/wgsl/parser_impl_storage_class_test.cc
@@ -36,9 +36,9 @@
   StorageClassTest() = default;
   ~StorageClassTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -52,7 +52,7 @@
 
 TEST_P(StorageClassTest, Parses) {
   auto params = GetParam();
-  auto p = parser(params.input);
+  auto* p = parser(params.input);
 
   auto sc = p->storage_class();
   ASSERT_FALSE(p->has_error());
@@ -78,7 +78,7 @@
         StorageClassData{"function", ast::StorageClass::kFunction}));
 
 TEST_F(ParserImplTest, StorageClass_NoMatch) {
-  auto p = parser("not-a-storage-class");
+  auto* p = parser("not-a-storage-class");
   auto sc = p->storage_class();
   ASSERT_EQ(sc, ast::StorageClass::kNone);
 
diff --git a/src/reader/wgsl/parser_impl_struct_body_decl_test.cc b/src/reader/wgsl/parser_impl_struct_body_decl_test.cc
index 0bee981..ecf29a9 100644
--- a/src/reader/wgsl/parser_impl_struct_body_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_struct_body_decl_test.cc
@@ -24,28 +24,28 @@
 namespace {
 
 TEST_F(ParserImplTest, StructBodyDecl_Parses) {
-  auto i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
+  auto* i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
 
-  auto p = parser("{a : i32;}");
+  auto* p = parser("{a : i32;}");
   auto m = p->struct_body_decl();
   ASSERT_FALSE(p->has_error());
-  ASSERT_EQ(m.size(), 1);
+  ASSERT_EQ(m.size(), 1u);
 
   const auto& mem = m[0];
   EXPECT_EQ(mem->name(), "a");
   EXPECT_EQ(mem->type(), i32);
-  EXPECT_EQ(mem->decorations().size(), 0);
+  EXPECT_EQ(mem->decorations().size(), 0u);
 }
 
 TEST_F(ParserImplTest, StructBodyDecl_ParsesEmpty) {
-  auto p = parser("{}");
+  auto* p = parser("{}");
   auto m = p->struct_body_decl();
   ASSERT_FALSE(p->has_error());
-  ASSERT_EQ(m.size(), 0);
+  ASSERT_EQ(m.size(), 0u);
 }
 
 TEST_F(ParserImplTest, StructBodyDecl_InvalidMember) {
-  auto p = parser(R"(
+  auto* p = parser(R"(
 {
   [[offset nan]] a : i32;
 })");
@@ -55,14 +55,14 @@
 }
 
 TEST_F(ParserImplTest, StructBodyDecl_MissingClosingBracket) {
-  auto p = parser("{a : i32;");
+  auto* p = parser("{a : i32;");
   auto m = p->struct_body_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:10: missing } for struct declaration");
 }
 
 TEST_F(ParserImplTest, StructBodyDecl_InvalidToken) {
-  auto p = parser(R"(
+  auto* p = parser(R"(
 {
   a : i32;
   1.23
diff --git a/src/reader/wgsl/parser_impl_struct_decl_test.cc b/src/reader/wgsl/parser_impl_struct_decl_test.cc
index b409289..bb91899 100644
--- a/src/reader/wgsl/parser_impl_struct_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_struct_decl_test.cc
@@ -23,7 +23,7 @@
 namespace {
 
 TEST_F(ParserImplTest, StructDecl_Parses) {
-  auto p = parser(R"(
+  auto* p = parser(R"(
 struct {
   a : i32;
   [[offset 4 ]] b : f32;
@@ -31,13 +31,13 @@
   auto s = p->struct_decl();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(s, nullptr);
-  ASSERT_EQ(s->impl()->members().size(), 2);
+  ASSERT_EQ(s->impl()->members().size(), 2u);
   EXPECT_EQ(s->impl()->members()[0]->name(), "a");
   EXPECT_EQ(s->impl()->members()[1]->name(), "b");
 }
 
 TEST_F(ParserImplTest, StructDecl_ParsesWithDecoration) {
-  auto p = parser(R"(
+  auto* p = parser(R"(
 [[block]] struct {
   a : f32;
   b : f32;
@@ -45,21 +45,21 @@
   auto s = p->struct_decl();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(s, nullptr);
-  ASSERT_EQ(s->impl()->members().size(), 2);
+  ASSERT_EQ(s->impl()->members().size(), 2u);
   EXPECT_EQ(s->impl()->members()[0]->name(), "a");
   EXPECT_EQ(s->impl()->members()[1]->name(), "b");
 }
 
 TEST_F(ParserImplTest, StructDecl_EmptyMembers) {
-  auto p = parser("struct {}");
+  auto* p = parser("struct {}");
   auto s = p->struct_decl();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(s, nullptr);
-  ASSERT_EQ(s->impl()->members().size(), 0);
+  ASSERT_EQ(s->impl()->members().size(), 0u);
 }
 
 TEST_F(ParserImplTest, StructDecl_MissingBracketLeft) {
-  auto p = parser("struct }");
+  auto* p = parser("struct }");
   auto s = p->struct_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(s, nullptr);
@@ -67,7 +67,7 @@
 }
 
 TEST_F(ParserImplTest, StructDecl_InvalidStructBody) {
-  auto p = parser("struct { a : B; }");
+  auto* p = parser("struct { a : B; }");
   auto s = p->struct_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(s, nullptr);
@@ -75,7 +75,7 @@
 }
 
 TEST_F(ParserImplTest, StructDecl_InvalidStructDecorationDecl) {
-  auto p = parser("[[block struct { a : i32; }");
+  auto* p = parser("[[block struct { a : i32; }");
   auto s = p->struct_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(s, nullptr);
@@ -83,7 +83,7 @@
 }
 
 TEST_F(ParserImplTest, StructDecl_MissingStruct) {
-  auto p = parser("[[block]] {}");
+  auto* p = parser("[[block]] {}");
   auto s = p->struct_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(s, nullptr);
diff --git a/src/reader/wgsl/parser_impl_struct_decoration_decl_test.cc b/src/reader/wgsl/parser_impl_struct_decoration_decl_test.cc
index a22bab0..c48dacf 100644
--- a/src/reader/wgsl/parser_impl_struct_decoration_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_struct_decoration_decl_test.cc
@@ -22,21 +22,21 @@
 namespace {
 
 TEST_F(ParserImplTest, StructDecorationDecl_Parses) {
-  auto p = parser("[[block]]");
+  auto* p = parser("[[block]]");
   auto d = p->struct_decoration_decl();
   ASSERT_FALSE(p->has_error());
   EXPECT_EQ(d, ast::StructDecoration::kBlock);
 }
 
 TEST_F(ParserImplTest, StructDecorationDecl_MissingAttrRight) {
-  auto p = parser("[[block");
+  auto* p = parser("[[block");
   p->struct_decoration_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:8: missing ]] for struct decoration");
 }
 
 TEST_F(ParserImplTest, StructDecorationDecl_InvalidDecoration) {
-  auto p = parser("[[invalid]]");
+  auto* p = parser("[[invalid]]");
   p->struct_decoration_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:3: unknown struct decoration");
diff --git a/src/reader/wgsl/parser_impl_struct_decoration_test.cc b/src/reader/wgsl/parser_impl_struct_decoration_test.cc
index b87ecbe..518ac0b 100644
--- a/src/reader/wgsl/parser_impl_struct_decoration_test.cc
+++ b/src/reader/wgsl/parser_impl_struct_decoration_test.cc
@@ -37,9 +37,9 @@
   StructDecorationTest() = default;
   ~StructDecorationTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -53,7 +53,7 @@
 
 TEST_P(StructDecorationTest, Parses) {
   auto params = GetParam();
-  auto p = parser(params.input);
+  auto* p = parser(params.input);
 
   auto deco = p->struct_decoration();
   ASSERT_FALSE(p->has_error());
@@ -68,7 +68,7 @@
                              "block", ast::StructDecoration::kBlock}));
 
 TEST_F(ParserImplTest, StructDecoration_NoMatch) {
-  auto p = parser("not-a-stage");
+  auto* p = parser("not-a-stage");
   auto deco = p->struct_decoration();
   ASSERT_EQ(deco, ast::StructDecoration::kNone);
 
diff --git a/src/reader/wgsl/parser_impl_struct_member_decoration_decl_test.cc b/src/reader/wgsl/parser_impl_struct_member_decoration_decl_test.cc
index 2fec9d6..ea54e9c 100644
--- a/src/reader/wgsl/parser_impl_struct_member_decoration_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_struct_member_decoration_decl_test.cc
@@ -23,43 +23,43 @@
 namespace {
 
 TEST_F(ParserImplTest, StructMemberDecorationDecl_EmptyStr) {
-  auto p = parser("");
+  auto* p = parser("");
   auto deco = p->struct_member_decoration_decl();
   ASSERT_FALSE(p->has_error());
-  EXPECT_EQ(deco.size(), 0);
+  EXPECT_EQ(deco.size(), 0u);
 }
 
 TEST_F(ParserImplTest, StructMemberDecorationDecl_EmptyBlock) {
-  auto p = parser("[[]]");
+  auto* p = parser("[[]]");
   auto deco = p->struct_member_decoration_decl();
   ASSERT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:3: empty struct member decoration found");
 }
 
 TEST_F(ParserImplTest, StructMemberDecorationDecl_Single) {
-  auto p = parser("[[offset 4]]");
+  auto* p = parser("[[offset 4]]");
   auto deco = p->struct_member_decoration_decl();
   ASSERT_FALSE(p->has_error());
-  ASSERT_EQ(deco.size(), 1);
+  ASSERT_EQ(deco.size(), 1u);
   EXPECT_TRUE(deco[0]->IsOffset());
 }
 
 TEST_F(ParserImplTest, StructMemberDecorationDecl_HandlesDuplicate) {
-  auto p = parser("[[offset 2, offset 4]]");
+  auto* p = parser("[[offset 2, offset 4]]");
   auto deco = p->struct_member_decoration_decl();
   ASSERT_TRUE(p->has_error()) << p->error();
   EXPECT_EQ(p->error(), "1:21: duplicate offset decoration found");
 }
 
 TEST_F(ParserImplTest, StructMemberDecorationDecl_InvalidDecoration) {
-  auto p = parser("[[offset nan]]");
+  auto* p = parser("[[offset nan]]");
   auto deco = p->struct_member_decoration_decl();
   ASSERT_TRUE(p->has_error()) << p->error();
   EXPECT_EQ(p->error(), "1:10: invalid value for offset decoration");
 }
 
 TEST_F(ParserImplTest, StructMemberDecorationDecl_MissingClose) {
-  auto p = parser("[[offset 4");
+  auto* p = parser("[[offset 4");
   auto deco = p->struct_member_decoration_decl();
   ASSERT_TRUE(p->has_error()) << p->error();
   EXPECT_EQ(p->error(), "1:11: missing ]] for struct member decoration");
diff --git a/src/reader/wgsl/parser_impl_struct_member_decoration_test.cc b/src/reader/wgsl/parser_impl_struct_member_decoration_test.cc
index 0bc2a92..7be4bce 100644
--- a/src/reader/wgsl/parser_impl_struct_member_decoration_test.cc
+++ b/src/reader/wgsl/parser_impl_struct_member_decoration_test.cc
@@ -23,18 +23,18 @@
 namespace {
 
 TEST_F(ParserImplTest, StructMemberDecoration_Offset) {
-  auto p = parser("offset 4");
+  auto* p = parser("offset 4");
   auto deco = p->struct_member_decoration();
   ASSERT_NE(deco, nullptr);
   ASSERT_FALSE(p->has_error());
   ASSERT_TRUE(deco->IsOffset());
 
-  auto o = deco->AsOffset();
-  EXPECT_EQ(o->offset(), 4);
+  auto* o = deco->AsOffset();
+  EXPECT_EQ(o->offset(), 4u);
 }
 
 TEST_F(ParserImplTest, StructMemberDecoration_Offset_MissingValue) {
-  auto p = parser("offset");
+  auto* p = parser("offset");
   auto deco = p->struct_member_decoration();
   ASSERT_EQ(deco, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -42,7 +42,7 @@
 }
 
 TEST_F(ParserImplTest, StructMemberDecoration_Offset_MissingInvalid) {
-  auto p = parser("offset nan");
+  auto* p = parser("offset nan");
   auto deco = p->struct_member_decoration();
   ASSERT_EQ(deco, nullptr);
   ASSERT_TRUE(p->has_error());
diff --git a/src/reader/wgsl/parser_impl_struct_member_test.cc b/src/reader/wgsl/parser_impl_struct_member_test.cc
index 3f630ef..49bc44c 100644
--- a/src/reader/wgsl/parser_impl_struct_member_test.cc
+++ b/src/reader/wgsl/parser_impl_struct_member_test.cc
@@ -25,35 +25,35 @@
 namespace {
 
 TEST_F(ParserImplTest, StructMember_Parses) {
-  auto i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
+  auto* i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
 
-  auto p = parser("a : i32;");
+  auto* p = parser("a : i32;");
   auto m = p->struct_member();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(m, nullptr);
 
   EXPECT_EQ(m->name(), "a");
   EXPECT_EQ(m->type(), i32);
-  EXPECT_EQ(m->decorations().size(), 0);
+  EXPECT_EQ(m->decorations().size(), 0u);
 }
 
 TEST_F(ParserImplTest, StructMember_ParsesWithDecoration) {
-  auto i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
+  auto* i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
 
-  auto p = parser("[[offset 2]] a : i32;");
+  auto* p = parser("[[offset 2]] a : i32;");
   auto m = p->struct_member();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(m, nullptr);
 
   EXPECT_EQ(m->name(), "a");
   EXPECT_EQ(m->type(), i32);
-  EXPECT_EQ(m->decorations().size(), 1);
+  EXPECT_EQ(m->decorations().size(), 1u);
   EXPECT_TRUE(m->decorations()[0]->IsOffset());
-  EXPECT_EQ(m->decorations()[0]->AsOffset()->offset(), 2);
+  EXPECT_EQ(m->decorations()[0]->AsOffset()->offset(), 2u);
 }
 
 TEST_F(ParserImplTest, StructMember_InvalidDecoration) {
-  auto p = parser("[[offset nan]] a : i32;");
+  auto* p = parser("[[offset nan]] a : i32;");
   auto m = p->struct_member();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(m, nullptr);
@@ -61,7 +61,7 @@
 }
 
 TEST_F(ParserImplTest, StructMember_InvalidVariable) {
-  auto p = parser("[[offset 4]] a : B;");
+  auto* p = parser("[[offset 4]] a : B;");
   auto m = p->struct_member();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(m, nullptr);
@@ -69,7 +69,7 @@
 }
 
 TEST_F(ParserImplTest, StructMember_MissingSemicolon) {
-  auto p = parser("a : i32");
+  auto* p = parser("a : i32");
   auto m = p->struct_member();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(m, nullptr);
diff --git a/src/reader/wgsl/parser_impl_switch_body_test.cc b/src/reader/wgsl/parser_impl_switch_body_test.cc
index a6780ff..dc85463 100644
--- a/src/reader/wgsl/parser_impl_switch_body_test.cc
+++ b/src/reader/wgsl/parser_impl_switch_body_test.cc
@@ -23,18 +23,18 @@
 namespace {
 
 TEST_F(ParserImplTest, SwitchBody_Case) {
-  auto p = parser("case 1: { a = 4; }");
+  auto* p = parser("case 1: { a = 4; }");
   auto e = p->switch_body();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsCase());
   EXPECT_FALSE(e->IsDefault());
-  ASSERT_EQ(e->body().size(), 1);
+  ASSERT_EQ(e->body().size(), 1u);
   EXPECT_TRUE(e->body()[0]->IsAssign());
 }
 
 TEST_F(ParserImplTest, SwitchBody_Case_InvalidConstLiteral) {
-  auto p = parser("case a == 4: { a = 4; }");
+  auto* p = parser("case a == 4: { a = 4; }");
   auto e = p->switch_body();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -42,7 +42,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchBody_Case_MissingConstLiteral) {
-  auto p = parser("case: { a = 4; }");
+  auto* p = parser("case: { a = 4; }");
   auto e = p->switch_body();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -50,7 +50,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchBody_Case_MissingColon) {
-  auto p = parser("case 1 { a = 4; }");
+  auto* p = parser("case 1 { a = 4; }");
   auto e = p->switch_body();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -58,7 +58,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchBody_Case_MissingBracketLeft) {
-  auto p = parser("case 1: a = 4; }");
+  auto* p = parser("case 1: a = 4; }");
   auto e = p->switch_body();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -66,7 +66,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchBody_Case_MissingBracketRight) {
-  auto p = parser("case 1: { a = 4; ");
+  auto* p = parser("case 1: { a = 4; ");
   auto e = p->switch_body();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -74,7 +74,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchBody_Case_InvalidCaseBody) {
-  auto p = parser("case 1: { fn main() -> void {} }");
+  auto* p = parser("case 1: { fn main() -> void {} }");
   auto e = p->switch_body();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -82,18 +82,18 @@
 }
 
 TEST_F(ParserImplTest, SwitchBody_Default) {
-  auto p = parser("default: { a = 4; }");
+  auto* p = parser("default: { a = 4; }");
   auto e = p->switch_body();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsCase());
   EXPECT_TRUE(e->IsDefault());
-  ASSERT_EQ(e->body().size(), 1);
+  ASSERT_EQ(e->body().size(), 1u);
   EXPECT_TRUE(e->body()[0]->IsAssign());
 }
 
 TEST_F(ParserImplTest, SwitchBody_Default_MissingColon) {
-  auto p = parser("default { a = 4; }");
+  auto* p = parser("default { a = 4; }");
   auto e = p->switch_body();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -101,7 +101,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchBody_Default_MissingBracketLeft) {
-  auto p = parser("default: a = 4; }");
+  auto* p = parser("default: a = 4; }");
   auto e = p->switch_body();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -109,7 +109,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchBody_Default_MissingBracketRight) {
-  auto p = parser("default: { a = 4; ");
+  auto* p = parser("default: { a = 4; ");
   auto e = p->switch_body();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -117,7 +117,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchBody_Default_InvalidCaseBody) {
-  auto p = parser("default: { fn main() -> void {} }");
+  auto* p = parser("default: { fn main() -> void {} }");
   auto e = p->switch_body();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_switch_stmt_test.cc b/src/reader/wgsl/parser_impl_switch_stmt_test.cc
index f9d9710..d0c98de 100644
--- a/src/reader/wgsl/parser_impl_switch_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_switch_stmt_test.cc
@@ -24,7 +24,7 @@
 namespace {
 
 TEST_F(ParserImplTest, SwitchStmt_WithoutDefault) {
-  auto p = parser(R"(switch(a) {
+  auto* p = parser(R"(switch(a) {
   case 1: {}
   case 2: {}
 })");
@@ -32,22 +32,22 @@
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsSwitch());
-  ASSERT_EQ(e->body().size(), 2);
+  ASSERT_EQ(e->body().size(), 2u);
   EXPECT_FALSE(e->body()[0]->IsDefault());
   EXPECT_FALSE(e->body()[1]->IsDefault());
 }
 
 TEST_F(ParserImplTest, SwitchStmt_Empty) {
-  auto p = parser("switch(a) { }");
+  auto* p = parser("switch(a) { }");
   auto e = p->switch_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsSwitch());
-  ASSERT_EQ(e->body().size(), 0);
+  ASSERT_EQ(e->body().size(), 0u);
 }
 
 TEST_F(ParserImplTest, SwitchStmt_DefaultInMiddle) {
-  auto p = parser(R"(switch(a) {
+  auto* p = parser(R"(switch(a) {
   case 1: {}
   default: {}
   case 2: {}
@@ -57,14 +57,14 @@
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsSwitch());
 
-  ASSERT_EQ(e->body().size(), 3);
+  ASSERT_EQ(e->body().size(), 3u);
   ASSERT_FALSE(e->body()[0]->IsDefault());
   ASSERT_TRUE(e->body()[1]->IsDefault());
   ASSERT_FALSE(e->body()[2]->IsDefault());
 }
 
 TEST_F(ParserImplTest, SwitchStmt_InvalidExpression) {
-  auto p = parser("switch(a=b) {}");
+  auto* p = parser("switch(a=b) {}");
   auto e = p->switch_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -72,7 +72,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchStmt_MissingExpression) {
-  auto p = parser("switch {}");
+  auto* p = parser("switch {}");
   auto e = p->switch_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -80,7 +80,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchStmt_MissingBracketLeft) {
-  auto p = parser("switch(a) }");
+  auto* p = parser("switch(a) }");
   auto e = p->switch_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -88,7 +88,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchStmt_MissingBracketRight) {
-  auto p = parser("switch(a) {");
+  auto* p = parser("switch(a) {");
   auto e = p->switch_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -96,7 +96,7 @@
 }
 
 TEST_F(ParserImplTest, SwitchStmt_InvalidBody) {
-  auto p = parser(R"(switch(a) {
+  auto* p = parser(R"(switch(a) {
   case: {}
 })");
   auto e = p->switch_stmt();
diff --git a/src/reader/wgsl/parser_impl_test.cc b/src/reader/wgsl/parser_impl_test.cc
index 890be8c..022e09d 100644
--- a/src/reader/wgsl/parser_impl_test.cc
+++ b/src/reader/wgsl/parser_impl_test.cc
@@ -24,12 +24,12 @@
 namespace {
 
 TEST_F(ParserImplTest, Empty) {
-  auto p = parser("");
+  auto* p = parser("");
   ASSERT_TRUE(p->Parse()) << p->error();
 }
 
 TEST_F(ParserImplTest, Parses) {
-  auto p = parser(R"(
+  auto* p = parser(R"(
 import "GLSL.std.430" as glsl;
 
 [[location 0]] var<out> gl_FragColor : vec4<f32>;
@@ -42,14 +42,14 @@
   ASSERT_TRUE(p->Parse()) << p->error();
 
   auto m = p->module();
-  ASSERT_EQ(1, m.imports().size());
-  ASSERT_EQ(1, m.entry_points().size());
-  ASSERT_EQ(1, m.functions().size());
-  ASSERT_EQ(1, m.global_variables().size());
+  ASSERT_EQ(1u, m.imports().size());
+  ASSERT_EQ(1u, m.entry_points().size());
+  ASSERT_EQ(1u, m.functions().size());
+  ASSERT_EQ(1u, m.global_variables().size());
 }
 
 TEST_F(ParserImplTest, HandlesError) {
-  auto p = parser(R"(
+  auto* p = parser(R"(
 import "GLSL.std.430" as glsl;
 
 fn main() ->  {  # missing return type
@@ -62,18 +62,18 @@
 }
 
 TEST_F(ParserImplTest, GetRegisteredType) {
-  auto p = parser("");
+  auto* p = parser("");
   ast::type::I32Type i32;
   p->register_alias("my_alias", &i32);
 
-  auto alias = p->get_alias("my_alias");
+  auto* alias = p->get_alias("my_alias");
   ASSERT_NE(alias, nullptr);
   ASSERT_EQ(alias, &i32);
 }
 
 TEST_F(ParserImplTest, GetUnregisteredType) {
-  auto p = parser("");
-  auto alias = p->get_alias("my_alias");
+  auto* p = parser("");
+  auto* alias = p->get_alias("my_alias");
   ASSERT_EQ(alias, nullptr);
 }
 
diff --git a/src/reader/wgsl/parser_impl_test_helper.cc b/src/reader/wgsl/parser_impl_test_helper.cc
new file mode 100644
index 0000000..d3746cf
--- /dev/null
+++ b/src/reader/wgsl/parser_impl_test_helper.cc
@@ -0,0 +1,34 @@
+// Copyright 2020 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "src/reader/wgsl/parser_impl_test_helper.h"
+
+namespace tint {
+namespace reader {
+namespace wgsl {
+
+ParserImplTest::ParserImplTest() = default;
+
+ParserImplTest::~ParserImplTest() = default;
+
+void ParserImplTest::SetUp() {
+  ctx_.Reset();
+}
+
+void ParserImplTest::TearDown() {
+  impl_ = nullptr;
+}
+
+}  // namespace wgsl
+}  // namespace reader
+}  // namespace tint
diff --git a/src/reader/wgsl/parser_impl_test_helper.h b/src/reader/wgsl/parser_impl_test_helper.h
index fd177e9..bdb1a29 100644
--- a/src/reader/wgsl/parser_impl_test_helper.h
+++ b/src/reader/wgsl/parser_impl_test_helper.h
@@ -30,14 +30,14 @@
 class ParserImplTest : public testing::Test {
  public:
   /// Constructor
-  ParserImplTest() = default;
-  ~ParserImplTest() = default;
+  ParserImplTest();
+  ~ParserImplTest() override;
 
   /// Sets up the test helper
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override;
 
   /// Tears down the test helper
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override;
 
   /// Retrieves the parser from the helper
   /// @param str the string to parse
diff --git a/src/reader/wgsl/parser_impl_type_alias_test.cc b/src/reader/wgsl/parser_impl_type_alias_test.cc
index e0dbacd..fde357e 100644
--- a/src/reader/wgsl/parser_impl_type_alias_test.cc
+++ b/src/reader/wgsl/parser_impl_type_alias_test.cc
@@ -26,10 +26,10 @@
 namespace {
 
 TEST_F(ParserImplTest, TypeDecl_ParsesType) {
-  auto i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
+  auto* i32 = tm()->Get(std::make_unique<ast::type::I32Type>());
 
-  auto p = parser("type a = i32");
-  auto t = p->type_alias();
+  auto* p = parser("type a = i32");
+  auto* t = p->type_alias();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(t, nullptr);
   ASSERT_TRUE(t->type()->IsI32());
@@ -37,52 +37,52 @@
 }
 
 TEST_F(ParserImplTest, TypeDecl_ParsesStruct) {
-  auto p = parser("type a = struct { b: i32; c: f32;}");
-  auto t = p->type_alias();
+  auto* p = parser("type a = struct { b: i32; c: f32;}");
+  auto* t = p->type_alias();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(t, nullptr);
   EXPECT_EQ(t->name(), "a");
   ASSERT_TRUE(t->type()->IsStruct());
 
-  auto s = t->type()->AsStruct();
-  EXPECT_EQ(s->impl()->members().size(), 2);
+  auto* s = t->type()->AsStruct();
+  EXPECT_EQ(s->impl()->members().size(), 2u);
 }
 
 TEST_F(ParserImplTest, TypeDecl_MissingIdent) {
-  auto p = parser("type = i32");
-  auto t = p->type_alias();
+  auto* p = parser("type = i32");
+  auto* t = p->type_alias();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(t, nullptr);
   EXPECT_EQ(p->error(), "1:6: missing identifier for type alias");
 }
 
 TEST_F(ParserImplTest, TypeDecl_InvalidIdent) {
-  auto p = parser("type 123 = i32");
-  auto t = p->type_alias();
+  auto* p = parser("type 123 = i32");
+  auto* t = p->type_alias();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(t, nullptr);
   EXPECT_EQ(p->error(), "1:6: missing identifier for type alias");
 }
 
 TEST_F(ParserImplTest, TypeDecl_MissingEqual) {
-  auto p = parser("type a i32");
-  auto t = p->type_alias();
+  auto* p = parser("type a i32");
+  auto* t = p->type_alias();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(t, nullptr);
   EXPECT_EQ(p->error(), "1:8: missing = for type alias");
 }
 
 TEST_F(ParserImplTest, TypeDecl_InvalidType) {
-  auto p = parser("type a = B");
-  auto t = p->type_alias();
+  auto* p = parser("type a = B");
+  auto* t = p->type_alias();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(t, nullptr);
   EXPECT_EQ(p->error(), "1:10: unknown type alias 'B'");
 }
 
 TEST_F(ParserImplTest, TypeDecl_InvalidStruct) {
-  auto p = parser("type a = [[block]] {}");
-  auto t = p->type_alias();
+  auto* p = parser("type a = [[block]] {}");
+  auto* t = p->type_alias();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(t, nullptr);
   EXPECT_EQ(p->error(), "1:20: missing struct declaration");
diff --git a/src/reader/wgsl/parser_impl_type_decl_test.cc b/src/reader/wgsl/parser_impl_type_decl_test.cc
index d8119ef..8399b2b 100644
--- a/src/reader/wgsl/parser_impl_type_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_type_decl_test.cc
@@ -33,80 +33,80 @@
 namespace {
 
 TEST_F(ParserImplTest, TypeDecl_Invalid) {
-  auto p = parser("1234");
-  auto t = p->type_decl();
+  auto* p = parser("1234");
+  auto* t = p->type_decl();
   EXPECT_EQ(t, nullptr);
   EXPECT_FALSE(p->has_error());
 }
 
 TEST_F(ParserImplTest, TypeDecl_Identifier) {
-  auto p = parser("A");
+  auto* p = parser("A");
 
-  auto int_type = tm()->Get(std::make_unique<ast::type::I32Type>());
+  auto* int_type = tm()->Get(std::make_unique<ast::type::I32Type>());
   // Pre-register to make sure that it's the same type.
-  auto alias_type =
+  auto* alias_type =
       tm()->Get(std::make_unique<ast::type::AliasType>("A", int_type));
 
   p->register_alias("A", alias_type);
 
-  auto t = p->type_decl();
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr);
   EXPECT_EQ(t, alias_type);
   ASSERT_TRUE(t->IsAlias());
 
-  auto alias = t->AsAlias();
+  auto* alias = t->AsAlias();
   EXPECT_EQ(alias->name(), "A");
   EXPECT_EQ(alias->type(), int_type);
 }
 
 TEST_F(ParserImplTest, TypeDecl_Identifier_NotFound) {
-  auto p = parser("B");
+  auto* p = parser("B");
 
-  auto t = p->type_decl();
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   EXPECT_TRUE(p->has_error());
   EXPECT_EQ(p->error(), "1:1: unknown type alias 'B'");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Bool) {
-  auto p = parser("bool");
+  auto* p = parser("bool");
 
-  auto bool_type = tm()->Get(std::make_unique<ast::type::BoolType>());
+  auto* bool_type = tm()->Get(std::make_unique<ast::type::BoolType>());
 
-  auto t = p->type_decl();
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr);
   EXPECT_EQ(t, bool_type);
   ASSERT_TRUE(t->IsBool());
 }
 
 TEST_F(ParserImplTest, TypeDecl_F32) {
-  auto p = parser("f32");
+  auto* p = parser("f32");
 
-  auto float_type = tm()->Get(std::make_unique<ast::type::F32Type>());
+  auto* float_type = tm()->Get(std::make_unique<ast::type::F32Type>());
 
-  auto t = p->type_decl();
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr);
   EXPECT_EQ(t, float_type);
   ASSERT_TRUE(t->IsF32());
 }
 
 TEST_F(ParserImplTest, TypeDecl_I32) {
-  auto p = parser("i32");
+  auto* p = parser("i32");
 
-  auto int_type = tm()->Get(std::make_unique<ast::type::I32Type>());
+  auto* int_type = tm()->Get(std::make_unique<ast::type::I32Type>());
 
-  auto t = p->type_decl();
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr);
   EXPECT_EQ(t, int_type);
   ASSERT_TRUE(t->IsI32());
 }
 
 TEST_F(ParserImplTest, TypeDecl_U32) {
-  auto p = parser("u32");
+  auto* p = parser("u32");
 
-  auto uint_type = tm()->Get(std::make_unique<ast::type::U32Type>());
+  auto* uint_type = tm()->Get(std::make_unique<ast::type::U32Type>());
 
-  auto t = p->type_decl();
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr);
   EXPECT_EQ(t, uint_type);
   ASSERT_TRUE(t->IsU32());
@@ -125,9 +125,9 @@
   VecTest() = default;
   ~VecTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -141,8 +141,8 @@
 
 TEST_P(VecTest, Parse) {
   auto params = GetParam();
-  auto p = parser(params.input);
-  auto t = p->type_decl();
+  auto* p = parser(params.input);
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr);
   ASSERT_FALSE(p->has_error());
   EXPECT_TRUE(t->IsVector());
@@ -159,9 +159,9 @@
   VecMissingGreaterThanTest() = default;
   ~VecMissingGreaterThanTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -175,8 +175,8 @@
 
 TEST_P(VecMissingGreaterThanTest, Handles_Missing_GreaterThan) {
   auto params = GetParam();
-  auto p = parser(params.input);
-  auto t = p->type_decl();
+  auto* p = parser(params.input);
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:9: missing > for vector");
@@ -192,9 +192,9 @@
   VecMissingLessThanTest() = default;
   ~VecMissingLessThanTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -208,8 +208,8 @@
 
 TEST_P(VecMissingLessThanTest, Handles_Missing_GreaterThan) {
   auto params = GetParam();
-  auto p = parser(params.input);
-  auto t = p->type_decl();
+  auto* p = parser(params.input);
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:5: missing < for vector");
@@ -225,9 +225,9 @@
   VecBadType() = default;
   ~VecBadType() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -241,8 +241,8 @@
 
 TEST_P(VecBadType, Handles_Unknown_Type) {
   auto params = GetParam();
-  auto p = parser(params.input);
-  auto t = p->type_decl();
+  auto* p = parser(params.input);
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:6: unknown type alias 'unknown'");
@@ -258,9 +258,9 @@
   VecMissingType() = default;
   ~VecMissingType() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -274,8 +274,8 @@
 
 TEST_P(VecMissingType, Handles_Missing_Type) {
   auto params = GetParam();
-  auto p = parser(params.input);
-  auto t = p->type_decl();
+  auto* p = parser(params.input);
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:6: unable to determine subtype for vector");
@@ -287,173 +287,173 @@
                                          VecData{"vec4<>", 4}));
 
 TEST_F(ParserImplTest, TypeDecl_Ptr) {
-  auto p = parser("ptr<function, f32>");
-  auto t = p->type_decl();
+  auto* p = parser("ptr<function, f32>");
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr) << p->error();
   ASSERT_FALSE(p->has_error());
   ASSERT_TRUE(t->IsPointer());
 
-  auto ptr = t->AsPointer();
+  auto* ptr = t->AsPointer();
   ASSERT_TRUE(ptr->type()->IsF32());
   ASSERT_EQ(ptr->storage_class(), ast::StorageClass::kFunction);
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_ToVec) {
-  auto p = parser("ptr<function, vec2<f32>>");
-  auto t = p->type_decl();
+  auto* p = parser("ptr<function, vec2<f32>>");
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr) << p->error();
   ASSERT_FALSE(p->has_error());
   ASSERT_TRUE(t->IsPointer());
 
-  auto ptr = t->AsPointer();
+  auto* ptr = t->AsPointer();
   ASSERT_TRUE(ptr->type()->IsVector());
   ASSERT_EQ(ptr->storage_class(), ast::StorageClass::kFunction);
 
-  auto vec = ptr->type()->AsVector();
-  ASSERT_EQ(vec->size(), 2);
+  auto* vec = ptr->type()->AsVector();
+  ASSERT_EQ(vec->size(), 2u);
   ASSERT_TRUE(vec->type()->IsF32());
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_MissingLessThan) {
-  auto p = parser("ptr private, f32>");
-  auto t = p->type_decl();
+  auto* p = parser("ptr private, f32>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:5: missing < for ptr declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_MissingGreaterThan) {
-  auto p = parser("ptr<function, f32");
-  auto t = p->type_decl();
+  auto* p = parser("ptr<function, f32");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:18: missing > for ptr declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_MissingComma) {
-  auto p = parser("ptr<function f32>");
-  auto t = p->type_decl();
+  auto* p = parser("ptr<function f32>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:14: missing , for ptr declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_MissingStorageClass) {
-  auto p = parser("ptr<, f32>");
-  auto t = p->type_decl();
+  auto* p = parser("ptr<, f32>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:5: missing storage class for ptr declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_MissingParams) {
-  auto p = parser("ptr<>");
-  auto t = p->type_decl();
+  auto* p = parser("ptr<>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:5: missing storage class for ptr declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_MissingType) {
-  auto p = parser("ptr<function,>");
-  auto t = p->type_decl();
+  auto* p = parser("ptr<function,>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:14: missing type for ptr declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_BadStorageClass) {
-  auto p = parser("ptr<unknown, f32>");
-  auto t = p->type_decl();
+  auto* p = parser("ptr<unknown, f32>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:5: missing storage class for ptr declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Ptr_BadType) {
-  auto p = parser("ptr<function, unknown>");
-  auto t = p->type_decl();
+  auto* p = parser("ptr<function, unknown>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:15: unknown type alias 'unknown'");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Array) {
-  auto p = parser("array<f32, 5>");
-  auto t = p->type_decl();
+  auto* p = parser("array<f32, 5>");
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr);
   ASSERT_FALSE(p->has_error());
   ASSERT_TRUE(t->IsArray());
 
-  auto a = t->AsArray();
+  auto* a = t->AsArray();
   ASSERT_FALSE(a->IsRuntimeArray());
-  ASSERT_EQ(a->size(), 5);
+  ASSERT_EQ(a->size(), 5u);
   ASSERT_TRUE(a->type()->IsF32());
 }
 
 TEST_F(ParserImplTest, TypeDecl_Array_Runtime) {
-  auto p = parser("array<u32>");
-  auto t = p->type_decl();
+  auto* p = parser("array<u32>");
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr);
   ASSERT_FALSE(p->has_error());
   ASSERT_TRUE(t->IsArray());
 
-  auto a = t->AsArray();
+  auto* a = t->AsArray();
   ASSERT_TRUE(a->IsRuntimeArray());
   ASSERT_TRUE(a->type()->IsU32());
 }
 
 TEST_F(ParserImplTest, TypeDecl_Array_BadType) {
-  auto p = parser("array<unknown, 3>");
-  auto t = p->type_decl();
+  auto* p = parser("array<unknown, 3>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:7: unknown type alias 'unknown'");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Array_ZeroSize) {
-  auto p = parser("array<f32, 0>");
-  auto t = p->type_decl();
+  auto* p = parser("array<f32, 0>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:12: invalid size for array declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Array_NegativeSize) {
-  auto p = parser("array<f32, -1>");
-  auto t = p->type_decl();
+  auto* p = parser("array<f32, -1>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:12: invalid size for array declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Array_BadSize) {
-  auto p = parser("array<f32, invalid>");
-  auto t = p->type_decl();
+  auto* p = parser("array<f32, invalid>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:12: missing size of array declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Array_MissingLessThan) {
-  auto p = parser("array f32>");
-  auto t = p->type_decl();
+  auto* p = parser("array f32>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:7: missing < for array declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Array_MissingGreaterThan) {
-  auto p = parser("array<f32");
-  auto t = p->type_decl();
+  auto* p = parser("array<f32");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:10: missing > for array declaration");
 }
 
 TEST_F(ParserImplTest, TypeDecl_Array_MissingComma) {
-  auto p = parser("array<f32 3>");
-  auto t = p->type_decl();
+  auto* p = parser("array<f32 3>");
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:11: missing > for array declaration");
@@ -473,9 +473,9 @@
   MatrixTest() = default;
   ~MatrixTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -489,12 +489,12 @@
 
 TEST_P(MatrixTest, Parse) {
   auto params = GetParam();
-  auto p = parser(params.input);
-  auto t = p->type_decl();
+  auto* p = parser(params.input);
+  auto* t = p->type_decl();
   ASSERT_NE(t, nullptr);
   ASSERT_FALSE(p->has_error());
   EXPECT_TRUE(t->IsMatrix());
-  auto mat = t->AsMatrix();
+  auto* mat = t->AsMatrix();
   EXPECT_EQ(mat->rows(), params.rows);
   EXPECT_EQ(mat->columns(), params.columns);
 }
@@ -515,9 +515,9 @@
   MatrixMissingGreaterThanTest() = default;
   ~MatrixMissingGreaterThanTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -530,8 +530,8 @@
 };
 TEST_P(MatrixMissingGreaterThanTest, Handles_Missing_GreaterThan) {
   auto params = GetParam();
-  auto p = parser(params.input);
-  auto t = p->type_decl();
+  auto* p = parser(params.input);
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:11: missing > for matrix");
@@ -553,9 +553,9 @@
   MatrixMissingLessThanTest() = default;
   ~MatrixMissingLessThanTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -568,8 +568,8 @@
 };
 TEST_P(MatrixMissingLessThanTest, Handles_Missing_GreaterThan) {
   auto params = GetParam();
-  auto p = parser(params.input);
-  auto t = p->type_decl();
+  auto* p = parser(params.input);
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:8: missing < for matrix");
@@ -591,9 +591,9 @@
   MatrixBadType() = default;
   ~MatrixBadType() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -606,8 +606,8 @@
 };
 TEST_P(MatrixBadType, Handles_Unknown_Type) {
   auto params = GetParam();
-  auto p = parser(params.input);
-  auto t = p->type_decl();
+  auto* p = parser(params.input);
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:8: unknown type alias 'unknown'");
@@ -629,9 +629,9 @@
   MatrixMissingType() = default;
   ~MatrixMissingType() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -644,8 +644,8 @@
 };
 TEST_P(MatrixMissingType, Handles_Missing_Type) {
   auto params = GetParam();
-  auto p = parser(params.input);
-  auto t = p->type_decl();
+  auto* p = parser(params.input);
+  auto* t = p->type_decl();
   ASSERT_EQ(t, nullptr);
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:8: unable to determine subtype for matrix");
diff --git a/src/reader/wgsl/parser_impl_unary_expression_test.cc b/src/reader/wgsl/parser_impl_unary_expression_test.cc
index 090c9af..5d1b578 100644
--- a/src/reader/wgsl/parser_impl_unary_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_unary_expression_test.cc
@@ -29,45 +29,45 @@
 namespace {
 
 TEST_F(ParserImplTest, UnaryExpression_Postix) {
-  auto p = parser("a[2]");
+  auto* p = parser("a[2]");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
 
   ASSERT_TRUE(e->IsArrayAccessor());
-  auto ary = e->AsArrayAccessor();
+  auto* ary = e->AsArrayAccessor();
   ASSERT_TRUE(ary->array()->IsIdentifier());
-  auto ident = ary->array()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = ary->array()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(ary->idx_expr()->IsConstructor());
   ASSERT_TRUE(ary->idx_expr()->AsConstructor()->IsScalarConstructor());
-  auto init = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
+  auto* init = ary->idx_expr()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsInt());
   ASSERT_EQ(init->literal()->AsInt()->value(), 2);
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Minus) {
-  auto p = parser("- 1");
+  auto* p = parser("- 1");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryOp());
 
-  auto u = e->AsUnaryOp();
+  auto* u = e->AsUnaryOp();
   ASSERT_EQ(u->op(), ast::UnaryOp::kNegation);
 
   ASSERT_TRUE(u->expr()->IsConstructor());
   ASSERT_TRUE(u->expr()->AsConstructor()->IsScalarConstructor());
 
-  auto init = u->expr()->AsConstructor()->AsScalarConstructor();
+  auto* init = u->expr()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsInt());
   EXPECT_EQ(init->literal()->AsInt()->value(), 1);
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Minus_InvalidRHS) {
-  auto p = parser("-if(a) {}");
+  auto* p = parser("-if(a) {}");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -75,25 +75,25 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Bang) {
-  auto p = parser("!1");
+  auto* p = parser("!1");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryOp());
 
-  auto u = e->AsUnaryOp();
+  auto* u = e->AsUnaryOp();
   ASSERT_EQ(u->op(), ast::UnaryOp::kNot);
 
   ASSERT_TRUE(u->expr()->IsConstructor());
   ASSERT_TRUE(u->expr()->AsConstructor()->IsScalarConstructor());
 
-  auto init = u->expr()->AsConstructor()->AsScalarConstructor();
+  auto* init = u->expr()->AsConstructor()->AsScalarConstructor();
   ASSERT_TRUE(init->literal()->IsInt());
   EXPECT_EQ(init->literal()->AsInt()->value(), 1);
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Bang_InvalidRHS) {
-  auto p = parser("!if (a) {}");
+  auto* p = parser("!if (a) {}");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -101,23 +101,23 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Any) {
-  auto p = parser("any(a)");
+  auto* p = parser("any(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryMethod());
 
-  auto u = e->AsUnaryMethod();
+  auto* u = e->AsUnaryMethod();
   ASSERT_EQ(u->op(), ast::UnaryMethod::kAny);
-  ASSERT_EQ(u->params().size(), 1);
+  ASSERT_EQ(u->params().size(), 1u);
   ASSERT_TRUE(u->params()[0]->IsIdentifier());
-  auto ident = u->params()[0]->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = u->params()[0]->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Any_MissingParenLeft) {
-  auto p = parser("any a)");
+  auto* p = parser("any a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -125,7 +125,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Any_MissingParenRight) {
-  auto p = parser("any(a");
+  auto* p = parser("any(a");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -133,7 +133,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Any_MissingIdentifier) {
-  auto p = parser("any()");
+  auto* p = parser("any()");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -141,7 +141,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Any_InvalidIdentifier) {
-  auto p = parser("any(123)");
+  auto* p = parser("any(123)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -149,23 +149,23 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_All) {
-  auto p = parser("all(a)");
+  auto* p = parser("all(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryMethod());
 
-  auto u = e->AsUnaryMethod();
+  auto* u = e->AsUnaryMethod();
   ASSERT_EQ(u->op(), ast::UnaryMethod::kAll);
-  ASSERT_EQ(u->params().size(), 1);
+  ASSERT_EQ(u->params().size(), 1u);
   ASSERT_TRUE(u->params()[0]->IsIdentifier());
-  auto ident = u->params()[0]->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = u->params()[0]->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_All_MissingParenLeft) {
-  auto p = parser("all a)");
+  auto* p = parser("all a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -173,7 +173,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_All_MissingParenRight) {
-  auto p = parser("all(a");
+  auto* p = parser("all(a");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -181,7 +181,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_All_MissingIdentifier) {
-  auto p = parser("all()");
+  auto* p = parser("all()");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -189,7 +189,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_All_InvalidIdentifier) {
-  auto p = parser("all(123)");
+  auto* p = parser("all(123)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -197,23 +197,23 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsNan) {
-  auto p = parser("is_nan(a)");
+  auto* p = parser("is_nan(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryMethod());
 
-  auto u = e->AsUnaryMethod();
+  auto* u = e->AsUnaryMethod();
   ASSERT_EQ(u->op(), ast::UnaryMethod::kIsNan);
-  ASSERT_EQ(u->params().size(), 1);
+  ASSERT_EQ(u->params().size(), 1u);
   ASSERT_TRUE(u->params()[0]->IsIdentifier());
-  auto ident = u->params()[0]->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = u->params()[0]->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsNan_MissingParenLeft) {
-  auto p = parser("is_nan a)");
+  auto* p = parser("is_nan a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -221,7 +221,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsNan_MissingParenRight) {
-  auto p = parser("is_nan(a");
+  auto* p = parser("is_nan(a");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -229,7 +229,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsNan_MissingIdentifier) {
-  auto p = parser("is_nan()");
+  auto* p = parser("is_nan()");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -237,7 +237,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsNan_InvalidIdentifier) {
-  auto p = parser("is_nan(123)");
+  auto* p = parser("is_nan(123)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -245,23 +245,23 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsInf) {
-  auto p = parser("is_inf(a)");
+  auto* p = parser("is_inf(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryMethod());
 
-  auto u = e->AsUnaryMethod();
+  auto* u = e->AsUnaryMethod();
   ASSERT_EQ(u->op(), ast::UnaryMethod::kIsInf);
-  ASSERT_EQ(u->params().size(), 1);
+  ASSERT_EQ(u->params().size(), 1u);
   ASSERT_TRUE(u->params()[0]->IsIdentifier());
-  auto ident = u->params()[0]->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = u->params()[0]->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsInf_MissingParenLeft) {
-  auto p = parser("is_inf a)");
+  auto* p = parser("is_inf a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -269,7 +269,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsInf_MissingParenRight) {
-  auto p = parser("is_inf(a");
+  auto* p = parser("is_inf(a");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -277,7 +277,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsInf_MissingIdentifier) {
-  auto p = parser("is_inf()");
+  auto* p = parser("is_inf()");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -285,7 +285,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsInf_InvalidIdentifier) {
-  auto p = parser("is_inf(123)");
+  auto* p = parser("is_inf(123)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -293,23 +293,23 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsFinite) {
-  auto p = parser("is_finite(a)");
+  auto* p = parser("is_finite(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryMethod());
 
-  auto u = e->AsUnaryMethod();
+  auto* u = e->AsUnaryMethod();
   ASSERT_EQ(u->op(), ast::UnaryMethod::kIsFinite);
-  ASSERT_EQ(u->params().size(), 1);
+  ASSERT_EQ(u->params().size(), 1u);
   ASSERT_TRUE(u->params()[0]->IsIdentifier());
-  auto ident = u->params()[0]->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = u->params()[0]->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsFinite_MissingParenLeft) {
-  auto p = parser("is_finite a)");
+  auto* p = parser("is_finite a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -317,7 +317,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsFinite_MissingParenRight) {
-  auto p = parser("is_finite(a");
+  auto* p = parser("is_finite(a");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -325,7 +325,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsFinite_MissingIdentifier) {
-  auto p = parser("is_finite()");
+  auto* p = parser("is_finite()");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -333,7 +333,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsFinite_InvalidIdentifier) {
-  auto p = parser("is_finite(123)");
+  auto* p = parser("is_finite(123)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -341,23 +341,23 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsNormal) {
-  auto p = parser("is_normal(a)");
+  auto* p = parser("is_normal(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryMethod());
 
-  auto u = e->AsUnaryMethod();
+  auto* u = e->AsUnaryMethod();
   ASSERT_EQ(u->op(), ast::UnaryMethod::kIsNormal);
-  ASSERT_EQ(u->params().size(), 1);
+  ASSERT_EQ(u->params().size(), 1u);
   ASSERT_TRUE(u->params()[0]->IsIdentifier());
-  auto ident = u->params()[0]->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = u->params()[0]->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsNormal_MissingParenLeft) {
-  auto p = parser("is_normal a)");
+  auto* p = parser("is_normal a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -365,7 +365,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsNormal_MissingParenRight) {
-  auto p = parser("is_normal(a");
+  auto* p = parser("is_normal(a");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -373,7 +373,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsNormal_MissingIdentifier) {
-  auto p = parser("is_normal()");
+  auto* p = parser("is_normal()");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -381,7 +381,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_IsNormal_InvalidIdentifier) {
-  auto p = parser("is_normal(123)");
+  auto* p = parser("is_normal(123)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -389,28 +389,28 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dot) {
-  auto p = parser("dot(a, b)");
+  auto* p = parser("dot(a, b)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryMethod());
 
-  auto u = e->AsUnaryMethod();
+  auto* u = e->AsUnaryMethod();
   ASSERT_EQ(u->op(), ast::UnaryMethod::kDot);
-  ASSERT_EQ(u->params().size(), 2);
+  ASSERT_EQ(u->params().size(), 2u);
   ASSERT_TRUE(u->params()[0]->IsIdentifier());
-  auto ident = u->params()[0]->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = u->params()[0]->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(u->params()[1]->IsIdentifier());
   ident = u->params()[1]->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "b");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dot_MissingParenLeft) {
-  auto p = parser("dot a, b)");
+  auto* p = parser("dot a, b)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -418,7 +418,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dot_MissingParenRight) {
-  auto p = parser("dot(a, b");
+  auto* p = parser("dot(a, b");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -426,7 +426,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dot_MissingFirstIdentifier) {
-  auto p = parser("dot(, a)");
+  auto* p = parser("dot(, a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -434,7 +434,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dot_MissingSecondIdentifier) {
-  auto p = parser("dot(a, )");
+  auto* p = parser("dot(a, )");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -442,7 +442,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dot_MissingComma) {
-  auto p = parser("dot(a b)");
+  auto* p = parser("dot(a b)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -450,7 +450,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dot_InvalidFirstIdentifier) {
-  auto p = parser("dot(123, b)");
+  auto* p = parser("dot(123, b)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -458,7 +458,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dot_InvalidSecondIdentifier) {
-  auto p = parser("dot(a, 123)");
+  auto* p = parser("dot(a, 123)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -466,28 +466,28 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_OuterProduct) {
-  auto p = parser("outer_product(a, b)");
+  auto* p = parser("outer_product(a, b)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryMethod());
 
-  auto u = e->AsUnaryMethod();
+  auto* u = e->AsUnaryMethod();
   ASSERT_EQ(u->op(), ast::UnaryMethod::kOuterProduct);
-  ASSERT_EQ(u->params().size(), 2);
+  ASSERT_EQ(u->params().size(), 2u);
   ASSERT_TRUE(u->params()[0]->IsIdentifier());
-  auto ident = u->params()[0]->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = u->params()[0]->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 
   ASSERT_TRUE(u->params()[1]->IsIdentifier());
   ident = u->params()[1]->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "b");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_OuterProduct_MissingParenLeft) {
-  auto p = parser("outer_product a, b)");
+  auto* p = parser("outer_product a, b)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -495,7 +495,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_OuterProduct_MissingParenRight) {
-  auto p = parser("outer_product(a, b");
+  auto* p = parser("outer_product(a, b");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -503,7 +503,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_OuterProduct_MissingFirstIdentifier) {
-  auto p = parser("outer_product(, b)");
+  auto* p = parser("outer_product(, b)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -511,7 +511,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_OuterProduct_MissingSecondIdentifier) {
-  auto p = parser("outer_product(a, )");
+  auto* p = parser("outer_product(a, )");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -519,7 +519,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_OuterProduct_MissingComma) {
-  auto p = parser("outer_product(a b)");
+  auto* p = parser("outer_product(a b)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -527,7 +527,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_OuterProduct_InvalidFirstIdentifier) {
-  auto p = parser("outer_product(123, b)");
+  auto* p = parser("outer_product(123, b)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -535,7 +535,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_OuterProduct_InvalidSecondIdentifier) {
-  auto p = parser("outer_product(a, 123)");
+  auto* p = parser("outer_product(a, 123)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -543,43 +543,43 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdx_NoModifier) {
-  auto p = parser("dpdx(a)");
+  auto* p = parser("dpdx(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryDerivative());
 
-  auto deriv = e->AsUnaryDerivative();
+  auto* deriv = e->AsUnaryDerivative();
   EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kDpdx);
   EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kNone);
 
   ASSERT_NE(deriv->param(), nullptr);
   ASSERT_TRUE(deriv->param()->IsIdentifier());
-  auto ident = deriv->param()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = deriv->param()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdx_WithModifier) {
-  auto p = parser("dpdx<coarse>(a)");
+  auto* p = parser("dpdx<coarse>(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryDerivative());
 
-  auto deriv = e->AsUnaryDerivative();
+  auto* deriv = e->AsUnaryDerivative();
   EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kDpdx);
   EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kCoarse);
 
   ASSERT_NE(deriv->param(), nullptr);
   ASSERT_TRUE(deriv->param()->IsIdentifier());
-  auto ident = deriv->param()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = deriv->param()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdx_MissingLessThan) {
-  auto p = parser("dpdx coarse>(a)");
+  auto* p = parser("dpdx coarse>(a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -587,7 +587,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdx_InvalidModifier) {
-  auto p = parser("dpdx<invalid>(a)");
+  auto* p = parser("dpdx<invalid>(a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -595,7 +595,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdx_EmptyModifer) {
-  auto p = parser("dpdx coarse>(a)");
+  auto* p = parser("dpdx coarse>(a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -603,7 +603,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdx_MissingGreaterThan) {
-  auto p = parser("dpdx<coarse (a)");
+  auto* p = parser("dpdx<coarse (a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -611,7 +611,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdx_MisisngLeftParen) {
-  auto p = parser("dpdx<coarse>a)");
+  auto* p = parser("dpdx<coarse>a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -619,7 +619,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdx_MissingRightParen) {
-  auto p = parser("dpdx<coarse>(a");
+  auto* p = parser("dpdx<coarse>(a");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -627,7 +627,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdx_MissingIdentifier) {
-  auto p = parser("dpdx<coarse>()");
+  auto* p = parser("dpdx<coarse>()");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -635,7 +635,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdx_InvalidIdentifeir) {
-  auto p = parser("dpdx<coarse>(12345)");
+  auto* p = parser("dpdx<coarse>(12345)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -643,43 +643,43 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdy_NoModifier) {
-  auto p = parser("dpdy(a)");
+  auto* p = parser("dpdy(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryDerivative());
 
-  auto deriv = e->AsUnaryDerivative();
+  auto* deriv = e->AsUnaryDerivative();
   EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kDpdy);
   EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kNone);
 
   ASSERT_NE(deriv->param(), nullptr);
   ASSERT_TRUE(deriv->param()->IsIdentifier());
-  auto ident = deriv->param()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = deriv->param()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdy_WithModifier) {
-  auto p = parser("dpdy<fine>(a)");
+  auto* p = parser("dpdy<fine>(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryDerivative());
 
-  auto deriv = e->AsUnaryDerivative();
+  auto* deriv = e->AsUnaryDerivative();
   EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kDpdy);
   EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kFine);
 
   ASSERT_NE(deriv->param(), nullptr);
   ASSERT_TRUE(deriv->param()->IsIdentifier());
-  auto ident = deriv->param()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = deriv->param()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdy_MissingLessThan) {
-  auto p = parser("dpdy coarse>(a)");
+  auto* p = parser("dpdy coarse>(a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -687,7 +687,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdy_InvalidModifier) {
-  auto p = parser("dpdy<invalid>(a)");
+  auto* p = parser("dpdy<invalid>(a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -695,7 +695,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdy_EmptyModifer) {
-  auto p = parser("dpdy coarse>(a)");
+  auto* p = parser("dpdy coarse>(a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -703,7 +703,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdy_MissingGreaterThan) {
-  auto p = parser("dpdy<coarse (a)");
+  auto* p = parser("dpdy<coarse (a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -711,7 +711,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdy_MisisngLeftParen) {
-  auto p = parser("dpdy<coarse>a)");
+  auto* p = parser("dpdy<coarse>a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -719,7 +719,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdy_MissingRightParen) {
-  auto p = parser("dpdy<coarse>(a");
+  auto* p = parser("dpdy<coarse>(a");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -727,7 +727,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdy_MissingIdentifier) {
-  auto p = parser("dpdy<coarse>()");
+  auto* p = parser("dpdy<coarse>()");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -735,7 +735,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Dpdy_InvalidIdentifeir) {
-  auto p = parser("dpdy<coarse>(12345)");
+  auto* p = parser("dpdy<coarse>(12345)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -743,43 +743,43 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Fwidth_NoModifier) {
-  auto p = parser("fwidth(a)");
+  auto* p = parser("fwidth(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryDerivative());
 
-  auto deriv = e->AsUnaryDerivative();
+  auto* deriv = e->AsUnaryDerivative();
   EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kFwidth);
   EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kNone);
 
   ASSERT_NE(deriv->param(), nullptr);
   ASSERT_TRUE(deriv->param()->IsIdentifier());
-  auto ident = deriv->param()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = deriv->param()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Fwidth_WithModifier) {
-  auto p = parser("fwidth<coarse>(a)");
+  auto* p = parser("fwidth<coarse>(a)");
   auto e = p->unary_expression();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnaryDerivative());
 
-  auto deriv = e->AsUnaryDerivative();
+  auto* deriv = e->AsUnaryDerivative();
   EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kFwidth);
   EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kCoarse);
 
   ASSERT_NE(deriv->param(), nullptr);
   ASSERT_TRUE(deriv->param()->IsIdentifier());
-  auto ident = deriv->param()->AsIdentifier();
-  ASSERT_EQ(ident->name().size(), 1);
+  auto* ident = deriv->param()->AsIdentifier();
+  ASSERT_EQ(ident->name().size(), 1u);
   EXPECT_EQ(ident->name()[0], "a");
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Fwidth_MissingLessThan) {
-  auto p = parser("fwidth coarse>(a)");
+  auto* p = parser("fwidth coarse>(a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -787,7 +787,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Fwidth_InvalidModifier) {
-  auto p = parser("fwidth<invalid>(a)");
+  auto* p = parser("fwidth<invalid>(a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -795,7 +795,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Fwidth_EmptyModifer) {
-  auto p = parser("fwidth coarse>(a)");
+  auto* p = parser("fwidth coarse>(a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -803,7 +803,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Fwidth_MissingGreaterThan) {
-  auto p = parser("fwidth<coarse (a)");
+  auto* p = parser("fwidth<coarse (a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -811,7 +811,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Fwidth_MisisngLeftParen) {
-  auto p = parser("fwidth<coarse>a)");
+  auto* p = parser("fwidth<coarse>a)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -819,7 +819,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Fwidth_MissingRightParen) {
-  auto p = parser("fwidth<coarse>(a");
+  auto* p = parser("fwidth<coarse>(a");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -827,7 +827,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Fwidth_MissingIdentifier) {
-  auto p = parser("fwidth<coarse>()");
+  auto* p = parser("fwidth<coarse>()");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -835,7 +835,7 @@
 }
 
 TEST_F(ParserImplTest, UnaryExpression_Fwidht_InvalidIdentifeir) {
-  auto p = parser("fwidth<coarse>(12345)");
+  auto* p = parser("fwidth<coarse>(12345)");
   auto e = p->unary_expression();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_unless_stmt_test.cc b/src/reader/wgsl/parser_impl_unless_stmt_test.cc
index 25cb4ef..4557c7c 100644
--- a/src/reader/wgsl/parser_impl_unless_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_unless_stmt_test.cc
@@ -22,19 +22,19 @@
 namespace {
 
 TEST_F(ParserImplTest, UnlessStmt) {
-  auto p = parser("unless (a) { kill; }");
+  auto* p = parser("unless (a) { kill; }");
   auto e = p->unless_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
   ASSERT_TRUE(e->IsUnless());
   ASSERT_NE(e->condition(), nullptr);
   EXPECT_TRUE(e->condition()->IsIdentifier());
-  ASSERT_EQ(e->body().size(), 1);
+  ASSERT_EQ(e->body().size(), 1u);
   EXPECT_TRUE(e->body()[0]->IsKill());
 }
 
 TEST_F(ParserImplTest, UnlessStmt_InvalidCondition) {
-  auto p = parser("unless(if(a){}) {}");
+  auto* p = parser("unless(if(a){}) {}");
   auto e = p->unless_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -42,7 +42,7 @@
 }
 
 TEST_F(ParserImplTest, UnlessStmt_EmptyCondition) {
-  auto p = parser("unless() {}");
+  auto* p = parser("unless() {}");
   auto e = p->unless_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -50,7 +50,7 @@
 }
 
 TEST_F(ParserImplTest, UnlessStmt_InvalidBody) {
-  auto p = parser("unless(a + 2 - 5 == true) { kill }");
+  auto* p = parser("unless(a + 2 - 5 == true) { kill }");
   auto e = p->unless_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_variable_decl_test.cc b/src/reader/wgsl/parser_impl_variable_decl_test.cc
index a4ca585..05519c7 100644
--- a/src/reader/wgsl/parser_impl_variable_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_decl_test.cc
@@ -23,19 +23,19 @@
 namespace {
 
 TEST_F(ParserImplTest, VariableDecl_Parses) {
-  auto p = parser("var my_var : f32");
+  auto* p = parser("var my_var : f32");
   auto var = p->variable_decl();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(var, nullptr);
   ASSERT_EQ(var->name(), "my_var");
   ASSERT_NE(var->type(), nullptr);
-  ASSERT_EQ(var->source().line, 1);
-  ASSERT_EQ(var->source().column, 1);
+  ASSERT_EQ(var->source().line, 1u);
+  ASSERT_EQ(var->source().column, 1u);
   ASSERT_TRUE(var->type()->IsF32());
 }
 
 TEST_F(ParserImplTest, VariableDecl_MissingVar) {
-  auto p = parser("my_var : f32");
+  auto* p = parser("my_var : f32");
   auto v = p->variable_decl();
   ASSERT_EQ(v, nullptr);
   ASSERT_FALSE(p->has_error());
@@ -45,7 +45,7 @@
 }
 
 TEST_F(ParserImplTest, VariableDecl_InvalidIdentDecl) {
-  auto p = parser("var my_var f32");
+  auto* p = parser("var my_var f32");
   auto v = p->variable_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(v, nullptr);
@@ -53,7 +53,7 @@
 }
 
 TEST_F(ParserImplTest, VariableDecl_WithStorageClass) {
-  auto p = parser("var<private> my_var : f32");
+  auto* p = parser("var<private> my_var : f32");
   auto v = p->variable_decl();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(v, nullptr);
@@ -63,7 +63,7 @@
 }
 
 TEST_F(ParserImplTest, VariableDecl_InvalidStorageClass) {
-  auto p = parser("var<unknown> my_var : f32");
+  auto* p = parser("var<unknown> my_var : f32");
   auto v = p->variable_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(v, nullptr);
diff --git a/src/reader/wgsl/parser_impl_variable_decoration_list_test.cc b/src/reader/wgsl/parser_impl_variable_decoration_list_test.cc
index 8552e7d..a93e21d 100644
--- a/src/reader/wgsl/parser_impl_variable_decoration_list_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_decoration_list_test.cc
@@ -24,53 +24,53 @@
 namespace {
 
 TEST_F(ParserImplTest, VariableDecorationList_Parses) {
-  auto p = parser(R"([[location 4, builtin position]])");
+  auto* p = parser(R"([[location 4, builtin position]])");
   auto decos = p->variable_decoration_list();
   ASSERT_FALSE(p->has_error());
-  ASSERT_EQ(decos.size(), 2);
+  ASSERT_EQ(decos.size(), 2u);
   ASSERT_TRUE(decos[0]->IsLocation());
-  EXPECT_EQ(decos[0]->AsLocation()->value(), 4);
+  EXPECT_EQ(decos[0]->AsLocation()->value(), 4u);
   ASSERT_TRUE(decos[1]->IsBuiltin());
   EXPECT_EQ(decos[1]->AsBuiltin()->value(), ast::Builtin::kPosition);
 }
 
 TEST_F(ParserImplTest, VariableDecorationList_Empty) {
-  auto p = parser(R"([[]])");
+  auto* p = parser(R"([[]])");
   auto decos = p->variable_decoration_list();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:3: empty variable decoration list");
 }
 
 TEST_F(ParserImplTest, VariableDecorationList_Invalid) {
-  auto p = parser(R"([[invalid]])");
+  auto* p = parser(R"([[invalid]])");
   auto decos = p->variable_decoration_list();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:3: missing variable decoration for decoration list");
 }
 
 TEST_F(ParserImplTest, VariableDecorationList_ExtraComma) {
-  auto p = parser(R"([[builtin position, ]])");
+  auto* p = parser(R"([[builtin position, ]])");
   auto decos = p->variable_decoration_list();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:21: missing variable decoration after comma");
 }
 
 TEST_F(ParserImplTest, VariableDecorationList_MissingComma) {
-  auto p = parser(R"([[binding 4 location 5]])");
+  auto* p = parser(R"([[binding 4 location 5]])");
   auto decos = p->variable_decoration_list();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:13: missing comma in variable decoration list");
 }
 
 TEST_F(ParserImplTest, VariableDecorationList_BadDecoration) {
-  auto p = parser(R"([[location bad]])");
+  auto* p = parser(R"([[location bad]])");
   auto decos = p->variable_decoration_list();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:12: invalid value for location decoration");
 }
 
 TEST_F(ParserImplTest, VariableDecorationList_InvalidBuiltin) {
-  auto p = parser("[[builtin invalid]]");
+  auto* p = parser("[[builtin invalid]]");
   auto decos = p->variable_decoration_list();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:11: invalid value for builtin decoration");
diff --git a/src/reader/wgsl/parser_impl_variable_decoration_test.cc b/src/reader/wgsl/parser_impl_variable_decoration_test.cc
index 2a6a766..8c30a26 100644
--- a/src/reader/wgsl/parser_impl_variable_decoration_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_decoration_test.cc
@@ -26,18 +26,18 @@
 namespace {
 
 TEST_F(ParserImplTest, VariableDecoration_Location) {
-  auto p = parser("location 4");
+  auto* p = parser("location 4");
   auto deco = p->variable_decoration();
   ASSERT_NE(deco, nullptr);
   ASSERT_FALSE(p->has_error());
   ASSERT_TRUE(deco->IsLocation());
 
-  auto loc = deco->AsLocation();
-  EXPECT_EQ(loc->value(), 4);
+  auto* loc = deco->AsLocation();
+  EXPECT_EQ(loc->value(), 4u);
 }
 
 TEST_F(ParserImplTest, VariableDecoration_Location_MissingValue) {
-  auto p = parser("location");
+  auto* p = parser("location");
   auto deco = p->variable_decoration();
   ASSERT_EQ(deco, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -45,7 +45,7 @@
 }
 
 TEST_F(ParserImplTest, VariableDecoration_Location_MissingInvalid) {
-  auto p = parser("location nan");
+  auto* p = parser("location nan");
   auto deco = p->variable_decoration();
   ASSERT_EQ(deco, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -53,18 +53,18 @@
 }
 
 TEST_F(ParserImplTest, VariableDecoration_Builtin) {
-  auto p = parser("builtin frag_depth");
+  auto* p = parser("builtin frag_depth");
   auto deco = p->variable_decoration();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(deco, nullptr);
   ASSERT_TRUE(deco->IsBuiltin());
 
-  auto builtin = deco->AsBuiltin();
+  auto* builtin = deco->AsBuiltin();
   EXPECT_EQ(builtin->value(), ast::Builtin::kFragDepth);
 }
 
 TEST_F(ParserImplTest, VariableDecoration_Builtin_MissingValue) {
-  auto p = parser("builtin");
+  auto* p = parser("builtin");
   auto deco = p->variable_decoration();
   ASSERT_EQ(deco, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -72,7 +72,7 @@
 }
 
 TEST_F(ParserImplTest, VariableDecoration_Builtin_MissingInvalid) {
-  auto p = parser("builtin 3");
+  auto* p = parser("builtin 3");
   auto deco = p->variable_decoration();
   ASSERT_EQ(deco, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -80,18 +80,18 @@
 }
 
 TEST_F(ParserImplTest, VariableDecoration_Binding) {
-  auto p = parser("binding 4");
+  auto* p = parser("binding 4");
   auto deco = p->variable_decoration();
   ASSERT_NE(deco, nullptr);
   ASSERT_FALSE(p->has_error());
   ASSERT_TRUE(deco->IsBinding());
 
-  auto binding = deco->AsBinding();
-  EXPECT_EQ(binding->value(), 4);
+  auto* binding = deco->AsBinding();
+  EXPECT_EQ(binding->value(), 4u);
 }
 
 TEST_F(ParserImplTest, VariableDecoration_Binding_MissingValue) {
-  auto p = parser("binding");
+  auto* p = parser("binding");
   auto deco = p->variable_decoration();
   ASSERT_EQ(deco, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -99,7 +99,7 @@
 }
 
 TEST_F(ParserImplTest, VariableDecoration_Binding_MissingInvalid) {
-  auto p = parser("binding nan");
+  auto* p = parser("binding nan");
   auto deco = p->variable_decoration();
   ASSERT_EQ(deco, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -107,18 +107,18 @@
 }
 
 TEST_F(ParserImplTest, VariableDecoration_set) {
-  auto p = parser("set 4");
+  auto* p = parser("set 4");
   auto deco = p->variable_decoration();
   ASSERT_FALSE(p->has_error());
   ASSERT_NE(deco.get(), nullptr);
   ASSERT_TRUE(deco->IsSet());
 
-  auto set = deco->AsSet();
-  EXPECT_EQ(set->value(), 4);
+  auto* set = deco->AsSet();
+  EXPECT_EQ(set->value(), 4u);
 }
 
 TEST_F(ParserImplTest, VariableDecoration_Set_MissingValue) {
-  auto p = parser("set");
+  auto* p = parser("set");
   auto deco = p->variable_decoration();
   ASSERT_EQ(deco, nullptr);
   ASSERT_TRUE(p->has_error());
@@ -126,7 +126,7 @@
 }
 
 TEST_F(ParserImplTest, VariableDecoration_Set_MissingInvalid) {
-  auto p = parser("set nan");
+  auto* p = parser("set nan");
   auto deco = p->variable_decoration();
   ASSERT_EQ(deco, nullptr);
   ASSERT_TRUE(p->has_error());
diff --git a/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc b/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc
index a9f0166..3a8b29f 100644
--- a/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_ident_decl_test.cc
@@ -22,7 +22,7 @@
 namespace {
 
 TEST_F(ParserImplTest, VariableIdentDecl_Parses) {
-  auto p = parser("my_var : f32");
+  auto* p = parser("my_var : f32");
   std::string name;
   ast::type::Type* type;
   std::tie(name, type) = p->variable_ident_decl();
@@ -33,7 +33,7 @@
 }
 
 TEST_F(ParserImplTest, VariableIdentDecl_MissingIdent) {
-  auto p = parser(": f32");
+  auto* p = parser(": f32");
   std::string name;
   ast::type::Type* type;
   std::tie(name, type) = p->variable_ident_decl();
@@ -46,21 +46,21 @@
 }
 
 TEST_F(ParserImplTest, VariableIdentDecl_MissingColon) {
-  auto p = parser("my_var f32");
+  auto* p = parser("my_var f32");
   auto r = p->variable_ident_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:8: missing : for identifier declaration");
 }
 
 TEST_F(ParserImplTest, VariableIdentDecl_MissingType) {
-  auto p = parser("my_var :");
+  auto* p = parser("my_var :");
   auto r = p->variable_ident_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:9: invalid type for identifier declaration");
 }
 
 TEST_F(ParserImplTest, VariableIdentDecl_InvalidIdent) {
-  auto p = parser("123 : f32");
+  auto* p = parser("123 : f32");
   std::string name;
   ast::type::Type* type;
   std::tie(name, type) = p->variable_ident_decl();
@@ -73,7 +73,7 @@
 }
 
 TEST_F(ParserImplTest, VariableIdentDecl_InvalidType) {
-  auto p = parser("my_var : invalid");
+  auto* p = parser("my_var : invalid");
   auto r = p->variable_ident_decl();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(p->error(), "1:10: unknown type alias 'invalid'");
diff --git a/src/reader/wgsl/parser_impl_variable_stmt_test.cc b/src/reader/wgsl/parser_impl_variable_stmt_test.cc
index 78b7685..891d572 100644
--- a/src/reader/wgsl/parser_impl_variable_stmt_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_stmt_test.cc
@@ -24,7 +24,7 @@
 namespace {
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl) {
-  auto p = parser("var a : i32;");
+  auto* p = parser("var a : i32;");
   auto e = p->variable_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -36,7 +36,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl_WithInit) {
-  auto p = parser("var a : i32 = 1;");
+  auto* p = parser("var a : i32 = 1;");
   auto e = p->variable_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -49,7 +49,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl_Invalid) {
-  auto p = parser("var a : invalid;");
+  auto* p = parser("var a : invalid;");
   auto e = p->variable_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -57,7 +57,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStmt_VariableDecl_ConstructorInvalid) {
-  auto p = parser("var a : i32 = if(a) {}");
+  auto* p = parser("var a : i32 = if(a) {}");
   auto e = p->variable_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -65,7 +65,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStmt_Const) {
-  auto p = parser("const a : i32 = 1");
+  auto* p = parser("const a : i32 = 1");
   auto e = p->variable_stmt();
   ASSERT_FALSE(p->has_error()) << p->error();
   ASSERT_NE(e, nullptr);
@@ -73,7 +73,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStmt_Const_InvalidVarIdent) {
-  auto p = parser("const a : invalid = 1");
+  auto* p = parser("const a : invalid = 1");
   auto e = p->variable_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -81,7 +81,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStmt_Const_MissingEqual) {
-  auto p = parser("const a : i32 1");
+  auto* p = parser("const a : i32 1");
   auto e = p->variable_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -89,7 +89,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStmt_Const_MissingConstructor) {
-  auto p = parser("const a : i32 =");
+  auto* p = parser("const a : i32 =");
   auto e = p->variable_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
@@ -97,7 +97,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStmt_Const_InvalidConstructor) {
-  auto p = parser("const a : i32 = if (a) {}");
+  auto* p = parser("const a : i32 = if (a) {}");
   auto e = p->variable_stmt();
   ASSERT_TRUE(p->has_error());
   ASSERT_EQ(e, nullptr);
diff --git a/src/reader/wgsl/parser_impl_variable_storage_decoration_test.cc b/src/reader/wgsl/parser_impl_variable_storage_decoration_test.cc
index 27a82f1..a15d211 100644
--- a/src/reader/wgsl/parser_impl_variable_storage_decoration_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_storage_decoration_test.cc
@@ -36,9 +36,9 @@
   VariableStorageTest() = default;
   ~VariableStorageTest() = default;
 
-  void SetUp() { ctx_.Reset(); }
+  void SetUp() override { ctx_.Reset(); }
 
-  void TearDown() { impl_ = nullptr; }
+  void TearDown() override { impl_ = nullptr; }
 
   ParserImpl* parser(const std::string& str) {
     impl_ = std::make_unique<ParserImpl>(&ctx_, str);
@@ -52,7 +52,7 @@
 
 TEST_P(VariableStorageTest, Parses) {
   auto params = GetParam();
-  auto p = parser(std::string("<") + params.input + ">");
+  auto* p = parser(std::string("<") + params.input + ">");
 
   auto sc = p->variable_storage_decoration();
   ASSERT_FALSE(p->has_error());
@@ -79,7 +79,7 @@
         VariableStorageData{"function", ast::StorageClass::kFunction}));
 
 TEST_F(ParserImplTest, VariableStorageDecoration_NoMatch) {
-  auto p = parser("<not-a-storage-class>");
+  auto* p = parser("<not-a-storage-class>");
   auto sc = p->variable_storage_decoration();
   ASSERT_EQ(sc, ast::StorageClass::kNone);
   ASSERT_TRUE(p->has_error());
@@ -87,7 +87,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStorageDecoration_Empty) {
-  auto p = parser("<>");
+  auto* p = parser("<>");
   auto sc = p->variable_storage_decoration();
   ASSERT_EQ(sc, ast::StorageClass::kNone);
   ASSERT_TRUE(p->has_error());
@@ -95,7 +95,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStorageDecoration_MissingLessThan) {
-  auto p = parser("in>");
+  auto* p = parser("in>");
   auto sc = p->variable_storage_decoration();
   ASSERT_EQ(sc, ast::StorageClass::kNone);
   ASSERT_FALSE(p->has_error());
@@ -105,7 +105,7 @@
 }
 
 TEST_F(ParserImplTest, VariableStorageDecoration_MissingGreaterThan) {
-  auto p = parser("<in");
+  auto* p = parser("<in");
   auto sc = p->variable_storage_decoration();
   ASSERT_EQ(sc, ast::StorageClass::kNone);
   ASSERT_TRUE(p->has_error());
diff --git a/src/reader/wgsl/parser_test.cc b/src/reader/wgsl/parser_test.cc
index 081deba..178794a 100644
--- a/src/reader/wgsl/parser_test.cc
+++ b/src/reader/wgsl/parser_test.cc
@@ -46,10 +46,10 @@
   ASSERT_TRUE(p.Parse()) << p.error();
 
   auto m = p.module();
-  ASSERT_EQ(1, m.imports().size());
-  ASSERT_EQ(1, m.entry_points().size());
-  ASSERT_EQ(1, m.functions().size());
-  ASSERT_EQ(1, m.global_variables().size());
+  ASSERT_EQ(1u, m.imports().size());
+  ASSERT_EQ(1u, m.entry_points().size());
+  ASSERT_EQ(1u, m.functions().size());
+  ASSERT_EQ(1u, m.global_variables().size());
 }
 
 TEST_F(ParserTest, HandlesError) {
diff --git a/src/reader/wgsl/token_test.cc b/src/reader/wgsl/token_test.cc
index c6dc9f5..4daa091 100644
--- a/src/reader/wgsl/token_test.cc
+++ b/src/reader/wgsl/token_test.cc
@@ -58,7 +58,7 @@
 
 TEST_F(TokenTest, ReturnsU32) {
   Token t2(Source{1, 1}, 2345u);
-  EXPECT_EQ(t2.to_u32(), 2345);
+  EXPECT_EQ(t2.to_u32(), 2345u);
 }
 
 TEST_F(TokenTest, ReturnsMaxU32) {
@@ -68,8 +68,8 @@
 
 TEST_F(TokenTest, Source) {
   Token t(Token::Type::kUintLiteral, Source{3, 9});
-  EXPECT_EQ(t.line(), 3);
-  EXPECT_EQ(t.column(), 9);
+  EXPECT_EQ(t.line(), 3u);
+  EXPECT_EQ(t.column(), 9u);
 }
 
 }  // namespace
diff --git a/src/scope_stack_test.cc b/src/scope_stack_test.cc
index 2f31292..f1f5551 100644
--- a/src/scope_stack_test.cc
+++ b/src/scope_stack_test.cc
@@ -27,7 +27,7 @@
 
   uint32_t val = 0;
   EXPECT_TRUE(s.get("var", &val));
-  EXPECT_EQ(val, 5);
+  EXPECT_EQ(val, 5u);
 }
 
 TEST_F(ScopeStackTest, Global_SetWithPointer) {
@@ -49,7 +49,7 @@
 
   uint32_t val = 0;
   EXPECT_TRUE(s.get("var", &val));
-  EXPECT_EQ(val, 5);
+  EXPECT_EQ(val, 5u);
 }
 
 TEST_F(ScopeStackTest, Scope) {
@@ -59,14 +59,14 @@
 
   uint32_t val = 0;
   EXPECT_TRUE(s.get("var", &val));
-  EXPECT_EQ(val, 5);
+  EXPECT_EQ(val, 5u);
 }
 
 TEST_F(ScopeStackTest, Get_MissingName) {
   ScopeStack<uint32_t> s;
   uint32_t ret = 0;
   EXPECT_FALSE(s.get("val", &ret));
-  EXPECT_EQ(ret, 0);
+  EXPECT_EQ(ret, 0u);
 }
 
 TEST_F(ScopeStackTest, Has) {
@@ -87,7 +87,7 @@
 
   uint32_t ret;
   EXPECT_TRUE(s.get("var", &ret));
-  EXPECT_EQ(ret, 5);
+  EXPECT_EQ(ret, 5u);
 }
 
 }  // namespace
diff --git a/src/type_determiner_test.cc b/src/type_determiner_test.cc
index 875842a..b722511 100644
--- a/src/type_determiner_test.cc
+++ b/src/type_determiner_test.cc
@@ -1,4 +1,3 @@
-
 // Copyright 2020 The Tint Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -71,7 +70,7 @@
 
 class TypeDeterminerTest : public testing::Test {
  public:
-  void SetUp() { td_ = std::make_unique<TypeDeterminer>(&ctx_); }
+  void SetUp() override { td_ = std::make_unique<TypeDeterminer>(&ctx_); }
 
   TypeDeterminer* td() const { return td_.get(); }
 
@@ -103,11 +102,11 @@
 
   auto lhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto lhs_ptr = lhs.get();
+  auto* lhs_ptr = lhs.get();
 
   auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.3f));
-  auto rhs_ptr = rhs.get();
+  auto* rhs_ptr = rhs.get();
 
   ast::AssignmentStatement assign(std::move(lhs), std::move(rhs));
 
@@ -124,7 +123,7 @@
 
   auto cond = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto cond_ptr = cond.get();
+  auto* cond_ptr = cond.get();
 
   ast::BreakStatement brk(ast::StatementCondition::kIf, std::move(cond));
 
@@ -145,11 +144,11 @@
 
   auto lhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto lhs_ptr = lhs.get();
+  auto* lhs_ptr = lhs.get();
 
   auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.3f));
-  auto rhs_ptr = rhs.get();
+  auto* rhs_ptr = rhs.get();
 
   ast::StatementList body;
   body.push_back(std::make_unique<ast::AssignmentStatement>(std::move(lhs),
@@ -170,7 +169,7 @@
 
   auto cond = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto cond_ptr = cond.get();
+  auto* cond_ptr = cond.get();
 
   ast::ContinueStatement stmt(ast::StatementCondition::kIf, std::move(cond));
 
@@ -191,11 +190,11 @@
 
   auto lhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto lhs_ptr = lhs.get();
+  auto* lhs_ptr = lhs.get();
 
   auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.3f));
-  auto rhs_ptr = rhs.get();
+  auto* rhs_ptr = rhs.get();
 
   ast::StatementList body;
   body.push_back(std::make_unique<ast::AssignmentStatement>(std::move(lhs),
@@ -220,11 +219,11 @@
 
   auto else_lhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto else_lhs_ptr = else_lhs.get();
+  auto* else_lhs_ptr = else_lhs.get();
 
   auto else_rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.3f));
-  auto else_rhs_ptr = else_rhs.get();
+  auto* else_rhs_ptr = else_rhs.get();
 
   ast::StatementList else_body;
   else_body.push_back(std::make_unique<ast::AssignmentStatement>(
@@ -240,11 +239,11 @@
 
   auto lhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto lhs_ptr = lhs.get();
+  auto* lhs_ptr = lhs.get();
 
   auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.3f));
-  auto rhs_ptr = rhs.get();
+  auto* rhs_ptr = rhs.get();
 
   ast::StatementList body;
   body.push_back(std::make_unique<ast::AssignmentStatement>(std::move(lhs),
@@ -274,11 +273,11 @@
 
   auto body_lhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto body_lhs_ptr = body_lhs.get();
+  auto* body_lhs_ptr = body_lhs.get();
 
   auto body_rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.3f));
-  auto body_rhs_ptr = body_rhs.get();
+  auto* body_rhs_ptr = body_rhs.get();
 
   ast::StatementList body;
   body.push_back(std::make_unique<ast::AssignmentStatement>(
@@ -286,11 +285,11 @@
 
   auto continuing_lhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto continuing_lhs_ptr = continuing_lhs.get();
+  auto* continuing_lhs_ptr = continuing_lhs.get();
 
   auto continuing_rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.3f));
-  auto continuing_rhs_ptr = continuing_rhs.get();
+  auto* continuing_rhs_ptr = continuing_rhs.get();
 
   ast::StatementList continuing;
   continuing.push_back(std::make_unique<ast::AssignmentStatement>(
@@ -314,7 +313,7 @@
 
   auto cond = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto cond_ptr = cond.get();
+  auto* cond_ptr = cond.get();
 
   ast::ReturnStatement ret(std::move(cond));
 
@@ -335,11 +334,11 @@
 
   auto lhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto lhs_ptr = lhs.get();
+  auto* lhs_ptr = lhs.get();
 
   auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.3f));
-  auto rhs_ptr = rhs.get();
+  auto* rhs_ptr = rhs.get();
 
   ast::StatementList body;
   body.push_back(std::make_unique<ast::AssignmentStatement>(std::move(lhs),
@@ -369,11 +368,11 @@
 
   auto lhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2));
-  auto lhs_ptr = lhs.get();
+  auto* lhs_ptr = lhs.get();
 
   auto rhs = std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::FloatLiteral>(&f32, 2.3f));
-  auto rhs_ptr = rhs.get();
+  auto* rhs_ptr = rhs.get();
 
   ast::StatementList body;
   body.push_back(std::make_unique<ast::AssignmentStatement>(std::move(lhs),
@@ -399,7 +398,7 @@
       std::make_unique<ast::Variable>("my_var", ast::StorageClass::kNone, &i32);
   var->set_constructor(std::make_unique<ast::ScalarConstructorExpression>(
       std::make_unique<ast::IntLiteral>(&i32, 2)));
-  auto init_ptr = var->constructor();
+  auto* init_ptr = var->constructor();
 
   ast::VariableDeclStatement decl(std::move(var));
 
@@ -460,7 +459,7 @@
   EXPECT_TRUE(td()->DetermineResultType(&acc));
   ASSERT_NE(acc.result_type(), nullptr);
   ASSERT_TRUE(acc.result_type()->IsVector());
-  EXPECT_EQ(acc.result_type()->AsVector()->size(), 3);
+  EXPECT_EQ(acc.result_type()->AsVector()->size(), 3u);
 }
 
 TEST_F(TypeDeterminerTest, Expr_ArrayAccessor_Matrix_BothDimensions) {
@@ -584,7 +583,7 @@
   ASSERT_NE(tc.result_type(), nullptr);
   ASSERT_TRUE(tc.result_type()->IsVector());
   EXPECT_TRUE(tc.result_type()->AsVector()->type()->IsF32());
-  EXPECT_EQ(tc.result_type()->AsVector()->size(), 3);
+  EXPECT_EQ(tc.result_type()->AsVector()->size(), 3u);
 }
 
 TEST_F(TypeDeterminerTest, Expr_Identifier_GlobalVariable) {
@@ -608,7 +607,7 @@
   ast::type::F32Type f32;
 
   auto my_var = std::make_unique<ast::IdentifierExpression>("my_var");
-  auto my_var_ptr = my_var.get();
+  auto* my_var_ptr = my_var.get();
 
   ast::StatementList body;
   body.push_back(std::make_unique<ast::VariableDeclStatement>(
@@ -700,7 +699,7 @@
   ASSERT_NE(mem.result_type(), nullptr);
   ASSERT_TRUE(mem.result_type()->IsVector());
   EXPECT_TRUE(mem.result_type()->AsVector()->type()->IsF32());
-  EXPECT_EQ(mem.result_type()->AsVector()->size(), 2);
+  EXPECT_EQ(mem.result_type()->AsVector()->size(), 2u);
 }
 
 TEST_F(TypeDeterminerTest, Expr_MultiLevel) {
@@ -781,7 +780,7 @@
   ASSERT_NE(mem.result_type(), nullptr);
   ASSERT_TRUE(mem.result_type()->IsVector());
   EXPECT_TRUE(mem.result_type()->AsVector()->type()->IsF32());
-  EXPECT_EQ(mem.result_type()->AsVector()->size(), 2);
+  EXPECT_EQ(mem.result_type()->AsVector()->size(), 2u);
 }
 
 using Expr_Binary_BitwiseTest = testing::TestWithParam<ast::BinaryOp>;
@@ -837,7 +836,7 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsVector());
   EXPECT_TRUE(expr.result_type()->AsVector()->type()->IsI32());
-  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3);
+  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3u);
 }
 INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
                          Expr_Binary_BitwiseTest,
@@ -905,7 +904,7 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsVector());
   EXPECT_TRUE(expr.result_type()->AsVector()->type()->IsBool());
-  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3);
+  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3u);
 }
 INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
                          Expr_Binary_LogicalTest,
@@ -965,7 +964,7 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsVector());
   EXPECT_TRUE(expr.result_type()->AsVector()->type()->IsBool());
-  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3);
+  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3u);
 }
 INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
                          Expr_Binary_CompareTest,
@@ -1029,7 +1028,7 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsVector());
   EXPECT_TRUE(expr.result_type()->AsVector()->type()->IsF32());
-  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3);
+  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3u);
 }
 
 TEST_F(TypeDeterminerTest, Expr_Binary_Multiply_Scalar_Vector) {
@@ -1060,7 +1059,7 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsVector());
   EXPECT_TRUE(expr.result_type()->AsVector()->type()->IsF32());
-  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3);
+  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3u);
 }
 
 TEST_F(TypeDeterminerTest, Expr_Binary_Multiply_Vector_Vector) {
@@ -1088,7 +1087,7 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsVector());
   EXPECT_TRUE(expr.result_type()->AsVector()->type()->IsF32());
-  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3);
+  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3u);
 }
 
 TEST_F(TypeDeterminerTest, Expr_Binary_Multiply_Matrix_Scalar) {
@@ -1119,10 +1118,10 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsMatrix());
 
-  auto mat = expr.result_type()->AsMatrix();
+  auto* mat = expr.result_type()->AsMatrix();
   EXPECT_TRUE(mat->type()->IsF32());
-  EXPECT_EQ(mat->rows(), 3);
-  EXPECT_EQ(mat->columns(), 2);
+  EXPECT_EQ(mat->rows(), 3u);
+  EXPECT_EQ(mat->columns(), 2u);
 }
 
 TEST_F(TypeDeterminerTest, Expr_Binary_Multiply_Scalar_Matrix) {
@@ -1153,10 +1152,10 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsMatrix());
 
-  auto mat = expr.result_type()->AsMatrix();
+  auto* mat = expr.result_type()->AsMatrix();
   EXPECT_TRUE(mat->type()->IsF32());
-  EXPECT_EQ(mat->rows(), 3);
-  EXPECT_EQ(mat->columns(), 2);
+  EXPECT_EQ(mat->rows(), 3u);
+  EXPECT_EQ(mat->columns(), 2u);
 }
 
 TEST_F(TypeDeterminerTest, Expr_Binary_Multiply_Matrix_Vector) {
@@ -1188,7 +1187,7 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsVector());
   EXPECT_TRUE(expr.result_type()->AsVector()->type()->IsF32());
-  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3);
+  EXPECT_EQ(expr.result_type()->AsVector()->size(), 3u);
 }
 
 TEST_F(TypeDeterminerTest, Expr_Binary_Multiply_Vector_Matrix) {
@@ -1220,7 +1219,7 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsVector());
   EXPECT_TRUE(expr.result_type()->AsVector()->type()->IsF32());
-  EXPECT_EQ(expr.result_type()->AsVector()->size(), 2);
+  EXPECT_EQ(expr.result_type()->AsVector()->size(), 2u);
 }
 
 TEST_F(TypeDeterminerTest, Expr_Binary_Multiply_Matrix_Matrix) {
@@ -1252,10 +1251,10 @@
   ASSERT_NE(expr.result_type(), nullptr);
   ASSERT_TRUE(expr.result_type()->IsMatrix());
 
-  auto mat = expr.result_type()->AsMatrix();
+  auto* mat = expr.result_type()->AsMatrix();
   EXPECT_TRUE(mat->type()->IsF32());
-  EXPECT_EQ(mat->rows(), 4);
-  EXPECT_EQ(mat->columns(), 4);
+  EXPECT_EQ(mat->rows(), 4u);
+  EXPECT_EQ(mat->columns(), 4u);
 }
 
 using UnaryDerivativeExpressionTest =
@@ -1286,7 +1285,7 @@
   ASSERT_NE(der.result_type(), nullptr);
   ASSERT_TRUE(der.result_type()->IsVector());
   EXPECT_TRUE(der.result_type()->AsVector()->type()->IsF32());
-  EXPECT_EQ(der.result_type()->AsVector()->size(), 4);
+  EXPECT_EQ(der.result_type()->AsVector()->size(), 4u);
 }
 INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
                          UnaryDerivativeExpressionTest,
@@ -1355,7 +1354,7 @@
   ASSERT_NE(exp.result_type(), nullptr);
   ASSERT_TRUE(exp.result_type()->IsVector());
   EXPECT_TRUE(exp.result_type()->AsVector()->type()->IsBool());
-  EXPECT_EQ(exp.result_type()->AsVector()->size(), 3);
+  EXPECT_EQ(exp.result_type()->AsVector()->size(), 3u);
 }
 TEST_P(UnaryMethodExpressionVecTest, Expr_UnaryMethod_Vec) {
   auto op = GetParam();
@@ -1447,10 +1446,10 @@
   EXPECT_TRUE(td.DetermineResultType(&exp));
   ASSERT_NE(exp.result_type(), nullptr);
   ASSERT_TRUE(exp.result_type()->IsMatrix());
-  auto mat = exp.result_type()->AsMatrix();
+  auto* mat = exp.result_type()->AsMatrix();
   EXPECT_TRUE(mat->type()->IsF32());
-  EXPECT_EQ(mat->rows(), 3);
-  EXPECT_EQ(mat->columns(), 2);
+  EXPECT_EQ(mat->rows(), 3u);
+  EXPECT_EQ(mat->columns(), 2u);
 }
 
 using UnaryOpExpressionTest = testing::TestWithParam<ast::UnaryOp>;
@@ -1479,7 +1478,7 @@
   ASSERT_NE(der.result_type(), nullptr);
   ASSERT_TRUE(der.result_type()->IsVector());
   EXPECT_TRUE(der.result_type()->AsVector()->type()->IsF32());
-  EXPECT_EQ(der.result_type()->AsVector()->size(), 4);
+  EXPECT_EQ(der.result_type()->AsVector()->size(), 4u);
 }
 INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
                          UnaryOpExpressionTest,
@@ -1491,7 +1490,7 @@
 
   auto var =
       std::make_unique<ast::Variable>("var", ast::StorageClass::kNone, &i32);
-  auto var_ptr = var.get();
+  auto* var_ptr = var.get();
   auto stmt = std::make_unique<ast::VariableDeclStatement>(std::move(var));
 
   auto func =
@@ -1513,7 +1512,7 @@
   auto var =
       std::make_unique<ast::Variable>("var", ast::StorageClass::kNone, &i32);
   var->set_is_const(true);
-  auto var_ptr = var.get();
+  auto* var_ptr = var.get();
   auto stmt = std::make_unique<ast::VariableDeclStatement>(std::move(var));
 
   auto func =
diff --git a/src/type_manager_test.cc b/src/type_manager_test.cc
index a0526d1..1628ffb 100644
--- a/src/type_manager_test.cc
+++ b/src/type_manager_test.cc
@@ -25,28 +25,28 @@
 
 TEST_F(TypeManagerTest, GetUnregistered) {
   TypeManager tm;
-  auto t = tm.Get(std::make_unique<ast::type::I32Type>());
+  auto* t = tm.Get(std::make_unique<ast::type::I32Type>());
   ASSERT_NE(t, nullptr);
   EXPECT_TRUE(t->IsI32());
 }
 
 TEST_F(TypeManagerTest, GetSameTypeReturnsSamePtr) {
   TypeManager tm;
-  auto t = tm.Get(std::make_unique<ast::type::I32Type>());
+  auto* t = tm.Get(std::make_unique<ast::type::I32Type>());
   ASSERT_NE(t, nullptr);
   EXPECT_TRUE(t->IsI32());
 
-  auto t2 = tm.Get(std::make_unique<ast::type::I32Type>());
+  auto* t2 = tm.Get(std::make_unique<ast::type::I32Type>());
   EXPECT_EQ(t, t2);
 }
 
 TEST_F(TypeManagerTest, GetDifferentTypeReturnsDifferentPtr) {
   TypeManager tm;
-  auto t = tm.Get(std::make_unique<ast::type::I32Type>());
+  auto* t = tm.Get(std::make_unique<ast::type::I32Type>());
   ASSERT_NE(t, nullptr);
   EXPECT_TRUE(t->IsI32());
 
-  auto t2 = tm.Get(std::make_unique<ast::type::U32Type>());
+  auto* t2 = tm.Get(std::make_unique<ast::type::U32Type>());
   ASSERT_NE(t2, nullptr);
   EXPECT_NE(t, t2);
   EXPECT_TRUE(t2->IsU32());
@@ -54,14 +54,14 @@
 
 TEST_F(TypeManagerTest, ResetClearsPreviousData) {
   TypeManager tm;
-  auto t = tm.Get(std::make_unique<ast::type::I32Type>());
+  auto* t = tm.Get(std::make_unique<ast::type::I32Type>());
   ASSERT_NE(t, nullptr);
 
   EXPECT_FALSE(tm.TypesForTesting().empty());
   tm.Reset();
   EXPECT_TRUE(tm.TypesForTesting().empty());
 
-  auto t2 = tm.Get(std::make_unique<ast::type::I32Type>());
+  auto* t2 = tm.Get(std::make_unique<ast::type::I32Type>());
   ASSERT_NE(t2, nullptr);
 }
 
diff --git a/src/writer/spirv/binary_writer_test.cc b/src/writer/spirv/binary_writer_test.cc
index 2a574c4..f3cf327 100644
--- a/src/writer/spirv/binary_writer_test.cc
+++ b/src/writer/spirv/binary_writer_test.cc
@@ -33,12 +33,12 @@
   bw.WriteHeader(5);
 
   auto res = bw.result();
-  ASSERT_EQ(res.size(), 5);
+  ASSERT_EQ(res.size(), 5u);
   EXPECT_EQ(res[0], spv::MagicNumber);
-  EXPECT_EQ(res[1], 0x00010300);  // SPIR-V 1.3
-  EXPECT_EQ(res[2], 0);           // Generator ID
-  EXPECT_EQ(res[3], 5);           // ID Bound
-  EXPECT_EQ(res[4], 0);           // Reserved
+  EXPECT_EQ(res[1], 0x00010300u);  // SPIR-V 1.3
+  EXPECT_EQ(res[2], 0u);           // Generator ID
+  EXPECT_EQ(res[3], 5u);           // ID Bound
+  EXPECT_EQ(res[4], 0u);           // Reserved
 }
 
 TEST_F(BinaryWriterTest, Float) {
@@ -48,7 +48,7 @@
   bw.WriteBuilder(b);
 
   auto res = bw.result();
-  ASSERT_EQ(res.size(), 2);
+  ASSERT_EQ(res.size(), 2u);
   float f;
   memcpy(&f, res.data() + 1, 4);
   EXPECT_EQ(f, 2.4f);
@@ -61,8 +61,8 @@
   bw.WriteBuilder(b);
 
   auto res = bw.result();
-  ASSERT_EQ(res.size(), 2);
-  EXPECT_EQ(res[1], 2);
+  ASSERT_EQ(res.size(), 2u);
+  EXPECT_EQ(res[1], 2u);
 }
 
 TEST_F(BinaryWriterTest, String) {
@@ -72,7 +72,7 @@
   bw.WriteBuilder(b);
 
   auto res = bw.result();
-  ASSERT_EQ(res.size(), 4);
+  ASSERT_EQ(res.size(), 4u);
 
   uint8_t* v = reinterpret_cast<uint8_t*>(res.data() + 1);
   EXPECT_EQ(v[0], 'm');
@@ -96,7 +96,7 @@
   bw.WriteBuilder(b);
 
   auto res = bw.result();
-  ASSERT_EQ(res.size(), 4);
+  ASSERT_EQ(res.size(), 4u);
 
   uint8_t* v = reinterpret_cast<uint8_t*>(res.data() + 1);
   EXPECT_EQ(v[0], 'm');
@@ -122,9 +122,9 @@
   bw.WriteInstruction(i2);
 
   auto res = bw.result();
-  ASSERT_EQ(res.size(), 4);
-  EXPECT_EQ(res[1], 2);
-  EXPECT_EQ(res[3], 4);
+  ASSERT_EQ(res.size(), 4u);
+  EXPECT_EQ(res[1], 2u);
+  EXPECT_EQ(res[3], 4u);
 }
 
 }  // namespace
diff --git a/src/writer/spirv/builder_binary_expression_test.cc b/src/writer/spirv/builder_binary_expression_test.cc
index fe18196..e356454 100644
--- a/src/writer/spirv/builder_binary_expression_test.cc
+++ b/src/writer/spirv/builder_binary_expression_test.cc
@@ -67,7 +67,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1
 %2 = OpConstant %1 3
 %3 = OpConstant %1 4
@@ -110,7 +110,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
 %1 = OpTypeVector %2 3
 %3 = OpConstant %2 1
@@ -155,7 +155,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0
 %2 = OpConstant %1 3
 %3 = OpConstant %1 4
@@ -198,7 +198,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 0
 %1 = OpTypeVector %2 3
 %3 = OpConstant %2 1
@@ -243,7 +243,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
 %2 = OpConstant %1 3.20000005
 %3 = OpConstant %1 4.5
@@ -287,7 +287,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
 %1 = OpTypeVector %2 3
 %3 = OpConstant %2 1
@@ -325,7 +325,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0
 %2 = OpConstant %1 3
 %3 = OpConstant %1 4
@@ -370,7 +370,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 0
 %1 = OpTypeVector %2 3
 %3 = OpConstant %2 1
@@ -412,7 +412,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1
 %2 = OpConstant %1 3
 %3 = OpConstant %1 4
@@ -457,7 +457,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
 %1 = OpTypeVector %2 3
 %3 = OpConstant %2 1
@@ -499,7 +499,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 4u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
 %2 = OpConstant %1 3.20000005
 %3 = OpConstant %1 4.5
@@ -544,7 +544,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
 %1 = OpTypeVector %2 3
 %3 = OpConstant %2 1
@@ -594,7 +594,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
 %1 = OpTypeVector %2 3
 %3 = OpConstant %2 1
@@ -632,7 +632,7 @@
   Builder b;
   b.push_function(Function{});
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 5u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
 %2 = OpConstant %1 1
 %3 = OpTypeVector %1 3
@@ -665,7 +665,7 @@
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 8) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 8u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeFloat 32
 %4 = OpTypeVector %5 3
 %3 = OpTypeMatrix %4 3
@@ -702,7 +702,7 @@
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 8) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 8u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeFloat 32
 %4 = OpTypeVector %5 3
 %3 = OpTypeMatrix %4 3
@@ -748,7 +748,7 @@
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 9) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 9u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeFloat 32
 %4 = OpTypeVector %5 3
 %3 = OpTypeMatrix %4 3
@@ -796,7 +796,7 @@
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 9) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 9u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeFloat 32
 %4 = OpTypeVector %5 3
 %3 = OpTypeMatrix %4 3
@@ -834,7 +834,7 @@
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(var.get())) << b.error();
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 8) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 8u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%5 = OpTypeFloat 32
 %4 = OpTypeVector %5 3
 %3 = OpTypeMatrix %4 3
diff --git a/src/writer/spirv/builder_constructor_expression_test.cc b/src/writer/spirv/builder_constructor_expression_test.cc
index 49cb27d..5e8f462 100644
--- a/src/writer/spirv/builder_constructor_expression_test.cc
+++ b/src/writer/spirv/builder_constructor_expression_test.cc
@@ -39,7 +39,7 @@
   ast::ScalarConstructorExpression c(std::move(fl));
 
   Builder b;
-  EXPECT_EQ(b.GenerateConstructorExpression(&c, true), 2);
+  EXPECT_EQ(b.GenerateConstructorExpression(&c, true), 2u);
   ASSERT_FALSE(b.has_error()) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
@@ -62,7 +62,7 @@
   ast::TypeConstructorExpression t(&vec, std::move(vals));
 
   Builder b;
-  EXPECT_EQ(b.GenerateConstructorExpression(&t, true), 5);
+  EXPECT_EQ(b.GenerateConstructorExpression(&t, true), 5u);
   ASSERT_FALSE(b.has_error()) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
@@ -88,8 +88,8 @@
   ast::TypeConstructorExpression t(&vec, std::move(vals));
 
   Builder b;
-  EXPECT_EQ(b.GenerateConstructorExpression(&t, true), 5);
-  EXPECT_EQ(b.GenerateConstructorExpression(&t, true), 5);
+  EXPECT_EQ(b.GenerateConstructorExpression(&t, true), 5u);
+  EXPECT_EQ(b.GenerateConstructorExpression(&t, true), 5u);
   ASSERT_FALSE(b.has_error()) << b.error();
 }
 
@@ -111,7 +111,7 @@
   ast::TypeConstructorExpression t(&vec, std::move(vals));
 
   Builder b;
-  EXPECT_EQ(b.GenerateConstructorExpression(&t, true), 0);
+  EXPECT_EQ(b.GenerateConstructorExpression(&t, true), 0u);
   EXPECT_TRUE(b.has_error());
   EXPECT_EQ(b.error(), R"(constructor must be a constant expression)");
 }
diff --git a/src/writer/spirv/builder_entry_point_test.cc b/src/writer/spirv/builder_entry_point_test.cc
index c92df6f..d629d26 100644
--- a/src/writer/spirv/builder_entry_point_test.cc
+++ b/src/writer/spirv/builder_entry_point_test.cc
@@ -37,7 +37,7 @@
   ASSERT_TRUE(b.GenerateEntryPoint(&ep));
 
   auto preamble = b.preamble();
-  ASSERT_EQ(preamble.size(), 1);
+  ASSERT_EQ(preamble.size(), 1u);
   EXPECT_EQ(DumpInstruction(preamble[0]), R"(OpEntryPoint Fragment %2 "main"
 )");
 }
@@ -50,7 +50,7 @@
   ASSERT_TRUE(b.GenerateEntryPoint(&ep));
 
   auto preamble = b.preamble();
-  ASSERT_EQ(preamble.size(), 1);
+  ASSERT_EQ(preamble.size(), 1u);
   EXPECT_EQ(DumpInstruction(preamble[0]),
             R"(OpEntryPoint GLCompute %3 "compute_main"
 )");
@@ -83,10 +83,10 @@
   ASSERT_TRUE(b.GenerateEntryPoint(&ep));
 
   auto preamble = b.preamble();
-  ASSERT_EQ(preamble.size(), 1);
+  ASSERT_EQ(preamble.size(), 1u);
   EXPECT_EQ(preamble[0].opcode(), spv::Op::OpEntryPoint);
 
-  ASSERT_GE(preamble[0].operands().size(), 3);
+  ASSERT_GE(preamble[0].operands().size(), 3u);
   EXPECT_EQ(preamble[0].operands()[0].to_i(), params.model);
 }
 INSTANTIATE_TEST_SUITE_P(
diff --git a/src/writer/spirv/builder_function_test.cc b/src/writer/spirv/builder_function_test.cc
index d5ee73e..f250cfb 100644
--- a/src/writer/spirv/builder_function_test.cc
+++ b/src/writer/spirv/builder_function_test.cc
@@ -42,7 +42,7 @@
 %1 = OpTypeFunction %2
 )");
 
-  ASSERT_GE(b.functions().size(), 1);
+  ASSERT_GE(b.functions().size(), 1u);
   const auto& ret = b.functions()[0];
   EXPECT_EQ(DumpInstruction(ret.declaration()), R"(%3 = OpFunction %2 None %1
 )");
diff --git a/src/writer/spirv/builder_ident_expression_test.cc b/src/writer/spirv/builder_ident_expression_test.cc
index 699de11..785aef5 100644
--- a/src/writer/spirv/builder_ident_expression_test.cc
+++ b/src/writer/spirv/builder_ident_expression_test.cc
@@ -68,7 +68,7 @@
 )");
 
   ast::IdentifierExpression expr("var");
-  EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 5);
+  EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 5u);
 }
 
 TEST_F(BuilderTest, IdentifierExpression_GlobalVar) {
@@ -85,7 +85,7 @@
 )");
 
   ast::IdentifierExpression expr("var");
-  EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 1);
+  EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 1u);
 }
 
 TEST_F(BuilderTest, IdentifierExpression_FunctionConst) {
@@ -119,7 +119,7 @@
 )");
 
   ast::IdentifierExpression expr("var");
-  EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 5);
+  EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 5u);
 }
 
 TEST_F(BuilderTest, IdentifierExpression_FunctionVar) {
@@ -140,7 +140,7 @@
 )");
 
   ast::IdentifierExpression expr("var");
-  EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 1);
+  EXPECT_EQ(b.GenerateIdentifierExpression(&expr), 1u);
 }
 
 TEST_F(BuilderTest, IdentifierExpression_Load) {
@@ -165,7 +165,7 @@
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(&var)) << b.error();
 
-  ASSERT_EQ(b.GenerateBinaryExpression(&expr), 6) << b.error();
+  ASSERT_EQ(b.GenerateBinaryExpression(&expr), 6u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeInt 32 1
 %2 = OpTypePointer Private %3
 %1 = OpVariable %2 Private
@@ -202,7 +202,7 @@
   b.push_function(Function{});
   ASSERT_TRUE(b.GenerateGlobalVariable(&var)) << b.error();
 
-  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 3) << b.error();
+  EXPECT_EQ(b.GenerateBinaryExpression(&expr), 3u) << b.error();
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1
 %2 = OpConstant %1 2
 )");
diff --git a/src/writer/spirv/builder_literal_test.cc b/src/writer/spirv/builder_literal_test.cc
index 3fdda3b..d87e9b1 100644
--- a/src/writer/spirv/builder_literal_test.cc
+++ b/src/writer/spirv/builder_literal_test.cc
@@ -39,7 +39,7 @@
   Builder b;
   auto id = b.GenerateLiteralIfNeeded(&b_true);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(2, id);
+  EXPECT_EQ(2u, id);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool
 %2 = OpConstantTrue %1
@@ -53,7 +53,7 @@
   Builder b;
   auto id = b.GenerateLiteralIfNeeded(&b_false);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(2, id);
+  EXPECT_EQ(2u, id);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool
 %2 = OpConstantFalse %1
@@ -66,11 +66,11 @@
   ast::BoolLiteral b_false(&bool_type, false);
 
   Builder b;
-  ASSERT_NE(b.GenerateLiteralIfNeeded(&b_true), 0);
+  ASSERT_NE(b.GenerateLiteralIfNeeded(&b_true), 0u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  ASSERT_NE(b.GenerateLiteralIfNeeded(&b_false), 0);
+  ASSERT_NE(b.GenerateLiteralIfNeeded(&b_false), 0u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  ASSERT_NE(b.GenerateLiteralIfNeeded(&b_true), 0);
+  ASSERT_NE(b.GenerateLiteralIfNeeded(&b_true), 0u);
   ASSERT_FALSE(b.has_error()) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool
@@ -86,7 +86,7 @@
   Builder b;
   auto id = b.GenerateLiteralIfNeeded(&i);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(2, id);
+  EXPECT_EQ(2u, id);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1
 %2 = OpConstant %1 -23
@@ -99,8 +99,8 @@
   ast::IntLiteral i2(&i32, -23);
 
   Builder b;
-  ASSERT_NE(b.GenerateLiteralIfNeeded(&i1), 0);
-  ASSERT_NE(b.GenerateLiteralIfNeeded(&i2), 0);
+  ASSERT_NE(b.GenerateLiteralIfNeeded(&i1), 0u);
+  ASSERT_NE(b.GenerateLiteralIfNeeded(&i2), 0u);
   ASSERT_FALSE(b.has_error()) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1
@@ -115,7 +115,7 @@
   Builder b;
   auto id = b.GenerateLiteralIfNeeded(&i);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(2, id);
+  EXPECT_EQ(2u, id);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0
 %2 = OpConstant %1 23
@@ -128,8 +128,8 @@
   ast::UintLiteral i2(&u32, 23);
 
   Builder b;
-  ASSERT_NE(b.GenerateLiteralIfNeeded(&i1), 0);
-  ASSERT_NE(b.GenerateLiteralIfNeeded(&i2), 0);
+  ASSERT_NE(b.GenerateLiteralIfNeeded(&i1), 0u);
+  ASSERT_NE(b.GenerateLiteralIfNeeded(&i2), 0u);
   ASSERT_FALSE(b.has_error()) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0
@@ -144,7 +144,7 @@
   Builder b;
   auto id = b.GenerateLiteralIfNeeded(&i);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(2, id);
+  EXPECT_EQ(2u, id);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
 %2 = OpConstant %1 23.2450008
@@ -157,8 +157,8 @@
   ast::FloatLiteral i2(&f32, 23.245f);
 
   Builder b;
-  ASSERT_NE(b.GenerateLiteralIfNeeded(&i1), 0);
-  ASSERT_NE(b.GenerateLiteralIfNeeded(&i2), 0);
+  ASSERT_NE(b.GenerateLiteralIfNeeded(&i1), 0u);
+  ASSERT_NE(b.GenerateLiteralIfNeeded(&i2), 0u);
   ASSERT_FALSE(b.has_error()) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
diff --git a/src/writer/spirv/builder_test.cc b/src/writer/spirv/builder_test.cc
index de6fd7a..6360d72 100644
--- a/src/writer/spirv/builder_test.cc
+++ b/src/writer/spirv/builder_test.cc
@@ -36,7 +36,7 @@
 
   Builder b;
   ASSERT_TRUE(b.Build(m));
-  ASSERT_EQ(b.preamble().size(), 4);
+  ASSERT_EQ(b.preamble().size(), 4u);
 
   EXPECT_EQ(DumpBuilder(b), R"(OpCapability Shader
 OpCapability VulkanMemoryModel
@@ -62,7 +62,7 @@
     EXPECT_EQ(b.next_id(), i + 1);
   }
 
-  EXPECT_EQ(6, b.id_bound());
+  EXPECT_EQ(6u, b.id_bound());
 }
 
 }  // namespace
diff --git a/src/writer/spirv/builder_type_test.cc b/src/writer/spirv/builder_type_test.cc
index 765c24b..1e2c79b 100644
--- a/src/writer/spirv/builder_type_test.cc
+++ b/src/writer/spirv/builder_type_test.cc
@@ -46,9 +46,9 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&alias_type);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
-  EXPECT_EQ(b.types().size(), 1);
+  EXPECT_EQ(b.types().size(), 1u);
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32
 )");
 }
@@ -59,13 +59,13 @@
   ast::type::AliasType alias_type("my_type", &f32);
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&alias_type), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&alias_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&alias_type), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&alias_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
 }
 
@@ -76,7 +76,7 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&ary);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(1, id);
+  EXPECT_EQ(1u, id);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
 %1 = OpTypeRuntimeArray %2
@@ -88,8 +88,8 @@
   ast::type::ArrayType ary(&i32);
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1);
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1u);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
@@ -104,7 +104,7 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&ary);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(1, id);
+  EXPECT_EQ(1u, id);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
 %3 = OpTypeInt 32 0
@@ -118,8 +118,8 @@
   ast::type::ArrayType ary(&i32, 4);
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1);
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1u);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&ary), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
@@ -135,9 +135,9 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&bool_type);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
-  ASSERT_EQ(b.types().size(), 1);
+  ASSERT_EQ(b.types().size(), 1u);
   EXPECT_EQ(DumpInstruction(b.types()[0]), R"(%1 = OpTypeBool
 )");
 }
@@ -147,11 +147,11 @@
   ast::type::BoolType bool_type;
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&bool_type), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&bool_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&bool_type), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&bool_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
 }
 
@@ -161,9 +161,9 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&f32);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
-  ASSERT_EQ(b.types().size(), 1);
+  ASSERT_EQ(b.types().size(), 1u);
   EXPECT_EQ(DumpInstruction(b.types()[0]), R"(%1 = OpTypeFloat 32
 )");
 }
@@ -173,11 +173,11 @@
   ast::type::F32Type f32;
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
 }
 
@@ -187,9 +187,9 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&i32);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
-  ASSERT_EQ(b.types().size(), 1);
+  ASSERT_EQ(b.types().size(), 1u);
   EXPECT_EQ(DumpInstruction(b.types()[0]), R"(%1 = OpTypeInt 32 1
 )");
 }
@@ -199,11 +199,11 @@
   ast::type::F32Type f32;
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 2);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 2u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
 }
 
@@ -214,9 +214,9 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&mat_type);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
-  EXPECT_EQ(b.types().size(), 3);
+  EXPECT_EQ(b.types().size(), 3u);
   EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32
 %2 = OpTypeVector %3 3
 %1 = OpTypeMatrix %2 2
@@ -228,11 +228,11 @@
   ast::type::MatrixType mat_type(&i32, 3, 4);
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&mat_type), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&mat_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 3);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 3u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&mat_type), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&mat_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
 }
 
@@ -243,7 +243,7 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&ptr);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(1, id);
+  EXPECT_EQ(1u, id);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeInt 32 1
 %1 = OpTypePointer Output %2
@@ -255,8 +255,8 @@
   ast::type::PointerType ptr(&i32, ast::StorageClass::kOutput);
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&ptr), 1);
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&ptr), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&ptr), 1u);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&ptr), 1u);
 }
 
 TEST_F(BuilderTest_Type, GenerateStruct_Empty) {
@@ -266,9 +266,9 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
-  EXPECT_EQ(b.types().size(), 1);
+  EXPECT_EQ(b.types().size(), 1u);
   EXPECT_EQ(DumpInstructions(b.debug()), "");
   EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeStruct
 )");
@@ -290,7 +290,7 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
 %1 = OpTypeStruct %2
@@ -316,7 +316,7 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
 %1 = OpTypeStruct %2
@@ -349,7 +349,7 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&s_type);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
 %1 = OpTypeStruct %2 %2
@@ -368,9 +368,9 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&u32);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
-  ASSERT_EQ(b.types().size(), 1);
+  ASSERT_EQ(b.types().size(), 1u);
   EXPECT_EQ(DumpInstruction(b.types()[0]), R"(%1 = OpTypeInt 32 0
 )");
 }
@@ -380,11 +380,11 @@
   ast::type::F32Type f32;
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&u32), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&u32), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 2);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&f32), 2u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&u32), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&u32), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
 }
 
@@ -395,9 +395,9 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&vec_type);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
-  EXPECT_EQ(b.types().size(), 2);
+  EXPECT_EQ(b.types().size(), 2u);
   EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32
 %1 = OpTypeVector %2 3
 )");
@@ -408,11 +408,11 @@
   ast::type::VectorType vec_type(&i32, 3);
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&vec_type), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&vec_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&vec_type), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&vec_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
 }
 
@@ -422,9 +422,9 @@
   Builder b;
   auto id = b.GenerateTypeIfNeeded(&void_type);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(id, 1);
+  EXPECT_EQ(id, 1u);
 
-  ASSERT_EQ(b.types().size(), 1);
+  ASSERT_EQ(b.types().size(), 1u);
   EXPECT_EQ(DumpInstruction(b.types()[0]), R"(%1 = OpTypeVoid
 )");
 }
@@ -434,11 +434,11 @@
   ast::type::VoidType void_type;
 
   Builder b;
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&void_type), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&void_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&i32), 2u);
   ASSERT_FALSE(b.has_error()) << b.error();
-  EXPECT_EQ(b.GenerateTypeIfNeeded(&void_type), 1);
+  EXPECT_EQ(b.GenerateTypeIfNeeded(&void_type), 1u);
   ASSERT_FALSE(b.has_error()) << b.error();
 }
 
diff --git a/src/writer/spirv/instruction_test.cc b/src/writer/spirv/instruction_test.cc
index e147a41..65e0630 100644
--- a/src/writer/spirv/instruction_test.cc
+++ b/src/writer/spirv/instruction_test.cc
@@ -28,14 +28,14 @@
   Instruction i(spv::Op::OpEntryPoint, {Operand::Float(1.2f), Operand::Int(1),
                                         Operand::String("my_str")});
   EXPECT_EQ(i.opcode(), spv::Op::OpEntryPoint);
-  ASSERT_EQ(i.operands().size(), 3);
+  ASSERT_EQ(i.operands().size(), 3u);
 
   const auto& ops = i.operands();
   EXPECT_TRUE(ops[0].IsFloat());
   EXPECT_FLOAT_EQ(ops[0].to_f(), 1.2);
 
   EXPECT_TRUE(ops[1].IsInt());
-  EXPECT_EQ(ops[1].to_i(), 1);
+  EXPECT_EQ(ops[1].to_i(), 1u);
 
   EXPECT_TRUE(ops[2].IsString());
   EXPECT_EQ(ops[2].to_s(), "my_str");
@@ -44,7 +44,7 @@
 TEST_F(InstructionTest, Length) {
   Instruction i(spv::Op::OpEntryPoint, {Operand::Float(1.2f), Operand::Int(1),
                                         Operand::String("my_str")});
-  EXPECT_EQ(i.word_length(), 5);
+  EXPECT_EQ(i.word_length(), 5u);
 }
 
 }  // namespace
diff --git a/src/writer/spirv/operand_test.cc b/src/writer/spirv/operand_test.cc
index 681e8c4..0bb1c26 100644
--- a/src/writer/spirv/operand_test.cc
+++ b/src/writer/spirv/operand_test.cc
@@ -32,7 +32,7 @@
 TEST_F(OperandTest, CreateInt) {
   auto o = Operand::Int(1);
   EXPECT_TRUE(o.IsInt());
-  EXPECT_EQ(o.to_i(), 1);
+  EXPECT_EQ(o.to_i(), 1u);
 }
 
 TEST_F(OperandTest, CreateString) {
@@ -43,22 +43,22 @@
 
 TEST_F(OperandTest, Length_Float) {
   auto o = Operand::Float(1.2f);
-  EXPECT_EQ(o.length(), 1);
+  EXPECT_EQ(o.length(), 1u);
 }
 
 TEST_F(OperandTest, Length_Int) {
   auto o = Operand::Int(1);
-  EXPECT_EQ(o.length(), 1);
+  EXPECT_EQ(o.length(), 1u);
 }
 
 TEST_F(OperandTest, Length_String) {
   auto o = Operand::String("my string");
-  EXPECT_EQ(o.length(), 3);
+  EXPECT_EQ(o.length(), 3u);
 }
 
 TEST_F(OperandTest, Length_String_Empty) {
   auto o = Operand::String("");
-  EXPECT_EQ(o.length(), 1);
+  EXPECT_EQ(o.length(), 1u);
 }
 
 }  // namespace
diff --git a/tint_overrides_with_defaults.gni b/tint_overrides_with_defaults.gni
index 5732e2d..a8861ea 100644
--- a/tint_overrides_with_defaults.gni
+++ b/tint_overrides_with_defaults.gni
@@ -22,6 +22,11 @@
     tint_spirv_tools_dir = "//third_party/spirv-tools"
   }
 
+  # Path to googletest checkout
+  if (!defined(tint_googletest_dir)) {
+    tint_googletest_dir = "//third_party/googletest"
+  }
+
   # Path to spirv-tools generated files, relative to |target_gen_dir|
   if (!defined(tint_spirv_tools_gen)) {
     tint_spirv_tools_gen = "third_party/spirv-tools"