Changeset 288473 in webkit for trunk/Source/JavaScriptCore


Ignore:
Timestamp:
Jan 24, 2022, 2:51:13 PM (3 years ago)
Author:
[email protected]
Message:

[JSC] Support import assertion syntax
​https://bugs.webkit.org/show_bug.cgi?id=235312

Reviewed by Ross Kirsling.

JSTests:

  • modules/import-meta-syntax.js:

(shouldThrow):

  • stress/import-syntax.js:
  • stress/modules-syntax-error.js:
  • stress/modules-syntax-import-assertion-error.js: Added.

(shouldThrow):

  • stress/modules-syntax-import-assertion.js: Added.

LayoutTests/imported/w3c:

  • web-platform-tests/html/semantics/scripting-1/the-script-element/css-module/css-module-worker-test-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/css-module/import-css-module-dynamic-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/import-assertions/dynamic-import-with-assertion-argument.any-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/import-assertions/dynamic-import-with-assertion-argument.any.worker-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/json-module/charset-bom.any-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/json-module/charset-bom.any.worker-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/json-module/invalid-content-type.any-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/json-module/invalid-content-type.any.worker-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/json-module/json-module-service-worker-test.https-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/json-module/non-object.any-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/json-module/non-object.any.worker-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/json-module/repeated-imports.any-expected.txt:
  • web-platform-tests/html/semantics/scripting-1/the-script-element/json-module/repeated-imports.any.worker-expected.txt:
  • web-platform-tests/service-workers/service-worker/dedicated-worker-service-worker-interception.https-expected.txt:
  • web-platform-tests/workers/dedicated-worker-parse-error-failure-expected.txt:
  • web-platform-tests/workers/modules/dedicated-worker-options-credentials-expected.txt:

Source/JavaScriptCore:

This patch adds syntax support for import assertion[1].
This does not add the actual feature propagating import assertion
to the module request yet.

[1]: ​https://github.com/tc39/proposal-import-assertions

  • bytecompiler/NodesCodegen.cpp:

(JSC::ImportNode::emitBytecode):

  • parser/ASTBuilder.h:

(JSC::ASTBuilder::createImportExpr):
(JSC::ASTBuilder::createImportAssertionList):
(JSC::ASTBuilder::appendImportAssertion):
(JSC::ASTBuilder::createImportDeclaration):
(JSC::ASTBuilder::createExportAllDeclaration):
(JSC::ASTBuilder::createExportNamedDeclaration):

  • parser/NodeConstructors.h:

(JSC::ImportNode::ImportNode):
(JSC::ImportDeclarationNode::ImportDeclarationNode):
(JSC::ExportAllDeclarationNode::ExportAllDeclarationNode):
(JSC::ExportNamedDeclarationNode::ExportNamedDeclarationNode):

  • parser/Nodes.h:
  • parser/Parser.cpp:

(JSC::Parser<LexerType>::parseImportAssertions):
(JSC::Parser<LexerType>::parseImportDeclaration):
(JSC::Parser<LexerType>::parseExportDeclaration):
(JSC::Parser<LexerType>::parseMemberExpression):

  • parser/Parser.h:
  • parser/SyntaxChecker.h:

(JSC::SyntaxChecker::createImportExpr):
(JSC::SyntaxChecker::createImportAssertionList):
(JSC::SyntaxChecker::appendImportAssertion):
(JSC::SyntaxChecker::createImportDeclaration):
(JSC::SyntaxChecker::createExportAllDeclaration):
(JSC::SyntaxChecker::createExportNamedDeclaration):

  • runtime/JSGlobalObjectFunctions.cpp:

(JSC::JSC_DEFINE_HOST_FUNCTION):

  • runtime/OptionsList.h:
Location:
trunk/Source/JavaScriptCore
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r288458 r288473  
     12022-01-24  Yusuke Suzuki  <[email protected]>
     2
     3        [JSC] Support import assertion syntax
     4        https://bugs.webkit.org/show_bug.cgi?id=235312
     5
     6        Reviewed by Ross Kirsling.
     7
     8        This patch adds syntax support for import assertion[1].
     9        This does not add the actual feature propagating import assertion
     10        to the module request yet.
     11
     12        [1]: https://github.com/tc39/proposal-import-assertions
     13
     14        * bytecompiler/NodesCodegen.cpp:
     15        (JSC::ImportNode::emitBytecode):
     16        * parser/ASTBuilder.h:
     17        (JSC::ASTBuilder::createImportExpr):
     18        (JSC::ASTBuilder::createImportAssertionList):
     19        (JSC::ASTBuilder::appendImportAssertion):
     20        (JSC::ASTBuilder::createImportDeclaration):
     21        (JSC::ASTBuilder::createExportAllDeclaration):
     22        (JSC::ASTBuilder::createExportNamedDeclaration):
     23        * parser/NodeConstructors.h:
     24        (JSC::ImportNode::ImportNode):
     25        (JSC::ImportDeclarationNode::ImportDeclarationNode):
     26        (JSC::ExportAllDeclarationNode::ExportAllDeclarationNode):
     27        (JSC::ExportNamedDeclarationNode::ExportNamedDeclarationNode):
     28        * parser/Nodes.h:
     29        * parser/Parser.cpp:
     30        (JSC::Parser<LexerType>::parseImportAssertions):
     31        (JSC::Parser<LexerType>::parseImportDeclaration):
     32        (JSC::Parser<LexerType>::parseExportDeclaration):
     33        (JSC::Parser<LexerType>::parseMemberExpression):
     34        * parser/Parser.h:
     35        * parser/SyntaxChecker.h:
     36        (JSC::SyntaxChecker::createImportExpr):
     37        (JSC::SyntaxChecker::createImportAssertionList):
     38        (JSC::SyntaxChecker::appendImportAssertion):
     39        (JSC::SyntaxChecker::createImportDeclaration):
     40        (JSC::SyntaxChecker::createExportAllDeclaration):
     41        (JSC::SyntaxChecker::createExportNamedDeclaration):
     42        * runtime/JSGlobalObjectFunctions.cpp:
     43        (JSC::JSC_DEFINE_HOST_FUNCTION):
     44        * runtime/OptionsList.h:
     45
    1462022-01-24  Mark Lam  <[email protected]>
    247

  • trunk/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp

    r287544 r288473  
    225225{
    226226    RefPtr<RegisterID> importModule = generator.moveLinkTimeConstant(nullptr, LinkTimeConstant::importModule);
    227     CallArguments arguments(generator, nullptr, 1);
     227    CallArguments arguments(generator, nullptr, m_option ? 2 : 1);
    228228    generator.emitLoad(arguments.thisRegister(), jsUndefined());
    229229    generator.emitNode(arguments.argumentRegister(0), m_expr);
     230    if (m_option)
     231        generator.emitNode(arguments.argumentRegister(1), m_option);
    230232    return generator.emitCall(generator.finalDestination(dst, importModule.get()), importModule.get(), NoExpectedFunction, arguments, divot(), divotStart(), divotEnd(), DebuggableCall::No);
    231233}

  • trunk/Source/JavaScriptCore/parser/ASTBuilder.h

    r287531 r288473  
    112112    typedef ImportSpecifierNode* ImportSpecifier;
    113113    typedef ImportSpecifierListNode* ImportSpecifierList;
     114    typedef ImportAssertionListNode* ImportAssertionList;
    114115    typedef ExportSpecifierNode* ExportSpecifier;
    115116    typedef ExportSpecifierListNode* ExportSpecifierList;
    … …  
    180181        return new (m_parserArena) SuperNode(location);
    181182    }
    182     ExpressionNode* createImportExpr(const JSTokenLocation& location, ExpressionNode* expr, const JSTextPosition& start, const JSTextPosition& divot, const JSTextPosition& end)
    183     {
    184         auto* node = new (m_parserArena) ImportNode(location, expr);
     183    ExpressionNode* createImportExpr(const JSTokenLocation& location, ExpressionNode* expr, ExpressionNode* option, const JSTextPosition& start, const JSTextPosition& divot, const JSTextPosition& end)
     184    {
     185        auto* node = new (m_parserArena) ImportNode(location, expr, option);
    185186        setExceptionLocation(node, start, divot, end);
    186187        return node;
    … …  
    812813    }
    813814
    814     StatementNode* createImportDeclaration(const JSTokenLocation& location, ImportSpecifierListNode* importSpecifierList, ModuleNameNode* moduleName)
    815     {
    816         return new (m_parserArena) ImportDeclarationNode(location, importSpecifierList, moduleName);
    817     }
    818 
    819     StatementNode* createExportAllDeclaration(const JSTokenLocation& location, ModuleNameNode* moduleName)
    820     {
    821         return new (m_parserArena) ExportAllDeclarationNode(location, moduleName);
     815    ImportAssertionListNode* createImportAssertionList()
     816    {
     817        return new (m_parserArena) ImportAssertionListNode();
     818    }
     819
     820    void appendImportAssertion(ImportAssertionListNode* assertionList, const Identifier& key, const Identifier& value)
     821    {
     822        assertionList->append(key, value);
     823    }
     824
     825    StatementNode* createImportDeclaration(const JSTokenLocation& location, ImportSpecifierListNode* importSpecifierList, ModuleNameNode* moduleName, ImportAssertionListNode* importAssertionList)
     826    {
     827        return new (m_parserArena) ImportDeclarationNode(location, importSpecifierList, moduleName, importAssertionList);
     828    }
     829
     830    StatementNode* createExportAllDeclaration(const JSTokenLocation& location, ModuleNameNode* moduleName, ImportAssertionListNode* importAssertionList)
     831    {
     832        return new (m_parserArena) ExportAllDeclarationNode(location, moduleName, importAssertionList);
    822833    }
    823834
    … …  
    832843    }
    833844
    834     StatementNode* createExportNamedDeclaration(const JSTokenLocation& location, ExportSpecifierListNode* exportSpecifierList, ModuleNameNode* moduleName)
    835     {
    836         return new (m_parserArena) ExportNamedDeclarationNode(location, exportSpecifierList, moduleName);
     845    StatementNode* createExportNamedDeclaration(const JSTokenLocation& location, ExportSpecifierListNode* exportSpecifierList, ModuleNameNode* moduleName, ImportAssertionListNode* importAssertionList)
     846    {
     847        return new (m_parserArena) ExportNamedDeclarationNode(location, exportSpecifierList, moduleName, importAssertionList);
    837848    }
    838849

  • trunk/Source/JavaScriptCore/parser/NodeConstructors.h

    r287531 r288473  
    180180    }
    181181
    182     inline ImportNode::ImportNode(const JSTokenLocation& location, ExpressionNode* expr)
    183         : ExpressionNode(location)
    184         , m_expr(expr)
     182    inline ImportNode::ImportNode(const JSTokenLocation& location, ExpressionNode* expr, ExpressionNode* option)
     183        : ExpressionNode(location)
     184        , m_expr(expr)
     185        , m_option(option)
    185186    {
    186187    }
    … …  
    866867    }
    867868
    868     inline ImportDeclarationNode::ImportDeclarationNode(const JSTokenLocation& location, ImportSpecifierListNode* importSpecifierList, ModuleNameNode* moduleName)
     869    inline ImportDeclarationNode::ImportDeclarationNode(const JSTokenLocation& location, ImportSpecifierListNode* importSpecifierList, ModuleNameNode* moduleName, ImportAssertionListNode* importAssertionList)
    869870        : ModuleDeclarationNode(location)
    870871        , m_specifierList(importSpecifierList)
    871872        , m_moduleName(moduleName)
    872     {
    873     }
    874 
    875     inline ExportAllDeclarationNode::ExportAllDeclarationNode(const JSTokenLocation& location, ModuleNameNode* moduleName)
     873        , m_assertionList(importAssertionList)
     874    {
     875    }
     876
     877    inline ExportAllDeclarationNode::ExportAllDeclarationNode(const JSTokenLocation& location, ModuleNameNode* moduleName, ImportAssertionListNode* importAssertionList)
    876878        : ModuleDeclarationNode(location)
    877879        , m_moduleName(moduleName)
     880        , m_assertionList(importAssertionList)
    878881    {
    879882    }
    … …  
    892895    }
    893896
    894     inline ExportNamedDeclarationNode::ExportNamedDeclarationNode(const JSTokenLocation& location, ExportSpecifierListNode* exportSpecifierList, ModuleNameNode* moduleName)
     897    inline ExportNamedDeclarationNode::ExportNamedDeclarationNode(const JSTokenLocation& location, ExportSpecifierListNode* exportSpecifierList, ModuleNameNode* moduleName, ImportAssertionListNode* importAssertionList)
    895898        : ModuleDeclarationNode(location)
    896899        , m_specifierList(exportSpecifierList)
    897900        , m_moduleName(moduleName)
     901        , m_assertionList(importAssertionList)
    898902    {
    899903    }

  • trunk/Source/JavaScriptCore/parser/Nodes.h

    r287531 r288473  
    628628    class ImportNode final : public ExpressionNode, public ThrowableExpressionData {
    629629    public:
    630         ImportNode(const JSTokenLocation&, ExpressionNode*);
     630        ImportNode(const JSTokenLocation&, ExpressionNode*, ExpressionNode*);
    631631
    632632    private:
    … …  
    635635
    636636        ExpressionNode* m_expr;
     637        ExpressionNode* m_option;
    637638    };
    638639
    … …  
    20582059    };
    20592060
     2061    class ImportAssertionListNode final : public ParserArenaDeletable {
     2062        JSC_MAKE_PARSER_ARENA_DELETABLE_ALLOCATED(ImportAssertionListNode);
     2063    public:
     2064        using Assertions = Vector<std::tuple<const Identifier*, const Identifier*>, 3>;
     2065
     2066        const Assertions& assertions() const { return m_assertions; }
     2067        void append(const Identifier& key, const Identifier& value)
     2068        {
     2069            m_assertions.append(std::tuple { &key, &value });
     2070        }
     2071
     2072    private:
     2073        Assertions m_assertions;
     2074    };
     2075
    20602076    class ModuleDeclarationNode : public StatementNode {
    20612077    public:
    … …  
    20702086    class ImportDeclarationNode final : public ModuleDeclarationNode {
    20712087    public:
    2072         ImportDeclarationNode(const JSTokenLocation&, ImportSpecifierListNode*, ModuleNameNode*);
     2088        ImportDeclarationNode(const JSTokenLocation&, ImportSpecifierListNode*, ModuleNameNode*, ImportAssertionListNode*);
    20732089
    20742090        ImportSpecifierListNode* specifierList() const { return m_specifierList; }
    20752091        ModuleNameNode* moduleName() const { return m_moduleName; }
     2092        ImportAssertionListNode* assertionList() const { return m_assertionList; }
    20762093
    20772094    private:
    … …  
    20812098        ImportSpecifierListNode* m_specifierList;
    20822099        ModuleNameNode* m_moduleName;
     2100        ImportAssertionListNode* m_assertionList;
    20832101    };
    20842102
    20852103    class ExportAllDeclarationNode final : public ModuleDeclarationNode {
    20862104    public:
    2087         ExportAllDeclarationNode(const JSTokenLocation&, ModuleNameNode*);
     2105        ExportAllDeclarationNode(const JSTokenLocation&, ModuleNameNode*, ImportAssertionListNode*);
    20882106
    20892107        ModuleNameNode* moduleName() const { return m_moduleName; }
     2108        ImportAssertionListNode* assertionList() const { return m_assertionList; }
    20902109
    20912110    private:
    … …  
    20942113
    20952114        ModuleNameNode* m_moduleName;
     2115        ImportAssertionListNode* m_assertionList;
    20962116    };
    20972117
    … …  
    21512171    class ExportNamedDeclarationNode final : public ModuleDeclarationNode {
    21522172    public:
    2153         ExportNamedDeclarationNode(const JSTokenLocation&, ExportSpecifierListNode*, ModuleNameNode*);
     2173        ExportNamedDeclarationNode(const JSTokenLocation&, ExportSpecifierListNode*, ModuleNameNode*, ImportAssertionListNode*);
    21542174
    21552175        ExportSpecifierListNode* specifierList() const { return m_specifierList; }
    21562176        ModuleNameNode* moduleName() const { return m_moduleName; }
     2177        ImportAssertionListNode* assertionList() const { return m_assertionList; }
    21572178
    21582179    private:
    … …  
    21612182        ExportSpecifierListNode* m_specifierList;
    21622183        ModuleNameNode* m_moduleName { nullptr };
     2184        ImportAssertionListNode* m_assertionList { nullptr };
    21632185    };
    21642186

  • trunk/Source/JavaScriptCore/parser/Parser.cpp

    r284435 r288473  
    35773577
    35783578template <typename LexerType>
     3579template <class TreeBuilder> typename TreeBuilder::ImportAssertionList Parser<LexerType>::parseImportAssertions(TreeBuilder& context)
     3580{
     3581    auto assertionList = context.createImportAssertionList();
     3582    consumeOrFail(OPENBRACE, "Expected opening '{' at the start of import assertion");
     3583    while (!match(CLOSEBRACE)) {
     3584        failIfFalse(matchIdentifierOrKeyword() || match(STRING), "Expected an assertion key");
     3585        auto key = m_token.m_data.ident;
     3586        next();
     3587        consumeOrFail(COLON, "Expected ':' after assertion key");
     3588        failIfFalse(match(STRING), "Expected an assertion value");
     3589        auto value = m_token.m_data.ident;
     3590        next();
     3591        context.appendImportAssertion(assertionList, *key, *value);
     3592        if (!consume(COMMA))
     3593            break;
     3594    }
     3595    handleProductionOrFail2(CLOSEBRACE, "}", "end", "import assertion");
     3596    return assertionList;
     3597}
     3598
     3599template <typename LexerType>
    35793600template <class TreeBuilder> TreeStatement Parser<LexerType>::parseImportDeclaration(TreeBuilder& context)
    35803601{
    … …  
    35883609    if (match(STRING)) {
    35893610        // import ModuleSpecifier ;
     3611        // import ModuleSpecifier [no LineTerminator here] AssertClause ;
    35903612        auto moduleName = parseModuleName(context);
    35913613        failIfFalse(moduleName, "Cannot parse the module name");
     3614
     3615        typename TreeBuilder::ImportAssertionList assertionList = 0;
     3616        if (Options::useImportAssertion() && !m_lexer->hasLineTerminatorBeforeToken() && matchContextualKeyword(m_vm.propertyNames->builtinNames().assertPublicName())) {
     3617            next();
     3618            assertionList = parseImportAssertions(context);
     3619            failIfFalse(assertionList, "Unable to parse import assertion");
     3620        }
     3621
    35923622        failIfFalse(autoSemiColon(), "Expected a ';' following a targeted import declaration");
    3593         return context.createImportDeclaration(importLocation, specifierList, moduleName);
     3623        return context.createImportDeclaration(importLocation, specifierList, moduleName, assertionList);
    35943624    }
    35953625
    … …  
    36413671    auto moduleName = parseModuleName(context);
    36423672    failIfFalse(moduleName, "Cannot parse the module name");
     3673
     3674    // [no LineTerminator here] AssertClause ;
     3675    typename TreeBuilder::ImportAssertionList assertionList = 0;
     3676    if (Options::useImportAssertion() && !m_lexer->hasLineTerminatorBeforeToken() && matchContextualKeyword(m_vm.propertyNames->builtinNames().assertPublicName())) {
     3677        next();
     3678        assertionList = parseImportAssertions(context);
     3679        failIfFalse(assertionList, "Unable to parse import assertion");
     3680    }
     3681
    36433682    failIfFalse(autoSemiColon(), "Expected a ';' following a targeted import declaration");
    36443683
    3645     return context.createImportDeclaration(importLocation, specifierList, moduleName);
     3684    return context.createImportDeclaration(importLocation, specifierList, moduleName, assertionList);
    36463685}
    36473686
    … …  
    37153754        auto moduleName = parseModuleName(context);
    37163755        failIfFalse(moduleName, "Cannot parse the 'from' clause");
     3756
     3757        // [no LineTerminator here] AssertClause ;
     3758        typename TreeBuilder::ImportAssertionList assertionList = 0;
     3759        if (Options::useImportAssertion() && !m_lexer->hasLineTerminatorBeforeToken() && matchContextualKeyword(m_vm.propertyNames->builtinNames().assertPublicName())) {
     3760            next();
     3761            assertionList = parseImportAssertions(context);
     3762            failIfFalse(assertionList, "Unable to parse import assertion");
     3763        }
     3764
    37173765        failIfFalse(autoSemiColon(), "Expected a ';' following a targeted export declaration");
    37183766
    … …  
    37233771            auto specifier = context.createExportSpecifier(specifierLocation, *localName, *exportedName);
    37243772            context.appendExportSpecifier(specifierList, specifier);
    3725             return context.createExportNamedDeclaration(exportLocation, specifierList, moduleName);
    3726         }
    3727 
    3728         return context.createExportAllDeclaration(exportLocation, moduleName);
     3773            return context.createExportNamedDeclaration(exportLocation, specifierList, moduleName, assertionList);
     3774        }
     3775
     3776        return context.createExportAllDeclaration(exportLocation, moduleName, assertionList);
    37293777    }
    37303778
    … …  
    38483896
    38493897        typename TreeBuilder::ModuleName moduleName = 0;
     3898        typename TreeBuilder::ImportAssertionList assertionList = 0;
    38503899        if (matchContextualKeyword(m_vm.propertyNames->from)) {
    38513900            next();
    38523901            moduleName = parseModuleName(context);
    38533902            failIfFalse(moduleName, "Cannot parse the 'from' clause");
     3903
     3904            // [no LineTerminator here] AssertClause ;
     3905            if (Options::useImportAssertion() && !m_lexer->hasLineTerminatorBeforeToken() && matchContextualKeyword(m_vm.propertyNames->builtinNames().assertPublicName())) {
     3906                next();
     3907                assertionList = parseImportAssertions(context);
     3908                failIfFalse(assertionList, "Unable to parse import assertion");
     3909            }
    38543910        } else
    38553911            semanticFailIfTrue(hasReferencedModuleExportNames, "Cannot use module export names if they reference variable names in the current module");
    … …  
    38733929        }
    38743930
    3875         return context.createExportNamedDeclaration(exportLocation, specifierList, moduleName);
     3931        return context.createExportNamedDeclaration(exportLocation, specifierList, moduleName, assertionList);
    38763932    }
    38773933
    … …  
    51375193        } else {
    51385194            semanticFailIfTrue(newCount, "Cannot use new with import");
    5139             consumeOrFail(OPENPAREN, "import call expects exactly one argument");
     5195            consumeOrFail(OPENPAREN, "import call expects one or two arguments");
    51405196            TreeExpression expr = parseAssignmentExpression(context);
    51415197            failIfFalse(expr, "Cannot parse expression");
    5142             consumeOrFail(CLOSEPAREN, "import call expects exactly one argument");
    5143             base = context.createImportExpr(location, expr, expressionStart, expressionEnd, lastTokenEndPosition());
     5198            TreeExpression optionExpression = 0;
     5199            if (consume(COMMA)) {
     5200                if (!match(CLOSEPAREN)) {
     5201                    optionExpression = parseAssignmentExpression(context);
     5202                    failIfFalse(optionExpression, "Cannot parse expression");
     5203                    consume(COMMA);
     5204                }
     5205            }
     5206            consumeOrFail(CLOSEPAREN, "import call expects one or two arguments");
     5207            base = context.createImportExpr(location, expr, optionExpression, expressionStart, expressionEnd, lastTokenEndPosition());
    51445208        }
    51455209    } else if (!baseIsNewTarget) {

  • trunk/Source/JavaScriptCore/parser/Parser.h

    r288261 r288473  
    17851785    template <class TreeBuilder> typename TreeBuilder::ImportSpecifier parseImportClauseItem(TreeBuilder&, ImportSpecifierType);
    17861786    template <class TreeBuilder> typename TreeBuilder::ModuleName parseModuleName(TreeBuilder&);
     1787    template <class TreeBuilder> typename TreeBuilder::ImportAssertionList parseImportAssertions(TreeBuilder&);
    17871788    template <class TreeBuilder> TreeStatement parseImportDeclaration(TreeBuilder&);
    17881789    template <class TreeBuilder> typename TreeBuilder::ExportSpecifier parseExportSpecifier(TreeBuilder& context, Vector<std::pair<const Identifier*, const Identifier*>>& maybeExportedLocalNames, bool& hasKeywordForLocalBindings, bool& hasReferencedModuleExportNames);

  • trunk/Source/JavaScriptCore/parser/SyntaxChecker.h

    r279447 r288473  
    8787        TaggedTemplateExpr, YieldExpr, AwaitExpr,
    8888        ModuleNameResult, PrivateIdentifier,
    89         ImportSpecifierResult, ImportSpecifierListResult,
     89        ImportSpecifierResult, ImportSpecifierListResult, ImportAssertionListResult,
    9090        ExportSpecifierResult, ExportSpecifierListResult,
    9191
    … …  
    129129    typedef int ImportSpecifier;
    130130    typedef int ImportSpecifierList;
     131    typedef int ImportAssertionList;
    131132    typedef int ExportSpecifier;
    132133    typedef int ExportSpecifierList;
    … …  
    160161    ExpressionType createUnaryPlus(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
    161162    ExpressionType createVoid(const JSTokenLocation&, ExpressionType) { return UnaryExpr; }
    162     ExpressionType createImportExpr(const JSTokenLocation&, ExpressionType, int, int, int) { return ImportExpr; }
     163    ExpressionType createImportExpr(const JSTokenLocation&, ExpressionType, ExpressionType, int, int, int) { return ImportExpr; }
    163164    ExpressionType createThisExpr(const JSTokenLocation&) { return ThisExpr; }
    164165    ExpressionType createSuperExpr(const JSTokenLocation&) { return SuperExpr; }
    … …  
    279280    ImportSpecifierList createImportSpecifierList() { return ImportSpecifierListResult; }
    280281    void appendImportSpecifier(ImportSpecifierList, ImportSpecifier) { }
    281     int createImportDeclaration(const JSTokenLocation&, ImportSpecifierList, ModuleName) { return StatementResult; }
    282     int createExportAllDeclaration(const JSTokenLocation&, ModuleName) { return StatementResult; }
     282    ImportAssertionList createImportAssertionList() { return ImportAssertionListResult; }
     283    void appendImportAssertion(ImportAssertionList, const Identifier&, const Identifier&) { }
     284    int createImportDeclaration(const JSTokenLocation&, ImportSpecifierList, ModuleName, ImportAssertionList) { return StatementResult; }
     285    int createExportAllDeclaration(const JSTokenLocation&, ModuleName, ImportAssertionList) { return StatementResult; }
    283286    int createExportDefaultDeclaration(const JSTokenLocation&, int, const Identifier&) { return StatementResult; }
    284287    int createExportLocalDeclaration(const JSTokenLocation&, int) { return StatementResult; }
    285     int createExportNamedDeclaration(const JSTokenLocation&, ExportSpecifierList, ModuleName) { return StatementResult; }
     288    int createExportNamedDeclaration(const JSTokenLocation&, ExportSpecifierList, ModuleName, ImportAssertionList) { return StatementResult; }
    286289    ExportSpecifier createExportSpecifier(const JSTokenLocation&, const Identifier&, const Identifier&) { return ExportSpecifierResult; }
    287290    ExportSpecifierList createExportSpecifierList() { return ExportSpecifierListResult; }

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp

    r287303 r288473  
    823823
    824824    auto sourceOrigin = callFrame->callerSourceOrigin(vm);
    825     RELEASE_ASSERT(callFrame->argumentCount() == 1);
     825    RELEASE_ASSERT(callFrame->argumentCount() >= 1);
    826826    auto* specifier = callFrame->uncheckedArgument(0).toString(globalObject);
    827827    RETURN_IF_EXCEPTION(scope, JSValue::encode(promise->rejectWithCaughtException(globalObject, scope)));

  • trunk/Source/JavaScriptCore/runtime/OptionsList.h

    r287136 r288473  
    542542    v(Bool, useAtMethod, true, Normal, "Expose the at() method on Array, %TypedArray%, and String.") \
    543543    v(Bool, useHasOwn, true, Normal, "Expose the Object.hasOwn method") \
     544    v(Bool, useImportAssertion, false, Normal, "Enable import assertion.") \
    544545    v(Bool, useIntlEnumeration, true, Normal, "Expose the Intl enumeration APIs.") \
    545546    v(Bool, useSharedArrayBuffer, false, Normal, nullptr) \
Note: See TracChangeset for help on using the changeset viewer.