[webkit-changes] [293050] trunk/Source/WebCore

Tue, 19 Apr 2022 17:24:14 -0700

Title: [293050] trunk/Source/WebCore
Revision
293050
Author
cdu...@apple.com
Date
2022-04-19 17:23:31 -0700 (Tue, 19 Apr 2022)

Log Message

Use SortedArrayMap in parseEnumeration<>() in the JS bindings
https://bugs.webkit.org/show_bug.cgi?id=239503

Reviewed by Darin Adler.

Use SortedArrayMap in parseEnumeration<>() in the JS bindings, which should be slightly
better for performance.

* bindings/scripts/CodeGeneratorJS.pm:
(GenerateEnumerationImplementationContent):
* bindings/scripts/test/JS/JSTestCallbackInterface.cpp:
(WebCore::parseEnumeration<TestCallbackInterface::Enum>):
* bindings/scripts/test/JS/JSTestDefaultToJSONEnum.cpp:
(WebCore::parseEnumeration<TestDefaultToJSONEnum>):
* bindings/scripts/test/JS/JSTestObj.cpp:
(WebCore::parseEnumeration<TestObj::EnumType>):
(WebCore::parseEnumeration<TestObj::EnumTrailingComma>):
(WebCore::parseEnumeration<TestObj::Optional>):
(WebCore::parseEnumeration<AlternateEnumName>):
(WebCore::parseEnumeration<TestObj::EnumA>):
(WebCore::parseEnumeration<TestObj::EnumB>):
(WebCore::parseEnumeration<TestObj::EnumC>):
(WebCore::parseEnumeration<TestObj::Kind>):
(WebCore::parseEnumeration<TestObj::Size>):
(WebCore::parseEnumeration<TestObj::Confidence>):
* bindings/scripts/test/JS/JSTestStandaloneDictionary.cpp:
(WebCore::parseEnumeration<TestStandaloneDictionary::EnumInStandaloneDictionaryFile>):
* bindings/scripts/test/JS/JSTestStandaloneEnumeration.cpp:
(WebCore::parseEnumeration<TestStandaloneEnumeration>):

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (293049 => 293050)


--- trunk/Source/WebCore/ChangeLog	2022-04-20 00:10:52 UTC (rev 293049)
+++ trunk/Source/WebCore/ChangeLog	2022-04-20 00:23:31 UTC (rev 293050)
@@ -1,3 +1,35 @@
+2022-04-19  Chris Dumez  <cdu...@apple.com>
+
+        Use SortedArrayMap in parseEnumeration<>() in the JS bindings
+        https://bugs.webkit.org/show_bug.cgi?id=239503
+
+        Reviewed by Darin Adler.
+
+        Use SortedArrayMap in parseEnumeration<>() in the JS bindings, which should be slightly
+        better for performance.
+
+        * bindings/scripts/CodeGeneratorJS.pm:
+        (GenerateEnumerationImplementationContent):
+        * bindings/scripts/test/JS/JSTestCallbackInterface.cpp:
+        (WebCore::parseEnumeration<TestCallbackInterface::Enum>):
+        * bindings/scripts/test/JS/JSTestDefaultToJSONEnum.cpp:
+        (WebCore::parseEnumeration<TestDefaultToJSONEnum>):
+        * bindings/scripts/test/JS/JSTestObj.cpp:
+        (WebCore::parseEnumeration<TestObj::EnumType>):
+        (WebCore::parseEnumeration<TestObj::EnumTrailingComma>):
+        (WebCore::parseEnumeration<TestObj::Optional>):
+        (WebCore::parseEnumeration<AlternateEnumName>):
+        (WebCore::parseEnumeration<TestObj::EnumA>):
+        (WebCore::parseEnumeration<TestObj::EnumB>):
+        (WebCore::parseEnumeration<TestObj::EnumC>):
+        (WebCore::parseEnumeration<TestObj::Kind>):
+        (WebCore::parseEnumeration<TestObj::Size>):
+        (WebCore::parseEnumeration<TestObj::Confidence>):
+        * bindings/scripts/test/JS/JSTestStandaloneDictionary.cpp:
+        (WebCore::parseEnumeration<TestStandaloneDictionary::EnumInStandaloneDictionaryFile>):
+        * bindings/scripts/test/JS/JSTestStandaloneEnumeration.cpp:
+        (WebCore::parseEnumeration<TestStandaloneEnumeration>):
+
 2022-04-19  Tim Nguyen  <n...@apple.com>
 
         Clean up SVGs added by r293038

Modified: trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm (293049 => 293050)


--- trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm	2022-04-20 00:10:52 UTC (rev 293049)
+++ trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm	2022-04-20 00:23:31 UTC (rev 293050)
@@ -2362,6 +2362,7 @@
     AddToImplIncludes("<_javascript_Core/JSString.h>");
     AddToImplIncludes("<_javascript_Core/JSCInlines.h>");
     AddToImplIncludes("JSDOMConvertEnumeration.h");
+    AddToImplIncludes("<wtf/SortedArrayMap.h>");
 
     my $result = "";
     $result .= "#if ${conditionalString}\n\n" if $conditionalString;
@@ -2402,15 +2403,21 @@
     $result .= "template<> std::optional<$className> parseEnumeration<$className>(JSGlobalObject& lexicalGlobalObject, JSValue value)\n";
     $result .= "{\n";
     $result .= "    auto stringValue = value.toWTFString(&lexicalGlobalObject);\n";
-    foreach my $value (@{$enumeration->values}) {
+    my @sortedEnumerationValues = sort @{$enumeration->values};
+    if ($sortedEnumerationValues[0] eq "") {
+        $result .= "    if (stringValue.isEmpty())\n";
+        my $enumerationValueName = GetEnumerationValueName(shift(@sortedEnumerationValues));
+        $result .= "        return ${className}::$enumerationValueName;\n";
+    }
+    $result .= "    static constexpr std::pair<ComparableASCIILiteral, $className> mappings[] = {\n";
+    for my $value (@sortedEnumerationValues) {
         my $enumerationValueName = GetEnumerationValueName($value);
-        if ($value eq "") {
-            $result .= "    if (stringValue.isEmpty())\n";
-        } else {
-            $result .= "    if (stringValue == \"$value\")\n";
-        }
-        $result .= "        return ${className}::${enumerationValueName};\n";
+        $result .= "        { \"$value\", ${className}::$enumerationValueName },\n";
     }
+    $result .= "    };\n";
+    $result .= "    static constexpr SortedArrayMap enumerationMapping { mappings };\n";
+    $result .= "    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))\n";
+    $result .= "        return *enumerationValue;\n";
     $result .= "    return std::nullopt;\n";
     $result .= "}\n\n";

Modified: trunk/Source/WebCore/bindings/scripts/test/JS/JSTestCallbackInterface.cpp (293049 => 293050)


--- trunk/Source/WebCore/bindings/scripts/test/JS/JSTestCallbackInterface.cpp	2022-04-20 00:10:52 UTC (rev 293049)
+++ trunk/Source/WebCore/bindings/scripts/test/JS/JSTestCallbackInterface.cpp	2022-04-20 00:23:31 UTC (rev 293050)
@@ -44,6 +44,7 @@
 #include <_javascript_Core/JSCInlines.h>
 #include <_javascript_Core/JSString.h>
 #include <wtf/NeverDestroyed.h>
+#include <wtf/SortedArrayMap.h>
 
 
 namespace WebCore {
@@ -69,10 +70,13 @@
 template<> std::optional<TestCallbackInterface::Enum> parseEnumeration<TestCallbackInterface::Enum>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "value1")
-        return TestCallbackInterface::Enum::Value1;
-    if (stringValue == "value2")
-        return TestCallbackInterface::Enum::Value2;
+    static constexpr std::pair<ComparableASCIILiteral, TestCallbackInterface::Enum> mappings[] = {
+        { "value1", TestCallbackInterface::Enum::Value1 },
+        { "value2", TestCallbackInterface::Enum::Value2 },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }

Modified: trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDefaultToJSONEnum.cpp (293049 => 293050)


--- trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDefaultToJSONEnum.cpp	2022-04-20 00:10:52 UTC (rev 293049)
+++ trunk/Source/WebCore/bindings/scripts/test/JS/JSTestDefaultToJSONEnum.cpp	2022-04-20 00:23:31 UTC (rev 293050)
@@ -24,6 +24,7 @@
 #include <_javascript_Core/JSCInlines.h>
 #include <_javascript_Core/JSString.h>
 #include <wtf/NeverDestroyed.h>
+#include <wtf/SortedArrayMap.h>
 
 
 namespace WebCore {
@@ -49,10 +50,13 @@
 template<> std::optional<TestDefaultToJSONEnum> parseEnumeration<TestDefaultToJSONEnum>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "EnumValue1")
-        return TestDefaultToJSONEnum::EnumValue1;
-    if (stringValue == "EnumValue2")
-        return TestDefaultToJSONEnum::EnumValue2;
+    static constexpr std::pair<ComparableASCIILiteral, TestDefaultToJSONEnum> mappings[] = {
+        { "EnumValue1", TestDefaultToJSONEnum::EnumValue1 },
+        { "EnumValue2", TestDefaultToJSONEnum::EnumValue2 },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }

Modified: trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp (293049 => 293050)


--- trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp	2022-04-20 00:10:52 UTC (rev 293049)
+++ trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp	2022-04-20 00:23:31 UTC (rev 293050)
@@ -103,6 +103,7 @@
 #include <variant>
 #include <wtf/GetPtr.h>
 #include <wtf/PointerPreparations.h>
+#include <wtf/SortedArrayMap.h>
 #include <wtf/URL.h>
 #include <wtf/Vector.h>
 
@@ -152,12 +153,14 @@
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
     if (stringValue.isEmpty())
         return TestObj::EnumType::EmptyString;
-    if (stringValue == "enumValue1")
-        return TestObj::EnumType::EnumValue1;
-    if (stringValue == "EnumValue2")
-        return TestObj::EnumType::EnumValue2;
-    if (stringValue == "EnumValue3")
-        return TestObj::EnumType::EnumValue3;
+    static constexpr std::pair<ComparableASCIILiteral, TestObj::EnumType> mappings[] = {
+        { "EnumValue2", TestObj::EnumType::EnumValue2 },
+        { "EnumValue3", TestObj::EnumType::EnumValue3 },
+        { "enumValue1", TestObj::EnumType::EnumValue1 },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }
 
@@ -186,10 +189,13 @@
 template<> std::optional<TestObj::EnumTrailingComma> parseEnumeration<TestObj::EnumTrailingComma>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "enumValue1")
