Changeset 223232 in webkit for trunk/Source/JavaScriptCore


Ignore:
Timestamp:
Oct 11, 2017, 11:45:23 PM (8 years ago)
Author:
Yusuke Suzuki
Message:

import.meta should not be assignable
​https://bugs.webkit.org/show_bug.cgi?id=178202

Reviewed by Saam Barati.

JSTests:

  • modules/import-meta-assignment.js: Added.

(shouldThrow):
(SyntaxError.import.meta.can.shouldThrow):

Source/JavaScriptCore:

import.meta cannot be used for LHS. This patch adds MetaPropertyNode
and make NewTargetNode and ImportMetaNode as derived classes of MetaPropertyNode.
We change the parser not to allow assignments for MetaPropertyNode.

  • bytecompiler/NodesCodegen.cpp:

(JSC::ImportMetaNode::emitBytecode):

  • parser/ASTBuilder.h:

(JSC::ASTBuilder::createImportMetaExpr):
(JSC::ASTBuilder::isMetaProperty):
(JSC::ASTBuilder::isImportMeta):

  • parser/NodeConstructors.h:

(JSC::MetaPropertyNode::MetaPropertyNode):
(JSC::NewTargetNode::NewTargetNode):
(JSC::ImportMetaNode::ImportMetaNode):

  • parser/Nodes.h:

(JSC::ExpressionNode::isMetaProperty const):
(JSC::ExpressionNode::isImportMeta const):

  • parser/Parser.cpp:

(JSC::Parser<LexerType>::metaPropertyName):
(JSC::Parser<LexerType>::parseAssignmentExpression):
(JSC::Parser<LexerType>::parseMemberExpression):
(JSC::Parser<LexerType>::parseUnaryExpression):

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

(JSC::SyntaxChecker::createImportMetaExpr):
(JSC::SyntaxChecker::isMetaProperty):
(JSC::SyntaxChecker::isImportMeta):

