Changeset 248822 in webkit


Ignore:
Timestamp:
Aug 17, 2019 11:49:37 AM (5 years ago)
Author:
weinig@apple.com
Message:

Rename StringBuilder::flexibleAppend(...) to StringBuilder::append(...)
​https://bugs.webkit.org/show_bug.cgi?id=200756

Reviewed by Darin Adler.

Source/WebCore:

Update call sites for rename from StringBuilder::flexibleAppend(...) to
StringBuilder::append(...).

  • Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp:

(WebCore::WHLSL::Metal::EntryPointScaffolding::emitResourceHelperTypes):
(WebCore::WHLSL::Metal::EntryPointScaffolding::emitResourceSignature):
(WebCore::WHLSL::Metal::EntryPointScaffolding::emitBuiltInsSignature):
(WebCore::WHLSL::Metal::EntryPointScaffolding::emitMangledInputPath):
(WebCore::WHLSL::Metal::EntryPointScaffolding::emitMangledOutputPath):
(WebCore::WHLSL::Metal::EntryPointScaffolding::emitUnpackResourcesAndNamedBuiltIns):
(WebCore::WHLSL::Metal::VertexEntryPointScaffolding::emitHelperTypes):
(WebCore::WHLSL::Metal::VertexEntryPointScaffolding::emitSignature):
(WebCore::WHLSL::Metal::VertexEntryPointScaffolding::emitUnpack):
(WebCore::WHLSL::Metal::VertexEntryPointScaffolding::emitPack):
(WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::emitHelperTypes):
(WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::emitSignature):
(WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::emitUnpack):
(WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::emitPack):
(WebCore::WHLSL::Metal::ComputeEntryPointScaffolding::emitSignature):

  • Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp:

(WebCore::WHLSL::Metal::declareFunction):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::visit):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::emitLoop):
(WebCore::WHLSL::Metal::FunctionDefinitionWriter::emitConstantExpressionString):

  • Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp:

(WebCore::WHLSL::Metal::inlineNativeFunction):

  • Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp:

(WebCore::WHLSL::Metal::TypeNamer::emitUnnamedTypeDefinition):
(WebCore::WHLSL::Metal::TypeNamer::emitNamedTypeDefinition):

  • Modules/webgpu/WHLSL/WHLSLParser.cpp:

(WebCore::WHLSL::Types::appendNameTo):

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::logLayerInfo):

  • testing/Internals.cpp:

(WebCore::Internals::ongoingLoadsDescriptions const):

Source/WebKit:

Update call sites for rename from StringBuilder::flexibleAppend(...) to
StringBuilder::append(...).

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::dumpHistoryItem):
We have to explicitly access the underlying String of the URL rather than
relying on the implicit conversion since it is now ambiguous which append(...)
overload should be used.

Source/WTF:

Now that there are no remaining multi-parameter or behavior changing overloads
of StringBuilder::append(...), we can rename StringBuilder::flexibleAppend(...)
to StringBuilder::append(...).

This change leaves the existing single parameter overloads StringBuilder::append(...)
for now, and since they have specify specific types, they will continue to be prefered
in overload resolution. Once we have concluded the variadic StringBuilder::append(...)
can provide the same performance as the single parameter variant, we can remove the
single parameter variant.

  • wtf/posix/FileSystemPOSIX.cpp:

(WTF::FileSystemImpl::pathByAppendingComponents):

  • wtf/text/StringBuilder.h:

(WTF::StringBuilder::appendFromAdapters):
(WTF::StringBuilder::append):
(WTF::StringBuilder::flexibleAppendFromAdapters): Deleted.
(WTF::StringBuilder::flexibleAppend): Deleted.
Update for rename from StringBuilder::flexibleAppend(...) to StringBuilder::append(...).

Tools:

Update call sites for rename from StringBuilder::flexibleAppend(...) to
StringBuilder::append(...).

  • TestWebKitAPI/Tests/WTF/StringBuilder.cpp:

(TestWebKitAPI::TEST):