-        return TestObj::EnumTrailingComma::EnumValue1;
-    if (stringValue == "enumValue2")
-        return TestObj::EnumTrailingComma::EnumValue2;
+    static constexpr std::pair<ComparableASCIILiteral, TestObj::EnumTrailingComma> mappings[] = {
+        { "enumValue1", TestObj::EnumTrailingComma::EnumValue1 },
+        { "enumValue2", TestObj::EnumTrailingComma::EnumValue2 },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }
 
@@ -224,12 +230,14 @@
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
     if (stringValue.isEmpty())
         return TestObj::Optional::EmptyString;
-    if (stringValue == "OptionalValue1")
-        return TestObj::Optional::OptionalValue1;
-    if (stringValue == "OptionalValue2")
-        return TestObj::Optional::OptionalValue2;
-    if (stringValue == "OptionalValue3")
-        return TestObj::Optional::OptionalValue3;
+    static constexpr std::pair<ComparableASCIILiteral, TestObj::Optional> mappings[] = {
+        { "OptionalValue1", TestObj::Optional::OptionalValue1 },
+        { "OptionalValue2", TestObj::Optional::OptionalValue2 },
+        { "OptionalValue3", TestObj::Optional::OptionalValue3 },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }
 
@@ -258,10 +266,13 @@
 template<> std::optional<AlternateEnumName> parseEnumeration<AlternateEnumName>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "enumValue1")
-        return AlternateEnumName::EnumValue1;
-    if (stringValue == "EnumValue2")
-        return AlternateEnumName::EnumValue2;
+    static constexpr std::pair<ComparableASCIILiteral, AlternateEnumName> mappings[] = {
+        { "EnumValue2", AlternateEnumName::EnumValue2 },
+        { "enumValue1", AlternateEnumName::EnumValue1 },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }
 
@@ -290,8 +301,12 @@
 template<> std::optional<TestObj::EnumA> parseEnumeration<TestObj::EnumA>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "A")
-        return TestObj::EnumA::A;
+    static constexpr std::pair<ComparableASCIILiteral, TestObj::EnumA> mappings[] = {
+        { "A", TestObj::EnumA::A },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }
 
@@ -322,8 +337,12 @@
 template<> std::optional<TestObj::EnumB> parseEnumeration<TestObj::EnumB>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "B")
-        return TestObj::EnumB::B;
+    static constexpr std::pair<ComparableASCIILiteral, TestObj::EnumB> mappings[] = {
+        { "B", TestObj::EnumB::B },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }
 
@@ -354,8 +373,12 @@
 template<> std::optional<TestObj::EnumC> parseEnumeration<TestObj::EnumC>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "C")
-        return TestObj::EnumC::C;
+    static constexpr std::pair<ComparableASCIILiteral, TestObj::EnumC> mappings[] = {
+        { "C", TestObj::EnumC::C },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }
 
@@ -386,10 +409,13 @@
 template<> std::optional<TestObj::Kind> parseEnumeration<TestObj::Kind>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "quick")
