Fix build errors about implicit conversions

This patch fixes all the build errors about implicit conversions:
- error: implicit conversion increases floating-point precision:
         'const float' to 'double' [-Werror,-Wdouble-promotion]
- error: comparison of integers of different signs:
        'const unsigned int' and 'const int' [-Werror,-Wsign-compare]

Bug: none
Change-Id: Iceda4d9dbca241a244566b8d4db4c8a563e0c22e
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/323595
Commit-Queue: Shao, Jiawei <jiawei.shao@intel.com>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
diff --git a/src/dawn/tests/unittests/AlgebraTests.cpp b/src/dawn/tests/unittests/AlgebraTests.cpp
index 527af9a..0f45717 100644
--- a/src/dawn/tests/unittests/AlgebraTests.cpp
+++ b/src/dawn/tests/unittests/AlgebraTests.cpp
@@ -287,12 +287,12 @@
 // Test computation of the determinant.
 TEST(Algebra, MatrixDeterminant) {
     // Simple test vectors.
-    EXPECT_EQ(Mat2x2f({2, 3}, {5, 7}).Determinant(), -1.0);
-    EXPECT_EQ(Mat3x3f({2, 3, 5}, {7, 11, 13}, {17, 19, 23}).Determinant(), -78.0);
+    EXPECT_EQ(Mat2x2f({2, 3}, {5, 7}).Determinant(), -1.0f);
+    EXPECT_EQ(Mat3x3f({2, 3, 5}, {7, 11, 13}, {17, 19, 23}).Determinant(), -78.0f);
 
     // Determinant of non-invertible matrices is 0.
-    EXPECT_EQ(Mat2x2f({1, 2}, {2, 4}).Determinant(), 0.0);
-    EXPECT_EQ(Mat3x3f({1, 2, 3}, {1, 3, 5}, {2, 5, 8}).Determinant(), 0.0);
+    EXPECT_EQ(Mat2x2f({1, 2}, {2, 4}).Determinant(), 0.0f);
+    EXPECT_EQ(Mat3x3f({1, 2, 3}, {1, 3, 5}, {2, 5, 8}).Determinant(), 0.0f);
 }
 
 // Test computation of the inverse.
diff --git a/src/dawn/tests/unittests/vulkan/MemoryTypeSelectorTests.cpp b/src/dawn/tests/unittests/vulkan/MemoryTypeSelectorTests.cpp
index bb1e64e..b313d5b 100644
--- a/src/dawn/tests/unittests/vulkan/MemoryTypeSelectorTests.cpp
+++ b/src/dawn/tests/unittests/vulkan/MemoryTypeSelectorTests.cpp
@@ -58,23 +58,23 @@
     MemoryTypeSelector selector(memoryTypes, memoryHeaps);
 
     // Device local buffers or textures.
-    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear), 0);
-    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::DeviceLocal), 0);
+    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear), 0u);
+    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::DeviceLocal), 0u);
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal),
-              0);
+              0u);
 
     // Write mappable buffers prefer HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::WriteMappable),
-              1);
+              1u);
 
     // Read mappable buffers prefer HOST_CACHED.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::ReadMappable),
-              2);
+              2u);
 
     // Read+write mappable buffers prefer HOST_CACHED+HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::ReadMappable |
                                                        MemoryKind::WriteMappable),
-              2);
+              2u);
 
     // BufferMapExtendedUsages buffers are disabled on Nvidia GPUs.
 }
@@ -95,44 +95,44 @@
     MemoryTypeSelector selector(memoryTypes, memoryHeaps);
 
     // Device local buffers or textures.
-    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear), 0);
-    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::DeviceLocal), 0);
+    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear), 0u);
+    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::DeviceLocal), 0u);
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal),
-              0);
+              0u);
 
     // Write mappable buffers prefer HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::WriteMappable),
-              0);
+              0u);
 
     // Read mappable buffers prefer HOST_CACHED over HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::ReadMappable),
-              1);
+              1u);
 
     // Read+write mappable buffers prefer HOST_CACHED since HOST_CACHED+HOST_COHERENT isn't
     // available.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::ReadMappable |
                                                        MemoryKind::WriteMappable),
-              1);
+              1u);
 
     // Lazily allocated textures.
-    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::LazilyAllocated), 2);
+    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::LazilyAllocated), 2u);
 
     // BufferMapExtendedUsages write mappable buffers prefer HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal |
                                                        MemoryKind::WriteMappable),
-              0);
+              0u);
 
     // BufferMapExtendedUsages read mappable buffers prefer HOST_CACHED.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal |
                                                        MemoryKind::ReadMappable),
-              1);
+              1u);
 
     // BufferMapExtendedUsages read+write mappable buffers prefer HOST_CACHED since no
     // HOST_CACHED+HOST_COHERENT exists.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal |
                                                        MemoryKind::ReadMappable |
                                                        MemoryKind::WriteMappable),
-              1);
+              1u);
 }
 
 TEST(MemoryTypeSelectorTests, Mali_G72) {
@@ -150,42 +150,42 @@
     MemoryTypeSelector selector(memoryTypes, memoryHeaps);
 
     // Device local buffers or textures.
-    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear), 0);
-    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::DeviceLocal), 0);
+    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear), 0u);
+    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::DeviceLocal), 0u);
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal),
-              0);
+              0u);
 
     // Write mappable buffers prefer HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::WriteMappable),
-              0);
+              0u);
 
     // Read mappable buffers prefer HOST_CACHED over HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::ReadMappable),