Location:
trunk/Source/JavaScriptCore
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r223222 r223232  
     12017-10-11  Yusuke Suzuki  <[email protected]>
     2
     3        import.meta should not be assignable
     4        https://bugs.webkit.org/show_bug.cgi?id=178202
     5
     6        Reviewed by Saam Barati.
     7
     8        `import.meta` cannot be used for LHS. This patch adds MetaPropertyNode
     9        and make NewTargetNode and ImportMetaNode as derived classes of MetaPropertyNode.
     10        We change the parser not to allow assignments for MetaPropertyNode.
     11
     12        * bytecompiler/NodesCodegen.cpp:
     13        (JSC::ImportMetaNode::emitBytecode):
     14        * parser/ASTBuilder.h:
     15        (JSC::ASTBuilder::createImportMetaExpr):
     16        (JSC::ASTBuilder::isMetaProperty):
     17        (JSC::ASTBuilder::isImportMeta):
     18        * parser/NodeConstructors.h:
     19        (JSC::MetaPropertyNode::MetaPropertyNode):
     20        (JSC::NewTargetNode::NewTargetNode):
     21        (JSC::ImportMetaNode::ImportMetaNode):
     22        * parser/Nodes.h:
     23        (JSC::ExpressionNode::isMetaProperty const):
     24        (JSC::ExpressionNode::isImportMeta const):
     25        * parser/Parser.cpp:
     26        (JSC::Parser<LexerType>::metaPropertyName):
     27        (JSC::Parser<LexerType>::parseAssignmentExpression):
     28        (JSC::Parser<LexerType>::parseMemberExpression):
     29        (JSC::Parser<LexerType>::parseUnaryExpression):
     30        * parser/Parser.h:
     31        * parser/SyntaxChecker.h:
     32        (JSC::SyntaxChecker::createImportMetaExpr):
     33        (JSC::SyntaxChecker::isMetaProperty):
     34        (JSC::SyntaxChecker::isImportMeta):
     35
    1362017-10-11  Saam Barati  <[email protected]>
    237

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

    r222689 r223232  
    210210
    211211    return generator.moveToDestinationIfNeeded(dst, generator.newTarget());
     212}
     213
     214// ------------------------------ ImportMetaNode ---------------------------------
     215
     216RegisterID* ImportMetaNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
     217{
     218    return generator.emitNode(dst, m_expr);
    212219}
    213220

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

    r223175 r223232  
    190190        return new (m_parserArena) NewTargetNode(location);
    191191    }
     192    ExpressionNode* createImportMetaExpr(const JSTokenLocation& location, ExpressionNode* expr) { return new (m_parserArena) ImportMetaNode(location, expr); }
     193    bool isMetaProperty(ExpressionNode* node) { return node->isMetaProperty(); }
    192194    bool isNewTarget(ExpressionNode* node) { return node->isNewTarget(); }
     195    bool isImportMeta(ExpressionNode* node) { return node->isImportMeta(); }
    193196    ExpressionNode* createResolve(const JSTokenLocation& location, const Identifier& ident, const JSTextPosition& start, const JSTextPosition& end)
    194197    {

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

    r221358 r223232  
    172172    }
    173173
     174    inline MetaPropertyNode::MetaPropertyNode(const JSTokenLocation& location)
     175        : ExpressionNode(location)
     176    {
     177    }
     178
    174179    inline NewTargetNode::NewTargetNode(const JSTokenLocation& location)
    175         : ExpressionNode(location)
     180        : MetaPropertyNode(location)
     181    {
     182    }
     183
     184    inline ImportMetaNode::ImportMetaNode(const JSTokenLocation& location, ExpressionNode* expr)
     185        : MetaPropertyNode(location)
     186        , m_expr(expr)
    176187    {
    177188    }

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

    r223047 r223232  
    187187        virtual bool isSuperNode() const { return false; }
    188188        virtual bool isImportNode() const { return false; }
     189        virtual bool isMetaProperty() const { return false; }
    189190        virtual bool isNewTarget() const { return false; }
     191        virtual bool isImportMeta() const { return false; }
    190192        virtual bool isBytecodeIntrinsicNode() const { return false; }
    191193
    … …  
    585587    };
    586588
    587     class NewTargetNode final : public ExpressionNode {
     589    class MetaPropertyNode : public ExpressionNode {
     590    public:
     591        MetaPropertyNode(const JSTokenLocation&);
     592
     593    private:
     594        bool isMetaProperty() const final { return true; }
     595    };
     596
     597    class NewTargetNode final : public MetaPropertyNode {
    588598    public:
    589599        NewTargetNode(const JSTokenLocation&);
    … …  
    592602        bool isNewTarget() const final { return true; }
    593603        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
     604    };
     605
     606    class ImportMetaNode final : public MetaPropertyNode {
     607    public:
     608        ImportMetaNode(const JSTokenLocation&, ExpressionNode*);
     609
     610    private:
     611        bool isImportMeta() const final { return true; }
     612        RegisterID* emitBytecode(BytecodeGenerator&, RegisterID* = 0) override;
     613
     614        ExpressionNode* m_expr;
    594615    };
    595616

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

    r223175 r223232  
    35863586    return parseAssignmentExpression(context, classifier);
    35873587}
     3588
     3589
     3590template <typename LexerType>
     3591template <typename TreeBuilder> NEVER_INLINE const char* Parser<LexerType>::metaPropertyName(TreeBuilder& context, TreeExpression expr)
     3592{
     3593    if (context.isNewTarget(expr))
     3594        return "new.target";
     3595    if (context.isImportMeta(expr))
     3596        return "import.meta";
     3597    RELEASE_ASSERT_NOT_REACHED();
     3598    return "error";
     3599}
    35883600   
    35893601template <typename LexerType>
    … …  
    36913703        m_parserState.nonTrivialExpressionCount++;
    36923704        hadAssignment = true;
    3693         if (UNLIKELY(context.isNewTarget(lhs)))
    3694             internalFailWithMessage(false, "new.target can't be the left hand side of an assignment expression");
     3705        if (UNLIKELY(context.isMetaProperty(lhs)))
     3706            internalFailWithMessage(false, metaPropertyName(context, lhs), " can't be the left hand side of an assignment expression");
    36953707        context.assignmentStackAppend(assignmentStack, lhs, start, tokenStartPosition(), m_parserState.assignmentCount, op);
    36963708        start = tokenStartPosition();
    … …  
    46994711
    47004712                JSTokenLocation location(tokenLocation());
    4701                 base = createResolveAndUseVariable(context, &m_vm->propertyNames->builtinNames().metaPrivateName(), false, expressionStart, location);
     4713                base = context.createImportMetaExpr(location, createResolveAndUseVariable(context, &m_vm->propertyNames->builtinNames().metaPrivateName(), false, expressionStart, location));
    47024714                next();
    47034715            } else {
    … …  
    49254937        failWithMessage("Cannot parse member expression");
    49264938    }
    4927     if (UNLIKELY(isUpdateOp(static_cast<JSTokenType>(lastOperator)) && context.isNewTarget(expr)))
    4928         internalFailWithMessage(false, "new.target can't come after a prefix operator");
     4939    if (UNLIKELY(isUpdateOp(static_cast<JSTokenType>(lastOperator)) && context.isMetaProperty(expr)))
     4940        internalFailWithMessage(false, metaPropertyName(context, expr), " can't come after a prefix operator");
    49294941    bool isEvalOrArguments = false;
    49304942    if (strictMode() && !m_syntaxAlreadyValidated) {
    … …  
    49354947    switch (m_token.m_type) {
    49364948    case PLUSPLUS:
    4937         if (UNLIKELY(context.isNewTarget(expr)))
    4938             internalFailWithMessage(false, "new.target can't come before a postfix operator");
     4949        if (UNLIKELY(context.isMetaProperty(expr)))
     4950            internalFailWithMessage(false, metaPropertyName(context, expr), " can't come before a postfix operator");
    49394951        m_parserState.nonTrivialExpressionCount++;
    49404952        m_parserState.nonLHSCount++;
    … …  
    49474959        break;
    49484960    case MINUSMINUS:
    4949         if (UNLIKELY(context.isNewTarget(expr)))
    4950             internalFailWithMessage(false, "new.target can't come before a postfix operator");
     4961        if (UNLIKELY(context.isMetaProperty(expr)))
     4962            internalFailWithMessage(false, metaPropertyName(context, expr), " can't come before a postfix operator");
    49514963        m_parserState.nonTrivialExpressionCount++;
    49524964        m_parserState.nonLHSCount++;

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

    r223124 r223232  
    16131613    template <class TreeBuilder> ALWAYS_INLINE bool shouldCheckPropertyForUnderscoreProtoDuplicate(TreeBuilder&, const TreeProperty&);
    16141614
     1615    template <class TreeBuilder> NEVER_INLINE const char* metaPropertyName(TreeBuilder&, TreeExpression);
     1616
    16151617    ALWAYS_INLINE int isBinaryOperator(JSTokenType);
    16161618    bool allowAutomaticSemicolon();

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

    r223175 r223232  
    6969    }
    7070
    71     enum { NoneExpr = 0,
     71    static const constexpr int MetaPropertyBit = 0x80000000;
     72    enum : int { NoneExpr = 0,
    7273        ResolveEvalExpr, ResolveExpr, IntegerExpr, DoubleExpr, StringExpr,
    7374        ThisExpr, NullExpr, BoolExpr, RegExpExpr, ObjectLiteralExpr,
    7475        FunctionExpr, ClassExpr, SuperExpr, ImportExpr, BracketExpr, DotExpr, CallExpr,
    7576        NewExpr, PreExpr, PostExpr, UnaryExpr, BinaryExpr,
    76         ConditionalExpr, AssignmentExpr, TypeofExpr, NewTargetExpr,
     77        ConditionalExpr, AssignmentExpr, TypeofExpr,
    7778        DeleteExpr, ArrayLiteralExpr, BindingDestructuring, RestParameter,
    7879        ArrayDestructuring, ObjectDestructuring, SourceElementsResult,
    … …  
    8687        ModuleNameResult,
    8788        ImportSpecifierResult, ImportSpecifierListResult,
    88         ExportSpecifierResult, ExportSpecifierListResult
     89        ExportSpecifierResult, ExportSpecifierListResult,
     90
     91        NewTargetExpr = MetaPropertyBit | 0,
     92        ImportMetaExpr = MetaPropertyBit | 1,
    8993    };
    9094    typedef int ExpressionType;
    … …  
    161165    ExpressionType createSuperExpr(const JSTokenLocation&) { return SuperExpr; }
    162166    ExpressionType createNewTargetExpr(const JSTokenLocation&) { return NewTargetExpr; }
     167    ExpressionType createImportMetaExpr(const JSTokenLocation&, ExpressionType) { return ImportMetaExpr; }
     168    ALWAYS_INLINE bool isMetaProperty(ExpressionType type) { return type & MetaPropertyBit; }
    163169    ALWAYS_INLINE bool isNewTarget(ExpressionType type) { return type == NewTargetExpr; }
     170    ALWAYS_INLINE bool isImportMeta(ExpressionType type) { return type == ImportMetaExpr; }
    164171    ExpressionType createResolve(const JSTokenLocation&, const Identifier&, int, int) { return ResolveExpr; }
    165172    ExpressionType createObjectLiteral(const JSTokenLocation&) { return ObjectLiteralExpr; }
Note: See TracChangeset for help on using the changeset viewer.