-        return TestObj::Kind::Quick;
-    if (stringValue == "dead")
-        return TestObj::Kind::Dead;
+    static constexpr std::pair<ComparableASCIILiteral, TestObj::Kind> mappings[] = {
+        { "dead", TestObj::Kind::Dead },
+        { "quick", TestObj::Kind::Quick },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }
 
@@ -418,10 +444,13 @@
 template<> std::optional<TestObj::Size> parseEnumeration<TestObj::Size>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "small")
-        return TestObj::Size::Small;
-    if (stringValue == "much-much-larger")
-        return TestObj::Size::MuchMuchLarger;
+    static constexpr std::pair<ComparableASCIILiteral, TestObj::Size> mappings[] = {
+        { "much-much-larger", TestObj::Size::MuchMuchLarger },
+        { "small", TestObj::Size::Small },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }
 
@@ -450,10 +479,13 @@
 template<> std::optional<TestObj::Confidence> parseEnumeration<TestObj::Confidence>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "high")
-        return TestObj::Confidence::High;
-    if (stringValue == "kinda-low")
-        return TestObj::Confidence::KindaLow;
+    static constexpr std::pair<ComparableASCIILiteral, TestObj::Confidence> mappings[] = {
+        { "high", TestObj::Confidence::High },
+        { "kinda-low", TestObj::Confidence::KindaLow },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }

Modified: trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStandaloneDictionary.cpp (293049 => 293050)


--- trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStandaloneDictionary.cpp	2022-04-20 00:10:52 UTC (rev 293049)
+++ trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStandaloneDictionary.cpp	2022-04-20 00:23:31 UTC (rev 293050)
@@ -38,6 +38,7 @@
 #include <_javascript_Core/ObjectConstructor.h>
 #include <variant>
 #include <wtf/NeverDestroyed.h>
+#include <wtf/SortedArrayMap.h>
 
 
 namespace WebCore {
@@ -350,10 +351,13 @@
 template<> std::optional<TestStandaloneDictionary::EnumInStandaloneDictionaryFile> parseEnumeration<TestStandaloneDictionary::EnumInStandaloneDictionaryFile>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "enumValue1")
-        return TestStandaloneDictionary::EnumInStandaloneDictionaryFile::EnumValue1;
-    if (stringValue == "enumValue2")
-        return TestStandaloneDictionary::EnumInStandaloneDictionaryFile::EnumValue2;
+    static constexpr std::pair<ComparableASCIILiteral, TestStandaloneDictionary::EnumInStandaloneDictionaryFile> mappings[] = {
+        { "enumValue1", TestStandaloneDictionary::EnumInStandaloneDictionaryFile::EnumValue1 },
+        { "enumValue2", TestStandaloneDictionary::EnumInStandaloneDictionaryFile::EnumValue2 },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }

Modified: trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStandaloneEnumeration.cpp (293049 => 293050)


--- trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStandaloneEnumeration.cpp	2022-04-20 00:10:52 UTC (rev 293049)
+++ trunk/Source/WebCore/bindings/scripts/test/JS/JSTestStandaloneEnumeration.cpp	2022-04-20 00:23:31 UTC (rev 293050)
@@ -27,6 +27,7 @@
 #include <_javascript_Core/JSCInlines.h>
 #include <_javascript_Core/JSString.h>
 #include <wtf/NeverDestroyed.h>
+#include <wtf/SortedArrayMap.h>
 
 
 namespace WebCore {
@@ -52,10 +53,13 @@
 template<> std::optional<TestStandaloneEnumeration> parseEnumeration<TestStandaloneEnumeration>(JSGlobalObject& lexicalGlobalObject, JSValue value)
 {
     auto stringValue = value.toWTFString(&lexicalGlobalObject);
-    if (stringValue == "enumValue1")
-        return TestStandaloneEnumeration::EnumValue1;
-    if (stringValue == "enumValue2")
-        return TestStandaloneEnumeration::EnumValue2;
+    static constexpr std::pair<ComparableASCIILiteral, TestStandaloneEnumeration> mappings[] = {
+        { "enumValue1", TestStandaloneEnumeration::EnumValue1 },
+        { "enumValue2", TestStandaloneEnumeration::EnumValue2 },
+    };
+    static constexpr SortedArrayMap enumerationMapping { mappings };
+    if (auto* enumerationValue = enumerationMapping.tryGet(stringValue); LIKELY(enumerationValue))
+        return *enumerationValue;
     return std::nullopt;
 }
 

_______________________________________________
webkit-changes mailing list
webkit-changes@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to