-              1);
+              1u);
 
     // Read+write mappable buffers prefer HOST_CACHED+HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::ReadMappable |
                                                        MemoryKind::WriteMappable),
-              1);
+              1u);
 
     // Lazily allocated textures.
-    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::LazilyAllocated), 2);
+    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::LazilyAllocated), 2u);
 
     // BufferMapExtendedUsages write mappable buffers prefer HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal |
                                                        MemoryKind::WriteMappable),
-              0);
+              0u);
 
     // BufferMapExtendedUsages read mappable buffers prefer HOST_CACHED.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal |
                                                        MemoryKind::ReadMappable),
-              1);
+              1u);
 
     // BufferMapExtendedUsages read+write mappable buffers prefer HOST_CACHED+HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal |
                                                        MemoryKind::ReadMappable |
                                                        MemoryKind::WriteMappable),
-              1);
+              1u);
 }
 
 TEST(MemoryTypeSelectorTests, Adreno_620) {
@@ -209,39 +209,39 @@
     MemoryTypeSelector selector(memoryTypes, memoryHeaps);
 
     // Device local buffers or textures.
-    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear), 0);
-    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::DeviceLocal), 0);
+    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear), 0u);
+    EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::DeviceLocal), 0u);
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal),
-              0);
+              0u);
 
     // Write mappable buffers prefer HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::WriteMappable),
-              1);
+              1u);
 
     // Read mappable buffers prefer HOST_CACHED over HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::ReadMappable),
-              2);
+              2u);
 
     // Read+write mappable buffers prefer HOST_CACHED+HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::ReadMappable |
                                                        MemoryKind::WriteMappable),
-              3);
+              3u);
 
     // BufferMapExtendedUsages write mappable buffers prefer HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal |
                                                        MemoryKind::WriteMappable),
-              1);
+              1u);
 
     // BufferMapExtendedUsages read mappable buffers prefer HOST_CACHED.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal |
                                                        MemoryKind::ReadMappable),
-              2);
+              2u);
 
     // BufferMapExtendedUsages read+write mappable buffers prefer HOST_CACHED+HOST_COHERENT.
     EXPECT_EQ(selector.FindBestTypeIndex(kAnyType, MemoryKind::Linear | MemoryKind::DeviceLocal |
                                                        MemoryKind::ReadMappable |
                                                        MemoryKind::WriteMappable),
-              3);
+              3u);
 }
 
 }  // namespace dawn::native::vulkan
diff --git a/src/tint/lang/core/constant/composite_test.cc b/src/tint/lang/core/constant/composite_test.cc
index 33cc3c9..38373d1 100644
--- a/src/tint/lang/core/constant/composite_test.cc
+++ b/src/tint/lang/core/constant/composite_test.cc
@@ -95,9 +95,9 @@
     ASSERT_EQ(composite->Index(2), nullptr);
 
     EXPECT_TRUE(composite->Index(0)->Is<Scalar<f32>>());
-    EXPECT_EQ(composite->Index(0)->As<Scalar<f32>>()->ValueOf(), 1.0);
+    EXPECT_EQ(composite->Index(0)->As<Scalar<f32>>()->ValueOf(), 1.0f);
     EXPECT_TRUE(composite->Index(1)->Is<Scalar<f32>>());
-    EXPECT_EQ(composite->Index(1)->As<Scalar<f32>>()->ValueOf(), 0.0);
+    EXPECT_EQ(composite->Index(1)->As<Scalar<f32>>()->ValueOf(), 0.0f);
 }
 
 TEST_F(ConstantTest_Composite, Clone) {
diff --git a/src/tint/lang/wgsl/reader/parser/expression_test.cc b/src/tint/lang/wgsl/reader/parser/expression_test.cc
index 7412010..e41f12d 100644
--- a/src/tint/lang/wgsl/reader/parser/expression_test.cc
+++ b/src/tint/lang/wgsl/reader/parser/expression_test.cc
@@ -382,7 +382,7 @@
 
     ASSERT_TRUE(e->Is<ast::FloatLiteralExpression>());
     EXPECT_EQ(e->As<ast::FloatLiteralExpression>()->value,
-              340282346638528859811704183484516925440.0f);
+              340282346638528859811704183484516925440.0);
 }
 
 TEST_F(WGSLParserTest, Expression_MinF32) {
@@ -406,7 +406,7 @@
 
     ASSERT_TRUE(b->expr->Is<ast::FloatLiteralExpression>());
     EXPECT_EQ(b->expr->As<ast::FloatLiteralExpression>()->value,
-              340282346638528859811704183484516925440.0f);
+              340282346638528859811704183484516925440.0);
 }
 
 namespace mixing_binary_ops {
diff --git a/src/tint/lang/wgsl/reader/parser/primary_expression_test.cc b/src/tint/lang/wgsl/reader/parser/primary_expression_test.cc
index 9e7a771..5e9554f 100644
--- a/src/tint/lang/wgsl/reader/parser/primary_expression_test.cc
+++ b/src/tint/lang/wgsl/reader/parser/primary_expression_test.cc
@@ -162,7 +162,7 @@
               ast::IntLiteralExpression::Suffix::kU);
 
     ASSERT_TRUE(call->args[1]->Is<ast::FloatLiteralExpression>());
-    EXPECT_EQ(call->args[1]->As<ast::FloatLiteralExpression>()->value, 2.f);
+    EXPECT_EQ(call->args[1]->As<ast::FloatLiteralExpression>()->value, 2.0);
 }
 
 TEST_F(WGSLParserTest, PrimaryExpression_ConstLiteral_True) {