Location:
trunk
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r248807 r248822  
     12019-08-17  Sam Weinig  <weinig@apple.com>
     2
     3        Rename StringBuilder::flexibleAppend(...) to StringBuilder::append(...)
     4        https://bugs.webkit.org/show_bug.cgi?id=200756
     5
     6        Reviewed by Darin Adler.
     7
     8        Now that there are no remaining multi-parameter or behavior changing overloads
     9        of StringBuilder::append(...), we can rename StringBuilder::flexibleAppend(...)
     10        to StringBuilder::append(...).
     11       
     12        This change leaves the existing single parameter overloads StringBuilder::append(...)
     13        for now, and since they have specify specific types, they will continue to be prefered
     14        in overload resolution. Once we have concluded the variadic StringBuilder::append(...)
     15        can provide the same performance as the single parameter variant, we can remove the
     16        single parameter variant.
     17
     18        * wtf/posix/FileSystemPOSIX.cpp:
     19        (WTF::FileSystemImpl::pathByAppendingComponents):
     20        * wtf/text/StringBuilder.h:
     21        (WTF::StringBuilder::appendFromAdapters):
     22        (WTF::StringBuilder::append):
     23        (WTF::StringBuilder::flexibleAppendFromAdapters): Deleted.
     24        (WTF::StringBuilder::flexibleAppend): Deleted.
     25        Update for rename from StringBuilder::flexibleAppend(...) to StringBuilder::append(...).
     26
    1272019-08-15  Ryosuke Niwa  <rniwa@webkit.org>
    228

  • trunk/Source/WTF/wtf/posix/FileSystemPOSIX.cpp

    r248702 r248822  
    309309    builder.append(path);
    310310    for (auto& component : components)
    311         builder.flexibleAppend('/', component);
     311        builder.append('/', component);
    312312    return builder.toString();
    313313}

  • trunk/Source/WTF/wtf/text/StringBuilder.h

    r248659 r248822  
    236236    WTF_EXPORT_PRIVATE void appendFixedWidthNumber(double, unsigned decimalPlaces);
    237237
    238     // FIXME: Rename to append(...) after renaming any overloads of append that take more than one argument.
    239     template<typename... StringTypes> void flexibleAppend(StringTypes...);
     238    template<typename... StringTypes> void append(StringTypes...);
    240239
    241240    String toString()
    … …  
    369368    WTF_EXPORT_PRIVATE void reifyString() const;
    370369
    371     template<typename... StringTypeAdapters> void flexibleAppendFromAdapters(StringTypeAdapters...);
     370    template<typename... StringTypeAdapters> void appendFromAdapters(StringTypeAdapters...);
    372371
    373372    mutable String m_string;
    … …  
    400399
    401400template<typename... StringTypeAdapters>
    402 void StringBuilder::flexibleAppendFromAdapters(StringTypeAdapters... adapters)
     401void StringBuilder::appendFromAdapters(StringTypeAdapters... adapters)
    403402{
    404403    auto requiredLength = checkedSum<int32_t>(m_length, adapters.length()...);
    … …  
    426425
    427426template<typename... StringTypes>
    428 void StringBuilder::flexibleAppend(StringTypes... strings)
    429 {
    430     flexibleAppendFromAdapters(StringTypeAdapter<StringTypes>(strings)...);
     427void StringBuilder::append(StringTypes... strings)
     428{
     429    appendFromAdapters(StringTypeAdapter<StringTypes>(strings)...);
    431430}
    432431

  • trunk/Source/WebCore/ChangeLog

    r248816 r248822  
     12019-08-17  Sam Weinig  <weinig@apple.com>
     2
     3        Rename StringBuilder::flexibleAppend(...) to StringBuilder::append(...)
     4        https://bugs.webkit.org/show_bug.cgi?id=200756
     5
     6        Reviewed by Darin Adler.
     7
     8        Update call sites for rename from StringBuilder::flexibleAppend(...) to
     9        StringBuilder::append(...).
     10
     11        * Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp:
     12        (WebCore::WHLSL::Metal::EntryPointScaffolding::emitResourceHelperTypes):
     13        (WebCore::WHLSL::Metal::EntryPointScaffolding::emitResourceSignature):
     14        (WebCore::WHLSL::Metal::EntryPointScaffolding::emitBuiltInsSignature):
     15        (WebCore::WHLSL::Metal::EntryPointScaffolding::emitMangledInputPath):
     16        (WebCore::WHLSL::Metal::EntryPointScaffolding::emitMangledOutputPath):
     17        (WebCore::WHLSL::Metal::EntryPointScaffolding::emitUnpackResourcesAndNamedBuiltIns):
     18        (WebCore::WHLSL::Metal::VertexEntryPointScaffolding::emitHelperTypes):
     19        (WebCore::WHLSL::Metal::VertexEntryPointScaffolding::emitSignature):
     20        (WebCore::WHLSL::Metal::VertexEntryPointScaffolding::emitUnpack):
     21        (WebCore::WHLSL::Metal::VertexEntryPointScaffolding::emitPack):
     22        (WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::emitHelperTypes):
     23        (WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::emitSignature):
     24        (WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::emitUnpack):
     25        (WebCore::WHLSL::Metal::FragmentEntryPointScaffolding::emitPack):
     26        (WebCore::WHLSL::Metal::ComputeEntryPointScaffolding::emitSignature):
     27        * Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp:
     28        (WebCore::WHLSL::Metal::declareFunction):
     29        (WebCore::WHLSL::Metal::FunctionDefinitionWriter::visit):
     30        (WebCore::WHLSL::Metal::FunctionDefinitionWriter::emitLoop):
     31        (WebCore::WHLSL::Metal::FunctionDefinitionWriter::emitConstantExpressionString):
     32        * Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp:
     33        (WebCore::WHLSL::Metal::inlineNativeFunction):
     34        * Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp:
     35        (WebCore::WHLSL::Metal::TypeNamer::emitUnnamedTypeDefinition):
     36        (WebCore::WHLSL::Metal::TypeNamer::emitNamedTypeDefinition):
     37        * Modules/webgpu/WHLSL/WHLSLParser.cpp:
     38        (WebCore::WHLSL::Types::appendNameTo):
     39        * rendering/RenderLayerCompositor.cpp:
     40        (WebCore::RenderLayerCompositor::logLayerInfo):
     41        * testing/Internals.cpp:
     42        (WebCore::Internals::ongoingLoadsDescriptions const):
     43
    1442019-08-16  Commit Queue  <commit-queue@webkit.org>
    245

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLEntryPointScaffolding.cpp

    r248307 r248822  
    143143{
    144144    for (size_t i = 0; i < m_layout.size(); ++i) {
    145         stringBuilder.flexibleAppend("struct ", m_namedBindGroups[i].structName, " {\n");
     145        stringBuilder.append("struct ", m_namedBindGroups[i].structName, " {\n");
    146146        Vector<std::pair<unsigned, String>> structItems;
    147147        for (size_t j = 0; j < m_layout[i].bindings.size(); ++j) {
    … …  
    171171        });
    172172        for (const auto& structItem : structItems)
    173             stringBuilder.flexibleAppend("    ", structItem.second, '\n');
     173            stringBuilder.append("    ", structItem.second, '\n');
    174174        stringBuilder.append("};\n\n");
    175175    }
    … …  
    188188            stringBuilder.append(", ");
    189189        auto& namedBindGroup = m_namedBindGroups[i];
    190         stringBuilder.flexibleAppend("device ", namedBindGroup.structName, "& ", namedBindGroup.variableName, " [[buffer(", namedBindGroup.argumentBufferIndex, ")]]");
     190        stringBuilder.append("device ", namedBindGroup.structName, "& ", namedBindGroup.variableName, " [[buffer(", namedBindGroup.argumentBufferIndex, ")]]");
    191191    }
    192192    return true;
    … …  
    244244        auto internalType = internalTypeForSemantic(builtInSemantic);
    245245        if (!internalType.isNull())
    246             stringBuilder.flexibleAppend(internalType);
     246            stringBuilder.append(internalType);
    247247        else
    248             stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(*item.unnamedType));
    249         stringBuilder.flexibleAppend(' ', namedBuiltIn.variableName, ' ', attributeForSemantic(builtInSemantic));
     248            stringBuilder.append(m_typeNamer.mangledNameForType(*item.unnamedType));
     249        stringBuilder.append(' ', namedBuiltIn.variableName, ' ', attributeForSemantic(builtInSemantic));
    250250    }
    251251    return true;
    … …  
    259259    for (size_t i = 0; i < m_functionDefinition.parameters().size(); ++i) {
    260260        if (m_functionDefinition.parameters()[i]->name() == path[0]) {
    261             stringBuilder.flexibleAppend(m_parameterVariables[i]);
     261            stringBuilder.append(m_parameterVariables[i]);
    262262            auto& unifyNode = m_functionDefinition.parameters()[i]->type()->unifyNode();
    263263            if (is<AST::NamedType>(unifyNode)) {
    … …  
    275275        auto* next = structureDefinition->find(path[i]);
    276276        ASSERT(next);
    277         stringBuilder.flexibleAppend('.', m_typeNamer.mangledNameForStructureElement(*next));
     277        stringBuilder.append('.', m_typeNamer.mangledNameForStructureElement(*next));
    278278        structureDefinition = nullptr;
    279279        auto& unifyNode = next->type().unifyNode();
    … …  
    295295        auto* next = structureDefinition->find(component);
    296296        ASSERT(next);
    297         stringBuilder.flexibleAppend('.', m_typeNamer.mangledNameForStructureElement(*next));
     297        stringBuilder.append('.', m_typeNamer.mangledNameForStructureElement(*next));
    298298        structureDefinition = nullptr;
    299299        auto& unifyNode = next->type().unifyNode();
    … …  
    309309{
    310310    for (size_t i = 0; i < m_functionDefinition.parameters().size(); ++i)
    311         stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(*m_functionDefinition.parameters()[i]->type()), ' ', m_parameterVariables[i], ";\n");
     311        stringBuilder.append(m_typeNamer.mangledNameForType(*m_functionDefinition.parameters()[i]->type()), ' ', m_parameterVariables[i], ";\n");
    312312
    313313    for (size_t i = 0; i < m_layout.size(); ++i) {
    … …  
    326326                auto mangledTypeName = m_typeNamer.mangledNameForType(downcast<AST::ReferenceType>(unnamedType).elementType());
    327327
    328                 stringBuilder.flexibleAppend(
     328                stringBuilder.append(
    329329                    "size_t ", lengthTemporaryName, " = ", variableName, '.', lengthElementName, ".y;\n",
    330330                    lengthTemporaryName, " = ", lengthTemporaryName, " << 32;\n",
    … …  
    335335                   
    336336                emitMangledInputPath(stringBuilder, path);
    337                 stringBuilder.flexibleAppend(
     337                stringBuilder.append(
    338338                    " = { ", variableName, '.', elementName, ", static_cast<uint32_t>(", lengthTemporaryName, ") };\n"
    339339                );
    … …  
    343343               
    344344                emitMangledInputPath(stringBuilder, path);
    345                 stringBuilder.flexibleAppend(" = ", variableName, '.', elementName, ";\n");
     345                stringBuilder.append(" = ", variableName, '.', elementName, ";\n");
    346346            }
    347347        }
    … …  
    355355
    356356        emitMangledInputPath(stringBuilder, path);
    357         stringBuilder.flexibleAppend(" = ", mangledTypeName, '(', variableName, ");\n");
     357        stringBuilder.append(" = ", mangledTypeName, '(', variableName, ");\n");
    358358    }
    359359}
    … …  
    393393void VertexEntryPointScaffolding::emitHelperTypes(StringBuilder& stringBuilder)
    394394{
    395     stringBuilder.flexibleAppend("struct ", m_stageInStructName, " {\n");
     395    stringBuilder.append("struct ", m_stageInStructName, " {\n");
    396396    for (auto& namedStageIn : m_namedStageIns) {
    397397        auto mangledTypeName = m_typeNamer.mangledNameForType(*m_entryPointItems.inputs[namedStageIn.indexInEntryPointItems].unnamedType);
    398398        auto elementName = namedStageIn.elementName;
    399399        auto attributeIndex = namedStageIn.attributeIndex;
    400         stringBuilder.flexibleAppend("    ", mangledTypeName, ' ', elementName, " [[attribute(", attributeIndex, ")]];\n");
    401     }
    402     stringBuilder.flexibleAppend(
     400        stringBuilder.append("    ", mangledTypeName, ' ', elementName, " [[attribute(", attributeIndex, ")]];\n");
     401    }
     402    stringBuilder.append(
    403403        "};\n\n"
    404404        "struct ", m_returnStructName, " {\n"
    … …  
    409409        auto elementName = m_namedOutputs[i].elementName;
    410410        auto attribute = attributeForSemantic(*outputItem.semantic);
    411         stringBuilder.flexibleAppend("    ", internalTypeName, ' ', elementName, ' ', attribute, ";\n");
     411        stringBuilder.append("    ", internalTypeName, ' ', elementName, ' ', attribute, ";\n");
    412412    }
    413413    stringBuilder.append(
    … …  
    420420void VertexEntryPointScaffolding::emitSignature(StringBuilder& stringBuilder, MangledFunctionName functionName)
    421421{
    422     stringBuilder.flexibleAppend("vertex ", m_returnStructName, ' ', functionName, '(', m_stageInStructName, ' ', m_stageInParameterName, " [[stage_in]]");
     422    stringBuilder.append("vertex ", m_returnStructName, ' ', functionName, '(', m_stageInStructName, ' ', m_stageInParameterName, " [[stage_in]]");
    423423    emitResourceSignature(stringBuilder, IncludePrecedingComma::Yes);
    424424    emitBuiltInsSignature(stringBuilder, IncludePrecedingComma::Yes);
    … …  
    434434        auto& elementName = namedStageIn.elementName;
    435435        emitMangledInputPath(stringBuilder, path);
    436         stringBuilder.flexibleAppend(" = ", m_stageInParameterName, '.', elementName, ";\n");
     436        stringBuilder.append(" = ", m_stageInParameterName, '.', elementName, ";\n");
    437437    }
    438438}
    … …  
    440440void VertexEntryPointScaffolding::emitPack(StringBuilder& stringBuilder, MangledVariableName inputVariableName, MangledVariableName outputVariableName)
    441441{
    442     stringBuilder.flexibleAppend(m_returnStructName, ' ', outputVariableName, ";\n");
     442    stringBuilder.append(m_returnStructName, ' ', outputVariableName, ";\n");
    443443    if (m_entryPointItems.outputs.size() == 1 && !m_entryPointItems.outputs[0].path.size()) {
    444444        auto& elementName = m_namedOutputs[0].elementName;
    445         stringBuilder.flexibleAppend(outputVariableName, '.', elementName, " = ", inputVariableName, ";\n");
     445        stringBuilder.append(outputVariableName, '.', elementName, " = ", inputVariableName, ";\n");
    446446        return;
    447447    }
    … …  
    450450        auto& internalTypeName = m_namedOutputs[i].internalTypeName;
    451451        auto& path = m_entryPointItems.outputs[i].path;
    452         stringBuilder.flexibleAppend(outputVariableName, '.', elementName, " = ", internalTypeName, '(', inputVariableName);
     452        stringBuilder.append(outputVariableName, '.', elementName, " = ", internalTypeName, '(', inputVariableName);
    453453        emitMangledOutputPath(stringBuilder, path);
    454         stringBuilder.flexibleAppend(");\n");
     454        stringBuilder.append(");\n");
    455455    }
    456456}
    … …  
    492492void FragmentEntryPointScaffolding::emitHelperTypes(StringBuilder& stringBuilder)
    493493{
    494     stringBuilder.flexibleAppend("struct ", m_stageInStructName, " {\n");
     494    stringBuilder.append("struct ", m_stageInStructName, " {\n");
    495495    for (auto& namedStageIn : m_namedStageIns) {
    496496        auto mangledTypeName = m_typeNamer.mangledNameForType(*m_entryPointItems.inputs[namedStageIn.indexInEntryPointItems].unnamedType);
    497497        auto elementName = namedStageIn.elementName;
    498498        auto attributeIndex = namedStageIn.attributeIndex;
    499         stringBuilder.flexibleAppend("    ", mangledTypeName, ' ', elementName, " [[user(user", attributeIndex, ")]];\n");
    500     }
    501     stringBuilder.flexibleAppend(
     499        stringBuilder.append("    ", mangledTypeName, ' ', elementName, " [[user(user", attributeIndex, ")]];\n");
     500    }
     501    stringBuilder.append(
    502502        "};\n\n"
    503503        "struct ", m_returnStructName, " {\n"
    … …  
    508508        auto elementName = m_namedOutputs[i].elementName;
    509509        auto attribute = attributeForSemantic(*outputItem.semantic);
    510         stringBuilder.flexibleAppend("    ", internalTypeName, ' ', elementName, ' ', attribute, ";\n");
     510        stringBuilder.append("    ", internalTypeName, ' ', elementName, ' ', attribute, ";\n");
    511511    }
    512512    stringBuilder.append(
    … …  
    519519void FragmentEntryPointScaffolding::emitSignature(StringBuilder& stringBuilder, MangledFunctionName functionName)
    520520{
    521     stringBuilder.flexibleAppend("fragment ", m_returnStructName, ' ', functionName, '(', m_stageInStructName, ' ', m_stageInParameterName, " [[stage_in]]");
     521    stringBuilder.append("fragment ", m_returnStructName, ' ', functionName, '(', m_stageInStructName, ' ', m_stageInParameterName, " [[stage_in]]");
    522522    emitResourceSignature(stringBuilder, IncludePrecedingComma::Yes);
    523523    emitBuiltInsSignature(stringBuilder, IncludePrecedingComma::Yes);
    … …  
    533533        auto& elementName = namedStageIn.elementName;
    534534        emitMangledInputPath(stringBuilder, path);
    535         stringBuilder.flexibleAppend(" = ", m_stageInParameterName, '.', elementName, ";\n");
     535        stringBuilder.append(" = ", m_stageInParameterName, '.', elementName, ";\n");
    536536    }
    537537}
    … …  
    539539void FragmentEntryPointScaffolding::emitPack(StringBuilder& stringBuilder, MangledVariableName inputVariableName, MangledVariableName outputVariableName)
    540540{
    541     stringBuilder.flexibleAppend(m_returnStructName, ' ', outputVariableName, ";\n");
     541    stringBuilder.append(m_returnStructName, ' ', outputVariableName, ";\n");
    542542    if (m_entryPointItems.outputs.size() == 1 && !m_entryPointItems.outputs[0].path.size()) {
    543543        auto& elementName = m_namedOutputs[0].elementName;
    544         stringBuilder.flexibleAppend(outputVariableName, '.', elementName, " = ", inputVariableName, ";\n");
     544        stringBuilder.append(outputVariableName, '.', elementName, " = ", inputVariableName, ";\n");
    545545        return;
    546546    }
    … …  
    549549        auto& internalTypeName = m_namedOutputs[i].internalTypeName;
    550550        auto& path = m_entryPointItems.outputs[i].path;
    551         stringBuilder.flexibleAppend(outputVariableName, '.', elementName, " = ", internalTypeName, '(', inputVariableName);
     551        stringBuilder.append(outputVariableName, '.', elementName, " = ", internalTypeName, '(', inputVariableName);
    552552        emitMangledOutputPath(stringBuilder, path);
    553         stringBuilder.flexibleAppend(");\n");
     553        stringBuilder.append(");\n");
    554554    }
    555555}
    … …  
    567567void ComputeEntryPointScaffolding::emitSignature(StringBuilder& stringBuilder, MangledFunctionName functionName)
    568568{
    569     stringBuilder.flexibleAppend("kernel void ", functionName, '(');
     569    stringBuilder.append("kernel void ", functionName, '(');
    570570    bool addedToSignature = emitResourceSignature(stringBuilder, IncludePrecedingComma::No);
    571571    emitBuiltInsSignature(stringBuilder, addedToSignature ? IncludePrecedingComma::Yes : IncludePrecedingComma::No);

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLFunctionWriter.cpp

    r248729 r248822  
    5555    auto iterator = functionMapping.find(&functionDeclaration);
    5656    ASSERT(iterator != functionMapping.end());
    57     stringBuilder.flexibleAppend(typeNamer.mangledNameForType(functionDeclaration.type()), ' ', iterator->value, '(');
     57    stringBuilder.append(typeNamer.mangledNameForType(functionDeclaration.type()), ' ', iterator->value, '(');
    5858    for (size_t i = 0; i < functionDeclaration.parameters().size(); ++i) {
    5959        if (i)
    6060            stringBuilder.append(", ");
    61         stringBuilder.flexibleAppend(typeNamer.mangledNameForType(*functionDeclaration.parameters()[i]->type()));
     61        stringBuilder.append(typeNamer.mangledNameForType(*functionDeclaration.parameters()[i]->type()));
    6262    }
    6363    stringBuilder.append(");\n");
    … …  
    238238    } else {
    239239        ASSERT(m_entryPointScaffolding == nullptr);
    240         m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(functionDefinition.type()), ' ', iterator->value, '(');
     240        m_stringBuilder.append(m_typeNamer.mangledNameForType(functionDefinition.type()), ' ', iterator->value, '(');
    241241        for (size_t i = 0; i < functionDefinition.parameters().size(); ++i) {
    242242            auto& parameter = functionDefinition.parameters()[i];
    … …  
    246246            auto addResult = m_variableMapping.add(&parameter, parameterName);
    247247            ASSERT_UNUSED(addResult, addResult.isNewEntry);
    248             m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(*parameter->type()), ' ', parameterName);
     248            m_stringBuilder.append(m_typeNamer.mangledNameForType(*parameter->type()), ' ', parameterName);
    249249        }
    250250        m_stringBuilder.append(")\n");
    … …  
    282282    case BreakContext::Loop:
    283283        ASSERT(m_breakOutOfCurrentLoopEarlyVariable);
    284         m_stringBuilder.flexibleAppend(
     284        m_stringBuilder.append(
    285285            *m_breakOutOfCurrentLoopEarlyVariable, " = true;\n"
    286286            "break;\n"
    … …  
    311311    SetForScope<Optional<MangledVariableName>> loopVariableScope(m_breakOutOfCurrentLoopEarlyVariable, generateNextVariableName());
    312312
    313     m_stringBuilder.flexibleAppend(
     313    m_stringBuilder.append(
    314314        "bool ", *m_breakOutOfCurrentLoopEarlyVariable, " = false;\n",
    315315        "while (true) {\n"
    … …  
    318318    if (loopConditionLocation == LoopConditionLocation::BeforeBody && conditionExpression) {
    319319        checkErrorAndVisit(*conditionExpression);
    320         m_stringBuilder.flexibleAppend("if (!", takeLastValue(), ") break;\n");
     320        m_stringBuilder.append("if (!", takeLastValue(), ") break;\n");
    321321    }
    322322
    … …  
    324324    SetForScope<Optional<BreakContext>> breakContext(m_currentBreakContext, BreakContext::Loop);
    325325    checkErrorAndVisit(body);
    326     m_stringBuilder.flexibleAppend(
     326    m_stringBuilder.append(
    327327        "} while(false); \n"
    328328        "if (", *m_breakOutOfCurrentLoopEarlyVariable, ") break;\n"
    … …  
    338338    if (loopConditionLocation == LoopConditionLocation::AfterBody && conditionExpression) {
    339339        checkErrorAndVisit(*conditionExpression);
    340         m_stringBuilder.flexibleAppend("if (!", takeLastValue(), ") break;\n");
     340        m_stringBuilder.append("if (!", takeLastValue(), ") break;\n");
    341341    }
    342342
    … …  
    365365{
    366366    checkErrorAndVisit(ifStatement.conditional());
    367     m_stringBuilder.flexibleAppend("if (", takeLastValue(), ") {\n");
     367    m_stringBuilder.append("if (", takeLastValue(), ") {\n");
    368368    checkErrorAndVisit(ifStatement.body());
    369369    if (ifStatement.elseBody()) {
    … …  
    381381            auto variableName = generateNextVariableName();
    382382            m_entryPointScaffolding->emitPack(m_stringBuilder, takeLastValue(), variableName);
    383             m_stringBuilder.flexibleAppend("return ", variableName, ";\n");
     383            m_stringBuilder.append("return ", variableName, ";\n");
    384384        } else
    385             m_stringBuilder.flexibleAppend("return ", takeLastValue(), ";\n");
     385            m_stringBuilder.append("return ", takeLastValue(), ";\n");
    386386    } else
    387387        m_stringBuilder.append("return;\n");
    … …  
    392392    checkErrorAndVisit(switchStatement.value());
    393393
    394     m_stringBuilder.flexibleAppend("switch (", takeLastValue(), ") {");
     394    m_stringBuilder.append("switch (", takeLastValue(), ") {");
    395395    for (auto& switchCase : switchStatement.switchCases())
    396396        checkErrorAndVisit(switchCase);
    … …  
    401401{
    402402    if (switchCase.value()) {
    403         m_stringBuilder.flexibleAppend("case ");
     403        m_stringBuilder.append("case ");
    404404        emitConstantExpressionString(*switchCase.value());
    405         m_stringBuilder.flexibleAppend(":\n");
     405        m_stringBuilder.append(":\n");
    406406    } else
    407407        m_stringBuilder.append("default:\n");
    … …  
    420420    auto variableName = generateNextVariableName();
    421421    auto mangledTypeName = m_typeNamer.mangledNameForType(integerLiteral.resolvedType());
    422     m_stringBuilder.flexibleAppend(mangledTypeName, ' ', variableName, " = static_cast<", mangledTypeName, ">(", integerLiteral.value(), ");\n");
     422    m_stringBuilder.append(mangledTypeName, ' ', variableName, " = static_cast<", mangledTypeName, ">(", integerLiteral.value(), ");\n");
    423423    appendRightValue(integerLiteral, variableName);
    424424}
    … …  
    428428    auto variableName = generateNextVariableName();
    429429    auto mangledTypeName = m_typeNamer.mangledNameForType(unsignedIntegerLiteral.resolvedType());
    430     m_stringBuilder.flexibleAppend(mangledTypeName, ' ', variableName, " = static_cast<", mangledTypeName, ">(", unsignedIntegerLiteral.value(), ");\n");
     430    m_stringBuilder.append(mangledTypeName, ' ', variableName, " = static_cast<", mangledTypeName, ">(", unsignedIntegerLiteral.value(), ");\n");
    431431    appendRightValue(unsignedIntegerLiteral, variableName);
    432432}
    … …  
    436436    auto variableName = generateNextVariableName();
    437437    auto mangledTypeName = m_typeNamer.mangledNameForType(floatLiteral.resolvedType());
    438     m_stringBuilder.flexibleAppend(mangledTypeName, ' ', variableName, " = static_cast<", mangledTypeName, ">(", floatLiteral.value(), ");\n");
     438    m_stringBuilder.append(mangledTypeName, ' ', variableName, " = static_cast<", mangledTypeName, ">(", floatLiteral.value(), ");\n");
    439439    appendRightValue(floatLiteral, variableName);
    440440}
    … …  
    447447
    448448    auto variableName = generateNextVariableName();
    449     m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(nullLiteral.resolvedType()), ' ', variableName, " = ");
     449    m_stringBuilder.append(m_typeNamer.mangledNameForType(nullLiteral.resolvedType()), ' ', variableName, " = ");
    450450    if (isArrayReferenceType)
    451451        m_stringBuilder.append("{ nullptr, 0 };\n");
    … …  
    459459    auto variableName = generateNextVariableName();
    460460    auto mangledTypeName = m_typeNamer.mangledNameForType(booleanLiteral.resolvedType());
    461     m_stringBuilder.flexibleAppend(mangledTypeName, ' ', variableName, " = static_cast<", mangledTypeName, ">(", booleanLiteral.value() ? "true" : "false", ");\n");
     461    m_stringBuilder.append(mangledTypeName, ' ', variableName, " = static_cast<", mangledTypeName, ">(", booleanLiteral.value() ? "true" : "false", ");\n");
    462462    appendRightValue(booleanLiteral, variableName);
    463463}
    … …  
    469469    auto variableName = generateNextVariableName();
    470470    auto mangledTypeName = m_typeNamer.mangledNameForType(enumerationMemberLiteral.resolvedType());
    471     m_stringBuilder.flexibleAppend(mangledTypeName, ' ', variableName, " = ", mangledTypeName, "::", m_typeNamer.mangledNameForEnumerationMember(*enumerationMemberLiteral.enumerationMember()), ";\n");
     471    m_stringBuilder.append(mangledTypeName, ' ', variableName, " = ", mangledTypeName, "::", m_typeNamer.mangledNameForEnumerationMember(*enumerationMemberLiteral.enumerationMember()), ";\n");
    472472    appendRightValue(enumerationMemberLiteral, variableName);
    473473}
    … …  
    492492    auto mangledTypeName = m_typeNamer.mangledNameForType(globalVariableReference.resolvedType());
    493493    checkErrorAndVisit(globalVariableReference.base());
    494     m_stringBuilder.flexibleAppend(
     494    m_stringBuilder.append(
    495495        "thread ", mangledTypeName, "* ", pointerName, " = &", takeLastValue(), "->", m_typeNamer.mangledNameForStructureElement(globalVariableReference.structField()), ";\n",
    496496        mangledTypeName, ' ', valueName, " = ", "*", pointerName, ";\n"
    … …  
    524524    if (variableDeclaration.initializer()) {
    525525        checkErrorAndVisit(*variableDeclaration.initializer());
    526         m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(*variableDeclaration.type()), ' ', variableName, " = ", takeLastValue(), ";\n");
     526        m_stringBuilder.append(m_typeNamer.mangledNameForType(*variableDeclaration.type()), ' ', variableName, " = ", takeLastValue(), ";\n");
    527527    } else
    528         m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(*variableDeclaration.type()), ' ', variableName, " = { };\n");
     528        m_stringBuilder.append(m_typeNamer.mangledNameForType(*variableDeclaration.type()), ' ', variableName, " = { };\n");
    529529}
    530530
    … …  
    536536    auto [rightName, rightNullability] = takeLastValueAndNullability();
    537537    if (nullability == Nullability::CanBeNull)
    538         m_stringBuilder.flexibleAppend("if (", pointerName, ") *", pointerName, " = ", rightName, ";\n");
     538        m_stringBuilder.append("if (", pointerName, ") *", pointerName, " = ", rightName, ";\n");
    539539    else
    540         m_stringBuilder.flexibleAppend("*", pointerName, " = ", rightName, ";\n");
     540        m_stringBuilder.append("*", pointerName, " = ", rightName, ";\n");
    541541    appendRightValueWithNullability(assignmentExpression, rightName, rightNullability);
    542542}
    … …  
    554554    if (!isVoid) {
    555555        returnName = generateNextVariableName();
    556         m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(callExpression.resolvedType()), ' ', returnName, ";\n");
     556        m_stringBuilder.append(m_typeNamer.mangledNameForType(callExpression.resolvedType()), ' ', returnName, ";\n");
    557557    }
    558558
    … …  
    563563        ASSERT(iterator != m_functionMapping.end());
    564564        if (!isVoid)
    565             m_stringBuilder.flexibleAppend(returnName, " = ");
    566         m_stringBuilder.flexibleAppend(iterator->value, '(');
     565            m_stringBuilder.append(returnName, " = ");
     566        m_stringBuilder.append(iterator->value, '(');
    567567        for (size_t i = 0; i < argumentNames.size(); ++i) {
    568568            if (i)
    569569                m_stringBuilder.append(", ");
    570             m_stringBuilder.flexibleAppend(argumentNames[i]);
     570            m_stringBuilder.append(argumentNames[i]);
    571571        }
    572572        m_stringBuilder.append(");\n");
    … …  
    593593    auto resultValue = generateNextVariableName();
    594594    auto resultPointer = generateNextVariableName();
    595     m_stringBuilder.flexibleAppend(
     595    m_stringBuilder.append(
    596596        m_typeNamer.mangledNameForType(dereferenceExpression.pointer().resolvedType()), ' ', resultPointer, " = ", inputPointer, ";\n",
    597597        m_typeNamer.mangledNameForType(dereferenceExpression.resolvedType()), ' ', resultValue, ";\n");
    598598    if (nullability == Nullability::CanBeNull) {
    599         m_stringBuilder.flexibleAppend(
     599        m_stringBuilder.append(
    600600            "if (", resultPointer, ") ", resultValue, " = *", inputPointer, ";\n",
    601601            "else ", resultValue, " = { };\n");
    602602    } else
    603         m_stringBuilder.flexibleAppend(resultValue, " = *", inputPointer, ";\n");
     603        m_stringBuilder.append(resultValue, " = *", inputPointer, ";\n");
    604604    appendLeftValue(dereferenceExpression, resultValue, resultPointer, nullability);
    605605}
    … …  
    612612    auto right = takeLastValue();
    613613    auto variableName = generateNextVariableName();
    614     m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(logicalExpression.resolvedType()), ' ', variableName, " = ", left);
     614    m_stringBuilder.append(m_typeNamer.mangledNameForType(logicalExpression.resolvedType()), ' ', variableName, " = ", left);
    615615    switch (logicalExpression.type()) {
    616616    case AST::LogicalExpression::Type::And:
    … …  
    622622        break;
    623623    }
    624     m_stringBuilder.flexibleAppend(right, ";\n");
     624    m_stringBuilder.append(right, ";\n");
    625625    appendRightValue(logicalExpression, variableName);
    626626}
    … …  
    631631    auto operand = takeLastValue();
    632632    auto variableName = generateNextVariableName();
    633     m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(logicalNotExpression.resolvedType()), ' ', variableName, " = !", operand, ";\n");
     633    m_stringBuilder.append(m_typeNamer.mangledNameForType(logicalNotExpression.resolvedType()), ' ', variableName, " = !", operand, ";\n");
    634634    appendRightValue(logicalNotExpression, variableName);
    635635}
    … …  
    645645    if (is<AST::PointerType>(makeArrayReferenceExpression.leftValue().resolvedType())) {
    646646        auto ptrValue = takeLastValue();
    647         m_stringBuilder.flexibleAppend(
     647        m_stringBuilder.append(
    648648            mangledTypeName, ' ', variableName, ";\n",
    649649            "if (", ptrValue, ") ", variableName, " = { ", ptrValue, ", 1};\n",
    … …  
    653653        auto lValue = takeLastLeftValue().value;
    654654        auto& arrayType = downcast<AST::ArrayType>(makeArrayReferenceExpression.leftValue().resolvedType());
    655         m_stringBuilder.flexibleAppend(mangledTypeName, ' ', variableName, " = { ", lValue, "->data(), ", arrayType.numElements(), " };\n");
     655        m_stringBuilder.append(mangledTypeName, ' ', variableName, " = { ", lValue, "->data(), ", arrayType.numElements(), " };\n");
    656656    } else {
    657657        auto lValue = takeLastLeftValue().value;
    658         m_stringBuilder.flexibleAppend(mangledTypeName, ' ', variableName, " = { ", lValue, ", 1 };\n");
     658        m_stringBuilder.append(mangledTypeName, ' ', variableName, " = { ", lValue, ", 1 };\n");
    659659    }
    660660    appendRightValue(makeArrayReferenceExpression, variableName);
    … …  
    666666    auto [pointer, nullability] = takeLastLeftValue();
    667667    auto variableName = generateNextVariableName();
    668     m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(makePointerExpression.resolvedType()), ' ', variableName, " = ", pointer, ";\n");
     668    m_stringBuilder.append(m_typeNamer.mangledNameForType(makePointerExpression.resolvedType()), ' ', variableName, " = ", pointer, ";\n");
    669669    appendRightValueWithNullability(makePointerExpression, variableName, nullability);
    670670}
    … …  
    686686
    687687    auto variableName = generateNextVariableName();
    688     m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(ternaryExpression.resolvedType()), ' ', variableName, " = ", check, " ? ", body, " : ", elseBody, ";\n");
     688    m_stringBuilder.append(m_typeNamer.mangledNameForType(ternaryExpression.resolvedType()), ' ', variableName, " = ", check, " ? ", body, " : ", elseBody, ";\n");
    689689    appendRightValue(ternaryExpression, variableName);
    690690}
    … …  
    696696    ASSERT(iterator != m_variableMapping.end());
    697697    auto pointerName = generateNextVariableName();
    698     m_stringBuilder.flexibleAppend("thread ", m_typeNamer.mangledNameForType(variableReference.resolvedType()), "* ", pointerName, " = &", iterator->value, ";\n");
     698    m_stringBuilder.append("thread ", m_typeNamer.mangledNameForType(variableReference.resolvedType()), "* ", pointerName, " = &", iterator->value, ";\n");
    699699    appendLeftValue(variableReference, iterator->value, pointerName, Nullability::NotNull);
    700700}
    … …  
    704704    constantExpression.visit(WTF::makeVisitor(
    705705        [&](AST::IntegerLiteral& integerLiteral) {
    706             m_stringBuilder.flexibleAppend(integerLiteral.value());
     706            m_stringBuilder.append(integerLiteral.value());
    707707        },
    708708        [&](AST::UnsignedIntegerLiteral& unsignedIntegerLiteral) {
    709             m_stringBuilder.flexibleAppend(unsignedIntegerLiteral.value());
     709            m_stringBuilder.append(unsignedIntegerLiteral.value());
    710710        },
    711711        [&](AST::FloatLiteral& floatLiteral) {
    712             m_stringBuilder.flexibleAppend(floatLiteral.value());
     712            m_stringBuilder.append(floatLiteral.value());
    713713        },
    714714        [&](AST::NullLiteral&) {
    715             m_stringBuilder.flexibleAppend("nullptr");
     715            m_stringBuilder.append("nullptr");
    716716        },
    717717        [&](AST::BooleanLiteral& booleanLiteral) {
    718718            if (booleanLiteral.value())
    719                 m_stringBuilder.flexibleAppend("true");
     719                m_stringBuilder.append("true");
    720720            else
    721                 m_stringBuilder.flexibleAppend("false");
     721                m_stringBuilder.append("false");
    722722        },
    723723        [&](AST::EnumerationMemberLiteral& enumerationMemberLiteral) {
    724724            ASSERT(enumerationMemberLiteral.enumerationDefinition());
    725725            ASSERT(enumerationMemberLiteral.enumerationDefinition());
    726             m_stringBuilder.flexibleAppend(m_typeNamer.mangledNameForType(*enumerationMemberLiteral.enumerationDefinition()), "::", m_typeNamer.mangledNameForEnumerationMember(*enumerationMemberLiteral.enumerationMember()));
     726            m_stringBuilder.append(m_typeNamer.mangledNameForType(*enumerationMemberLiteral.enumerationDefinition()), "::", m_typeNamer.mangledNameForEnumerationMember(*enumerationMemberLiteral.enumerationMember()));
    727727        }
    728728    ));

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLNativeFunctionWriter.cpp

    r248814 r248822  
    140140
    141141        if (!nativeFunctionDeclaration.parameters().size()) {
    142             stringBuilder.flexibleAppend(returnName, " = { };\n");
     142            stringBuilder.append(returnName, " = { };\n");
    143143            return;
    144144        }
    … …  
    148148            auto& parameterType = *nativeFunctionDeclaration.parameters()[0]->type();
    149149            auto metalParameterTypeName = typeNamer.mangledNameForType(parameterType);
    150             stringBuilder.flexibleAppend("{\n", metalParameterTypeName, " x = ", args[0], ";\n");
     150            stringBuilder.append("{\n", metalParameterTypeName, " x = ", args[0], ";\n");
    151151
    152152            {
    … …  
    161161                    for (auto& member : enumerationDefinition.enumerationMembers()) {
    162162                        hasZeroCase |= !member.get().value();
    163                         stringBuilder.flexibleAppend("        case ", member.get().value(), ": break;\n");
     163                        stringBuilder.append("        case ", member.get().value(), ": break;\n");
    164164                    }
    165165                    ASSERT_UNUSED(hasZeroCase, hasZeroCase);
    … …  
    168168            }
    169169
    170             stringBuilder.flexibleAppend(
     170            stringBuilder.append(
    171171                returnName, " = static_cast<", metalReturnTypeName, ">(x);\n}\n");
    172172
    … …  
    179179            RELEASE_ASSERT(nativeFunctionDeclaration.parameters().size() == numRows || nativeFunctionDeclaration.parameters().size() == numRows * numColumns);
    180180
    181             stringBuilder.flexibleAppend("{\n", metalReturnTypeName, " x;\n");
     181            stringBuilder.append("{\n", metalReturnTypeName, " x;\n");
    182182
    183183            // We need to abide by the memory layout we use for matrices here.
    … …  
    186186                for (unsigned i = 0; i < numRows; ++i) {
    187187                    for (unsigned j = 0; j < numColumns; ++j)
    188                         stringBuilder.flexibleAppend("x[", j * numRows + i, "] = ", args[i], "[", j, "];\n");
     188                        stringBuilder.append("x[", j * numRows + i, "] = ", args[i], "[", j, "];\n");
    189189                }
    190190
    … …  
    194194                for (unsigned i = 0; i < numRows; ++i) {
    195195                    for (unsigned j = 0; j < numColumns; ++j) {
    196                         stringBuilder.flexibleAppend("x[", j * numRows + i, "] = ", args[index], ";\n");
     196                        stringBuilder.append("x[", j * numRows + i, "] = ", args[index], ";\n");
    197197                        ++index;
    198198                    }
    … …  
    200200            }
    201201
    202             stringBuilder.flexibleAppend(returnName, " = x;\n}\n");
     202            stringBuilder.append(returnName, " = x;\n}\n");
    203203            return;
    204204        }
    205205
    206         stringBuilder.flexibleAppend(returnName, " = ", metalReturnTypeName, "(");
     206        stringBuilder.append(returnName, " = ", metalReturnTypeName, "(");
    207207        for (unsigned i = 0; i < nativeFunctionDeclaration.parameters().size(); ++i) {
    208208            if (i > 0)
    209209                stringBuilder.append(", ");
    210             stringBuilder.flexibleAppend(args[i]);
     210            stringBuilder.append(args[i]);
    211211        }
    212212        stringBuilder.append(");\n");
    … …  
    222222        if (is<AST::ArrayType>(unnamedParameterType)) {
    223223            auto& arrayParameterType = downcast<AST::ArrayType>(unnamedParameterType);
    224             stringBuilder.flexibleAppend(
     224            stringBuilder.append(
    225225                returnName, " = ", arrayParameterType.numElements(), ";\n");
    226226            return;
    … …  
    228228
    229229        ASSERT(is<AST::ArrayReferenceType>(unnamedParameterType));
    230         stringBuilder.flexibleAppend(
     230        stringBuilder.append(
    231231            returnName, " = ", args[0], ".length;\n");
    232232        return;
    … …  
    241241                auto* structureElement = structureDefinition.find(fieldName);
    242242                ASSERT(structureElement);
    243                 stringBuilder.flexibleAppend(typeNamer.mangledNameForStructureElement(*structureElement));
     243                stringBuilder.append(typeNamer.mangledNameForStructureElement(*structureElement));
    244244                return;
    245245            }
    … …  
    253253            fieldName = fieldName.substring(0, fieldName.length() - 1);
    254254
    255             stringBuilder.flexibleAppend(
     255            stringBuilder.append(
    256256                returnName, " = ", args[0], ";\n",
    257257                returnName, '.');
    258258            appendMangledFieldName(fieldName);
    259             stringBuilder.flexibleAppend(" = ", args[1], ";\n");
     259            stringBuilder.append(" = ", args[1], ";\n");
    260260
    261261            return;
    … …  
    264264        ASSERT(nativeFunctionDeclaration.parameters().size() == 1);
    265265        auto fieldName = nativeFunctionDeclaration.name().substring("operator."_str.length());
    266         stringBuilder.flexibleAppend(
     266        stringBuilder.append(
    267267            returnName, " = ", args[0], '.');
    268268        appendMangledFieldName(fieldName);
    … …  
    275275        auto fieldName = nativeFunctionDeclaration.name().substring("operator&."_str.length());
    276276
    277         stringBuilder.flexibleAppend(
     277        stringBuilder.append(
    278278            returnName, " = &(", args[0], "->");
    279279
    … …  
    285285            auto* structureElement = structureDefinition.find(fieldName);
    286286            ASSERT(structureElement);
    287             stringBuilder.flexibleAppend(typeNamer.mangledNameForStructureElement(*structureElement));
     287            stringBuilder.append(typeNamer.mangledNameForStructureElement(*structureElement));
    288288        } else
    289             stringBuilder.flexibleAppend(fieldName);
     289            stringBuilder.append(fieldName);
    290290
    291291        stringBuilder.append(");\n");
    … …  
    298298        ASSERT(is<AST::ArrayReferenceType>(*nativeFunctionDeclaration.parameters()[0]->type()));
    299299
    300         stringBuilder.flexibleAppend(
     300        stringBuilder.append(
    301301            returnName, " = (", args[1], " < ", args[0], ".length) ? ", " &(", args[0], ".pointer[", args[1], "]) : nullptr;\n");
    302302           
    … …  
    328328            unsigned numberOfRows = getMatrixType().numberOfMatrixRows();
    329329            unsigned numberOfColumns = getMatrixType().numberOfMatrixColumns();
    330             stringBuilder.flexibleAppend("do {\n", metalReturnName, " result;\n");
    331 
    332             stringBuilder.flexibleAppend(
     330            stringBuilder.append("do {\n", metalReturnName, " result;\n");
     331
     332            stringBuilder.append(
    333333                "    if (", args[1], " >= ", numberOfRows, ") {", returnName, " = ", metalReturnName, "(0); break;}\n",
    334334                "    result[0] = ", args[0], '[', args[1], "];\n",
    … …  
    336336
    337337            if (numberOfColumns >= 3)
    338                 stringBuilder.flexibleAppend("    result[2] = ", args[0], '[', args[1], " + ", numberOfRows * 2, "];\n");
     338                stringBuilder.append("    result[2] = ", args[0], '[', args[1], " + ", numberOfRows * 2, "];\n");
    339339            if (numberOfColumns >= 4)
    340                 stringBuilder.flexibleAppend("    result[3] = ", args[0], '[', args[1], " + ", numberOfRows * 3, "];\n");
    341 
    342             stringBuilder.flexibleAppend(
     340                stringBuilder.append("    result[3] = ", args[0], '[', args[1], " + ", numberOfRows * 3, "];\n");
     341
     342            stringBuilder.append(
    343343                "    ", returnName, " = result;\n",
    344344                "} while (0);\n");
    … …  
    349349            auto metalReturnName = typeNamer.mangledNameForType(nativeFunctionDeclaration.type());
    350350
    351             stringBuilder.flexibleAppend("do {\n", metalReturnName, " result;\n");
    352 
    353             stringBuilder.flexibleAppend(
     351            stringBuilder.append("do {\n", metalReturnName, " result;\n");
     352
     353            stringBuilder.append(
    354354                "    if (", args[1], " >= ", numElements, ") {", returnName, " = ", metalReturnName, "(0); break;}\n",
    355355                "    result = ", args[0], "[", args[1], "];\n");
    356             stringBuilder.flexibleAppend(
     356            stringBuilder.append(
    357357                "    ", returnName, " = result;\n",
    358358                "} while (0);\n");
    … …  
    373373            unsigned numberOfColumns = getMatrixType().numberOfMatrixColumns();
    374374
    375             stringBuilder.flexibleAppend("do {\n", metalReturnName, " m = ", args[0], ";\n",
     375            stringBuilder.append("do {\n", metalReturnName, " m = ", args[0], ";\n",
    376376                metalParameter2Name, " i = ", args[1], ";\n");
    377377
    378             stringBuilder.flexibleAppend(
     378            stringBuilder.append(
    379379                "    if (i >= ", numberOfRows, ") {", returnName, " = m;\nbreak;}\n",
    380380                "    m[i] = ", args[2], "[0];\n",
    381381                "    m[i + ", numberOfRows, "] = ", args[2], "[1];\n");
    382382            if (numberOfColumns >= 3)
    383                 stringBuilder.flexibleAppend("    m[i + ", numberOfRows * 2, "] = ", args[2], "[2];\n");
     383                stringBuilder.append("    m[i + ", numberOfRows * 2, "] = ", args[2], "[2];\n");
    384384            if (numberOfColumns >= 4)
    385                 stringBuilder.flexibleAppend("    m[i + ", numberOfRows * 3, "] = ", args[2], "[3];\n");
    386             stringBuilder.flexibleAppend(
     385                stringBuilder.append("    m[i + ", numberOfRows * 3, "] = ", args[2], "[3];\n");
     386            stringBuilder.append(
    387387                "    ", returnName, " = m;\n",
    388388                "} while(0);\n");
    … …  
    396396            unsigned numElements = vectorSize();
    397397
    398             stringBuilder.flexibleAppend("do {\n", metalReturnName, " v = ", args[0], ";\n",
     398            stringBuilder.append("do {\n", metalReturnName, " v = ", args[0], ";\n",
    399399                metalParameter2Name, " i = ", args[1], ";\n");
    400400
    401             stringBuilder.flexibleAppend(
     401            stringBuilder.append(
    402402                "    if (i >= ", numElements, ") {", returnName, " = v;\nbreak;}\n",
    403403                "    v[i] = ", args[2], ";\n");
    404             stringBuilder.flexibleAppend(
     404            stringBuilder.append(
    405405                "    ", returnName, " = v;\n",
    406406                "} while(0);\n");
    … …  
    415415        if (nativeFunctionDeclaration.parameters().size() == 1) {
    416416            if (auto* matrixType = asMatrixType(nativeFunctionDeclaration.type())) {
    417                 stringBuilder.flexibleAppend(
     417                stringBuilder.append(
    418418                    "{\n", metalReturnType, " x = ", args[0], ";\n",
    419419                    "for (size_t i = 0; i < x.size(); ++i) x[i] = ", operatorName, "x[i];\n",
    420420                    returnName, " = x;\n}\n");
    421421            } else {
    422                 stringBuilder.flexibleAppend(
     422                stringBuilder.append(
    423423                    "{\n", metalReturnType, " x = ", args[0], ";\n",
    424424                    returnName, " = ", operatorName, "x;\n}\n");
    … …  
    431431            if (auto* rightMatrix = asMatrixType(*nativeFunctionDeclaration.parameters()[1]->type())) {
    432432                // matrix <op> matrix
    433                 stringBuilder.flexibleAppend(
     433                stringBuilder.append(
    434434                    "{\n", metalReturnType, " x;\n",
    435435                    "for (size_t i = 0; i < x.size(); ++i) x[i] = ", args[0], "[i] ", operatorName, ' ', args[1], "[i];\n",
    … …  
    437437            } else {
    438438                // matrix <op> scalar
    439                 stringBuilder.flexibleAppend(
     439                stringBuilder.append(
    440440                    "{\n", metalReturnType, " x;\n",
    441441                    "for (size_t i = 0; i < x.size(); ++i) x[i] = ", args[0], "[i] ", operatorName, ' ', args[1], ";\n",
    … …  
    445445            ASSERT(!asMatrixType(*nativeFunctionDeclaration.parameters()[0]->type()));
    446446            // scalar <op> matrix
    447             stringBuilder.flexibleAppend(
     447            stringBuilder.append(
    448448                "{\n", metalReturnType, " x;\n",
    449449                "for (size_t i = 0; i < x.size(); ++i) x[i] = ", args[0], ' ', operatorName, ' ', args[1], "[i];\n",
    … …  
    454454            // vector <op> scalar
    455455            // scalar <op> vector
    456             stringBuilder.flexibleAppend(
     456            stringBuilder.append(
    457457                returnName, " = ", args[0], ' ', operatorName, ' ', args[1], ";\n");
    458458        }
    … …  
    487487        || nativeFunctionDeclaration.name() == "length") {
    488488        ASSERT(nativeFunctionDeclaration.parameters().size() == 1);
    489         stringBuilder.flexibleAppend(
     489        stringBuilder.append(
    490490            returnName, " = ", mapFunctionName(nativeFunctionDeclaration.name()), '(', args[0], ");\n");
    491491        return;
    … …  
    494494    if (nativeFunctionDeclaration.name() == "pow" || nativeFunctionDeclaration.name() == "atan2") {
    495495        ASSERT(nativeFunctionDeclaration.parameters().size() == 2);
    496         stringBuilder.flexibleAppend(
     496        stringBuilder.append(
    497497            returnName, " = ", nativeFunctionDeclaration.name(), "(", args[0], ", ", args[1], ");\n");
    498498        return;
    … …  
    503503        if (asMatrixType(nativeFunctionDeclaration.type())) {
    504504            auto metalReturnType = typeNamer.mangledNameForType(nativeFunctionDeclaration.type());
    505             stringBuilder.flexibleAppend(
     505            stringBuilder.append(
    506506                "{\n", metalReturnType, " x;\n",
    507507                "for (size_t i = 0; i < x.size(); ++i) x[i] = clamp(", args[0], "[i], ", args[1], "[i], ", args[2], "[i]);",
    508508                returnName, " = x;\n}\n");
    509509        } else {
    510             stringBuilder.flexibleAppend(
     510            stringBuilder.append(
    511511                returnName, " = clamp(", args[0], ", ", args[1], ", ", args[2], ");\n");
    512512        }
    … …  
    540540        if (nativeFunctionDeclaration.name() == "InterlockedCompareExchange") {
    541541            ASSERT(nativeFunctionDeclaration.parameters().size() == 4);
    542             stringBuilder.flexibleAppend(
     542            stringBuilder.append(
    543543                "atomic_compare_exchange_weak_explicit(", args[0], ", &", args[1], ", ", args[2], ", memory_order_relaxed, memory_order_relaxed);\n",
    544544                '*', args[3], " = ", args[1], ";\n");
    … …  
    548548        ASSERT(nativeFunctionDeclaration.parameters().size() == 3);
    549549        auto name = atomicName(nativeFunctionDeclaration.name().substring("Interlocked"_str.length()));
    550         stringBuilder.flexibleAppend(
     550        stringBuilder.append(
    551551            '*', args[2], " = atomic_", name, "_explicit(", args[0], ", ", args[1], ", memory_order_relaxed);\n");
    552552        return;
    … …  
    562562        auto returnVectorLength = vectorLength(returnType);
    563563
    564         stringBuilder.flexibleAppend(
     564        stringBuilder.append(
    565565            returnName, " = ", args[0], ".sample(", args[1], ", ");
    566566
    567567        if (textureType.isTextureArray()) {
    568568            ASSERT(locationVectorLength > 1);
    569             stringBuilder.flexibleAppend(args[2], '.', "xyzw"_str.substring(0, locationVectorLength - 1), ", ", args[2], '.', "xyzw"_str.substring(locationVectorLength - 1, 1));
     569            stringBuilder.append(args[2], '.', "xyzw"_str.substring(0, locationVectorLength - 1), ", ", args[2], '.', "xyzw"_str.substring(locationVectorLength - 1, 1));
    570570        } else
    571             stringBuilder.flexibleAppend(args[2]);
     571            stringBuilder.append(args[2]);
    572572        if (nativeFunctionDeclaration.parameters().size() == 4)
    573             stringBuilder.flexibleAppend(", ", args[3]);
     573            stringBuilder.append(", ", args[3]);
    574574        stringBuilder.append(")");
    575575        if (!textureType.isDepthTexture())
    576             stringBuilder.flexibleAppend(".", "xyzw"_str.substring(0, returnVectorLength));
     576            stringBuilder.append(".", "xyzw"_str.substring(0, returnVectorLength));
    577577        stringBuilder.append(";\n");
    578578
    … …  
    597597            for (int i = 0; i < locationVectorLength - 1; ++i) {
    598598                auto suffix = "xyzw"_str.substring(i, 1);
    599                 stringBuilder.flexibleAppend("    if (", args[1], '.', suffix, " < 0 || static_cast<uint32_t>(", args[1], '.', suffix, ") >= ", args[0], ".get_", dimensions[i], "()) {", returnName, " = ", metalReturnName, "(0); break;}\n");
     599                stringBuilder.append("    if (", args[1], '.', suffix, " < 0 || static_cast<uint32_t>(", args[1], '.', suffix, ") >= ", args[0], ".get_", dimensions[i], "()) {", returnName, " = ", metalReturnName, "(0); break;}\n");
    600600            }
    601601            auto suffix = "xyzw"_str.substring(locationVectorLength - 1, 1);
    602             stringBuilder.flexibleAppend("    if (", args[1], '.', suffix, " < 0 || static_cast<uint32_t>(", args[1], '.', suffix, ") >= ", args[0], ".get_array_size()) {", returnName, " = ", metalReturnName, "(0); break;}\n");
     602            stringBuilder.append("    if (", args[1], '.', suffix, " < 0 || static_cast<uint32_t>(", args[1], '.', suffix, ") >= ", args[0], ".get_array_size()) {", returnName, " = ", metalReturnName, "(0); break;}\n");
    603603        } else {
    604604            if (locationVectorLength == 1)
    605                 stringBuilder.flexibleAppend("    if (", args[1], " < 0 || static_cast<uint32_t>(", args[1], ") >= ", args[0], ".get_width()) { ", returnName, " = ", metalReturnName, "(0); break;}\n");
     605                stringBuilder.append("    if (", args[1], " < 0 || static_cast<uint32_t>(", args[1], ") >= ", args[0], ".get_width()) { ", returnName, " = ", metalReturnName, "(0); break;}\n");
    606606            else {
    607                 stringBuilder.flexibleAppend(
     607                stringBuilder.append(
    608608                    "    if (", args[1], ".x < 0 || static_cast<uint32_t>(", args[1], ".x) >= ", args[0], ".get_width()) {", returnName, " = ", metalReturnName, "(0); break;}\n"
    609609                    "    if (", args[1], ".y < 0 || static_cast<uint32_t>(", args[1], ".y) >= ", args[0], ".get_height()) {", returnName, " = ", metalReturnName, "(0); break;}\n");
    610610
    611611                if (locationVectorLength >= 3)
    612                     stringBuilder.flexibleAppend("    if (", args[1], ".z < 0 || static_cast<uint32_t>(", args[1], ".z) >= ", args[0], ".get_depth()) {", returnName, " = ", metalReturnName, "(0); break;}\n");
     612                    stringBuilder.append("    if (", args[1], ".z < 0 || static_cast<uint32_t>(", args[1], ".z) >= ", args[0], ".get_depth()) {", returnName, " = ", metalReturnName, "(0); break;}\n");
    613613            }
    614614        }
    615         stringBuilder.flexibleAppend("    ", returnName, " = ", args[0], ".read(");
     615        stringBuilder.append("    ", returnName, " = ", args[0], ".read(");
    616616        if (textureType.isTextureArray()) {
    617617            ASSERT(locationVectorLength > 1);
    618             stringBuilder.flexibleAppend("uint", vectorSuffix(locationVectorLength - 1), '(', args[1], '.', "xyzw"_str.substring(0, locationVectorLength - 1), "), uint(", args[1], '.', "xyzw"_str.substring(locationVectorLength - 1, 1), ')');
     618            stringBuilder.append("uint", vectorSuffix(locationVectorLength - 1), '(', args[1], '.', "xyzw"_str.substring(0, locationVectorLength - 1), "), uint(", args[1], '.', "xyzw"_str.substring(locationVectorLength - 1, 1), ')');
    619619        } else
    620             stringBuilder.flexibleAppend("uint", vectorSuffix(locationVectorLength), '(', args[1], ')');
     620            stringBuilder.append("uint", vectorSuffix(locationVectorLength), '(', args[1], ')');
    621621        stringBuilder.append(')');
    622622        if (!textureType.isDepthTexture())
    623             stringBuilder.flexibleAppend('.', "xyzw"_str.substring(0, returnVectorLength));
     623            stringBuilder.append('.', "xyzw"_str.substring(0, returnVectorLength));
    624624        stringBuilder.append(
    625625            ";\n"
    … …  
    631631    if (nativeFunctionDeclaration.name() == "load") {
    632632        ASSERT(nativeFunctionDeclaration.parameters().size() == 1);
    633         stringBuilder.flexibleAppend(
     633        stringBuilder.append(
    634634            returnName, " = atomic_load_explicit(", args[0], ", memory_order_relaxed);\n");
    635635        return;
    … …  
    638638    if (nativeFunctionDeclaration.name() == "store") {
    639639        ASSERT(nativeFunctionDeclaration.parameters().size() == 2);
    640         stringBuilder.flexibleAppend(
     640        stringBuilder.append(
    641641            "atomic_store_explicit(", args[0], ", ", args[1], ", memory_order_relaxed);\n");
    642642        return;
    … …  
    674674        ASSERT(index == nativeFunctionDeclaration.parameters().size());
    675675
    676         stringBuilder.flexibleAppend(
     676        stringBuilder.append(
    677677            "if (", widthName, ")\n"
    678678            "    *", widthName, " = ", args[0], ".get_width(");
    679679
    680680        if (hasMipLevel)
    681             stringBuilder.flexibleAppend(args[1]);
     681            stringBuilder.append(args[1]);
    682682        stringBuilder.append(");\n");
    683683        if (heightName) {
    684             stringBuilder.flexibleAppend(
     684            stringBuilder.append(
    685685                "    if (", *heightName, ")\n"
    686686                "        *", *heightName, " = ", args[0], ".get_height(");
    687687            if (hasMipLevel)
    688                 stringBuilder.flexibleAppend(args[1]);
     688                stringBuilder.append(args[1]);
    689689            stringBuilder.append(");\n");
    690690        }
    691691        if (depthName) {
    692             stringBuilder.flexibleAppend(
     692            stringBuilder.append(
    693693                "    if (", *depthName, ")\n"
    694694                "        *", *depthName, " = ", args[0], ".get_depth(");
    695695            if (hasMipLevel)
    696                 stringBuilder.flexibleAppend(args[1]);
     696                stringBuilder.append(args[1]);
    697697            stringBuilder.append(");\n");
    698698        }
    699699        if (elementsName) {
    700             stringBuilder.flexibleAppend(
     700            stringBuilder.append(
    701701                "    if (", *elementsName, ")\n"
    702702                "        *", *elementsName, " = ", args[0], ".get_array_size();\n");
    703703        }
    704704        if (numberOfLevelsName) {
    705             stringBuilder.flexibleAppend(
     705            stringBuilder.append(
    706706                "    if (", *numberOfLevelsName, ")\n"
    707707                "        *", *numberOfLevelsName, " = ", args[0], ".get_num_mip_levels();\n");
    … …  
    763763            for (int i = 0; i < locationVectorLength - 1; ++i) {
    764764                auto suffix = "xyzw"_str.substring(i, 1);
    765                 stringBuilder.flexibleAppend("    if (", args[2], ".", suffix, " >= ", args[0], ".get_", dimensions[i], "()) break;\n");
     765                stringBuilder.append("    if (", args[2], ".", suffix, " >= ", args[0], ".get_", dimensions[i], "()) break;\n");
    766766            }
    767767            auto suffix = "xyzw"_str.substring(locationVectorLength - 1, 1);
    768             stringBuilder.flexibleAppend("    if (", args[2], '.', suffix, " >= ", args[0], ".get_array_size()) break;\n");
     768            stringBuilder.append("    if (", args[2], '.', suffix, " >= ", args[0], ".get_array_size()) break;\n");
    769769        } else {
    770770            if (locationVectorLength == 1)
    771                 stringBuilder.flexibleAppend("    if (", args[2], " >= ", args[0], ".get_width()) break;\n");
     771                stringBuilder.append("    if (", args[2], " >= ", args[0], ".get_width()) break;\n");
    772772            else {
    773                 stringBuilder.flexibleAppend(
     773                stringBuilder.append(
    774774                    "    if (", args[2], ".x >= ", args[0], ".get_width()) break;\n"
    775775                    "    if (", args[2], ".y >= ", args[0], ".get_height()) break;\n");
    776776                if (locationVectorLength >= 3)
    777                     stringBuilder.flexibleAppend("    if (", args[2], ".z >= ", args[0], ".get_depth()) break;\n");
     777                    stringBuilder.append("    if (", args[2], ".z >= ", args[0], ".get_depth()) break;\n");
    778778            }
    779779        }
    780         stringBuilder.flexibleAppend("    ", args[0], ".write(vec<", metalInnerTypeName, ", 4>(", args[1]);
     780        stringBuilder.append("    ", args[0], ".write(vec<", metalInnerTypeName, ", 4>(", args[1]);
    781781        for (int i = 0; i < 4 - itemVectorLength; ++i)
    782782            stringBuilder.append(", 0");
    … …  
    784784        if (textureType.isTextureArray()) {
    785785            ASSERT(locationVectorLength > 1);
    786             stringBuilder.flexibleAppend("uint", vectorSuffix(locationVectorLength - 1), '(', args[2], '.', "xyzw"_str.substring(0, locationVectorLength - 1), "), uint(", args[2], ".", "xyzw"_str.substring(locationVectorLength - 1, 1), ')');
     786            stringBuilder.append("uint", vectorSuffix(locationVectorLength - 1), '(', args[2], '.', "xyzw"_str.substring(0, locationVectorLength - 1), "), uint(", args[2], ".", "xyzw"_str.substring(locationVectorLength - 1, 1), ')');
    787787        } else
    788             stringBuilder.flexibleAppend("uint", vectorSuffix(locationVectorLength), '(', args[2], ')');
     788            stringBuilder.append("uint", vectorSuffix(locationVectorLength), '(', args[2], ')');
    789789        stringBuilder.append(
    790790            ");\n"

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/Metal/WHLSLTypeNamer.cpp

    r248488 r248822  
    336336    void visit(AST::StructureDefinition& structureDefinition) override
    337337    {
    338         m_stringBuilder.flexibleAppend("struct ", m_mangledNameForNamedType(structureDefinition), ";\n");
     338        m_stringBuilder.append("struct ", m_mangledNameForNamedType(structureDefinition), ";\n");
    339339    }
    340340
    … …  
    363363        auto& namedType = downcast<ReferenceTypeNameNode>(baseTypeNameNode).namedType();
    364364        emitNamedTypeDefinition(stringBuilder, namedType, emittedNamedTypes, emittedUnnamedTypes);
    365         stringBuilder.flexibleAppend("typedef ", mangledNameForType(namedType), ' ', baseTypeNameNode.mangledName(), ";\n");
     365        stringBuilder.append("typedef ", mangledNameForType(namedType), ' ', baseTypeNameNode.mangledName(), ";\n");
    366366        break;
    367367    }
    … …  
    369369        auto& pointerType = downcast<PointerTypeNameNode>(baseTypeNameNode);
    370370        ASSERT(baseTypeNameNode.parent());
    371         stringBuilder.flexibleAppend("typedef ", toString(pointerType.addressSpace()), ' ', pointerType.parent()->mangledName(), "* ", pointerType.mangledName(), ";\n");
     371        stringBuilder.append("typedef ", toString(pointerType.addressSpace()), ' ', pointerType.parent()->mangledName(), "* ", pointerType.mangledName(), ";\n");
    372372        break;
    373373    }
    … …  
    375375        auto& arrayReferenceType = downcast<ArrayReferenceTypeNameNode>(baseTypeNameNode);
    376376        ASSERT(baseTypeNameNode.parent());
    377         stringBuilder.flexibleAppend(
     377        stringBuilder.append(
    378378            "struct ", arrayReferenceType.mangledName(), "{ \n"
    379379            "    ", toString(arrayReferenceType.addressSpace()), ' ', arrayReferenceType.parent()->mangledName(), "* pointer;\n"
    … …  
    386386        auto& arrayType = downcast<ArrayTypeNameNode>(baseTypeNameNode);
    387387        ASSERT(baseTypeNameNode.parent());
    388         stringBuilder.flexibleAppend("typedef array<", arrayType.parent()->mangledName(), ", ", arrayType.numElements(), "> ", arrayType.mangledName(), ";\n");
     388        stringBuilder.append("typedef array<", arrayType.parent()->mangledName(), ", ", arrayType.numElements(), "> ", arrayType.mangledName(), ";\n");
    389389        break;
    390390    }
    … …  
    407407        auto& enumerationDefinition = downcast<AST::EnumerationDefinition>(namedType);
    408408        auto& baseType = enumerationDefinition.type().unifyNode();
    409         stringBuilder.flexibleAppend("enum class ", mangledNameForType(enumerationDefinition), " : ", mangledNameForType(downcast<AST::NamedType>(baseType)), " {\n");
     409        stringBuilder.append("enum class ", mangledNameForType(enumerationDefinition), " : ", mangledNameForType(downcast<AST::NamedType>(baseType)), " {\n");
    410410        for (auto& enumerationMember : enumerationDefinition.enumerationMembers())
    411             stringBuilder.flexibleAppend("    ", mangledNameForEnumerationMember(enumerationMember), " = ", enumerationMember.get().value(), ",\n");
     411            stringBuilder.append("    ", mangledNameForEnumerationMember(enumerationMember), " = ", enumerationMember.get().value(), ",\n");
    412412        stringBuilder.append("};\n");
    413413    } else if (is<AST::NativeTypeDeclaration>(namedType)) {
    … …  
    415415    } else if (is<AST::StructureDefinition>(namedType)) {
    416416        auto& structureDefinition = downcast<AST::StructureDefinition>(namedType);
    417         stringBuilder.flexibleAppend("struct ", mangledNameForType(structureDefinition), " {\n");
     417        stringBuilder.append("struct ", mangledNameForType(structureDefinition), " {\n");
    418418        for (auto& structureElement : structureDefinition.structureElements())
    419             stringBuilder.flexibleAppend("    ", mangledNameForType(structureElement.type()), ' ', mangledNameForStructureElement(structureElement), ";\n");
     419            stringBuilder.append("    ", mangledNameForType(structureElement.type()), ' ', mangledNameForStructureElement(structureElement), ";\n");
    420420        stringBuilder.append("};\n");
    421421    } else {
    422422        auto& typeDefinition = downcast<AST::TypeDefinition>(namedType);
    423         stringBuilder.flexibleAppend("typedef ", mangledNameForType(typeDefinition.type()), ' ', mangledNameForType(typeDefinition), ";\n");
     423        stringBuilder.append("typedef ", mangledNameForType(typeDefinition.type()), ' ', mangledNameForType(typeDefinition), ";\n");
    424424    }
    425425    emittedNamedTypes.add(&namedType);

  • trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp

    r248650 r248822  
    159159    static void appendNameTo(StringBuilder& builder)
    160160    {
    161         builder.flexibleAppend(Token::typeName(t), ", ");
     161        builder.append(Token::typeName(t), ", ");
    162162        Types<ts...>::appendNameTo(builder);
    163163    }

  • trunk/Source/WebCore/loader/archive/mhtml/MHTMLArchive.cpp

    r230211 r248822  
    181181        stringBuilder.append(contentEncoding);
    182182        stringBuilder.append("\r\nContent-Location: ");
    183         stringBuilder.append(resource.url);
     183        stringBuilder.append(resource.url.string());
    184184        stringBuilder.append("\r\n\r\n");
    185185

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r248591 r248822  
    13691369   
    13701370    StringBuilder logString;
    1371     logString.flexibleAppend(pad(' ', 12 + depth * 2, hex(reinterpret_cast<uintptr_t>(&layer))), " id ", backing->graphicsLayer()->primaryLayerID(), " (", FormattedNumber::fixedWidth(absoluteBounds.x().toFloat(), 3), ',', FormattedNumber::fixedWidth(absoluteBounds.y().toFloat(), 3), '-', FormattedNumber::fixedWidth(absoluteBounds.maxX().toFloat(), 3), ',', FormattedNumber::fixedWidth(absoluteBounds.maxY().toFloat(), 3), ") ", FormattedNumber::fixedWidth(backing->backingStoreMemoryEstimate() / 1024, 2), "KB");
     1371    logString.append(pad(' ', 12 + depth * 2, hex(reinterpret_cast<uintptr_t>(&layer))), " id ", backing->graphicsLayer()->primaryLayerID(), " (", FormattedNumber::fixedWidth(absoluteBounds.x().toFloat(), 3), ',', FormattedNumber::fixedWidth(absoluteBounds.y().toFloat(), 3), '-', FormattedNumber::fixedWidth(absoluteBounds.maxX().toFloat(), 3), ',', FormattedNumber::fixedWidth(absoluteBounds.maxY().toFloat(), 3), ") ", FormattedNumber::fixedWidth(backing->backingStoreMemoryEstimate() / 1024, 2), "KB");
    13721372
    13731373    if (!layer.renderer().style().hasAutoZIndex())
    1374         logString.flexibleAppend(" z-index: ", layer.renderer().style().zIndex());
    1375 
    1376     logString.flexibleAppend(" (", logReasonsForCompositing(layer), ") ");
     1374        logString.append(" z-index: ", layer.renderer().style().zIndex());
     1375
     1376    logString.append(" (", logReasonsForCompositing(layer), ") ");
    13771377
    13781378    if (backing->graphicsLayer()->contentsOpaque() || backing->paintsIntoCompositedAncestor() || backing->foregroundLayer() || backing->backgroundLayer()) {

  • trunk/Source/WebCore/testing/Internals.cpp

    r248718 r248822  
    50105010
    50115011        for (auto& info : platformStrategies()->loaderStrategy()->intermediateLoadInformationFromResourceLoadIdentifier(identifier))
    5012             builder.flexibleAppend('[', (int)info.type, ",\"", info.request.url().string(), "\",\"", info.request.httpMethod(), "\",", info.response.httpStatusCode(), ']');
     5012            builder.append('[', (int)info.type, ",\"", info.request.url().string(), "\",\"", info.request.httpMethod(), "\",", info.response.httpStatusCode(), ']');
    50135013
    50145014        builder.append(']');

  • trunk/Source/WebKit/ChangeLog

    r248821 r248822  
     12019-08-17  Sam Weinig  <weinig@apple.com>
     2
     3        Rename StringBuilder::flexibleAppend(...) to StringBuilder::append(...)
     4        https://bugs.webkit.org/show_bug.cgi?id=200756
     5
     6        Reviewed by Darin Adler.
     7
     8        Update call sites for rename from StringBuilder::flexibleAppend(...) to
     9        StringBuilder::append(...).
     10
     11        * WebProcess/WebPage/WebPage.cpp:
     12        (WebKit::dumpHistoryItem):
     13        We have to explicitly access the underlying String of the URL rather than
     14        relying on the implicit conversion since it is now ambiguous which append(...)
     15        overload should be used.
     16
    1172019-08-17  Devin Rousso  <drousso@apple.com>
    218

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r248713 r248822  
    18711871        stringBuilder.append(url.string().substring(start));
    18721872    } else
    1873         stringBuilder.append(url);
     1873        stringBuilder.append(url.string());
    18741874   
    18751875    auto& target = item.target();

  • trunk/Tools/ChangeLog

    r248820 r248822  
     12019-08-17  Sam Weinig  <weinig@apple.com>
     2
     3        Rename StringBuilder::flexibleAppend(...) to StringBuilder::append(...)
     4        https://bugs.webkit.org/show_bug.cgi?id=200756
     5
     6        Reviewed by Darin Adler.
     7
     8        Update call sites for rename from StringBuilder::flexibleAppend(...) to
     9        StringBuilder::append(...).
     10
     11        * TestWebKitAPI/Tests/WTF/StringBuilder.cpp:
     12        (TestWebKitAPI::TEST):
     13
    1142019-08-17  Simon Fraser  <simon.fraser@apple.com>
    215

  • trunk/Tools/TestWebKitAPI/Tests/WTF/StringBuilder.cpp

    r248659 r248822  
    117117}
    118118
    119 TEST(StringBuilderTest, FlexibleAppend)
     119TEST(StringBuilderTest, VariadicAppend)
    120120{
    121121    {
    122122        StringBuilder builder;
    123         builder.flexibleAppend(String("0123456789"));
     123        builder.append(String("0123456789"));
    124124        expectBuilderContent("0123456789", builder);
    125         builder.flexibleAppend("abcd");
     125        builder.append("abcd");
    126126        expectBuilderContent("0123456789abcd", builder);
    127         builder.flexibleAppend('e');
     127        builder.append('e');
    128128        expectBuilderContent("0123456789abcde", builder);
    129         builder.flexibleAppend("");
     129        builder.append("");
    130130        expectBuilderContent("0123456789abcde", builder);
    131131    }
    … …  
    133133    {
    134134        StringBuilder builder;
    135         builder.flexibleAppend(String("0123456789"), "abcd", 'e', "");
     135        builder.append(String("0123456789"), "abcd", 'e', "");
    136136        expectBuilderContent("0123456789abcde", builder);
    137         builder.flexibleAppend(String("A"), "B", 'C', "");
     137        builder.append(String("A"), "B", 'C', "");
    138138        expectBuilderContent("0123456789abcdeABC", builder);
    139139    }
Note: See TracChangeset for help on using the changeset viewer.