ChangeLog

2015-03-20  Geoffrey Garen  <ggaren@apple.com>

        FunctionBodyNode should known where its parameters started

        https://bugs.webkit.org/show_bug.cgi?id=142926

        Reviewed by NOBODY (OOPS!).

        This will allow us to re-parse parameters instead of keeping the

        parameters piece of the AST around forever.

        I also took the opportunity to initialized most FunctionBodyNode data

        members at construction time, to help clarify that they are set right.

        * parser/ASTBuilder.h:

        (JSC::ASTBuilder::createFunctionExpr): No need to pass

        functionKeywordStart here; we now provide it at FunctionBodyNode

        creation time.

        (JSC::ASTBuilder::createFunctionBody): Require everything we need at

        construction time, including the start of our parameters.

        (JSC::ASTBuilder::createGetterOrSetterProperty):

        (JSC::ASTBuilder::createFuncDeclStatement):  No need to pass

        functionKeywordStart here; we now provide it at FunctionBodyNode

        creation time.

        (JSC::ASTBuilder::setFunctionNameStart): Deleted.

        * parser/Nodes.cpp:

        (JSC::FunctionBodyNode::FunctionBodyNode): Initialize everything at

        construction time.

        * parser/Nodes.h: Added a field for the location of our parameters.

        * parser/Parser.cpp:

        (JSC::Parser<LexerType>::parseFunctionBody):

        (JSC::Parser<LexerType>::parseFunctionInfo):

        (JSC::Parser<LexerType>::parseFunctionDeclaration):

        (JSC::Parser<LexerType>::parseClass):

        (JSC::Parser<LexerType>::parsePropertyMethod):

        (JSC::Parser<LexerType>::parseGetterSetter):

        (JSC::Parser<LexerType>::parsePrimaryExpression):

        * parser/Parser.h: Refactored to match above interface changes.

        * parser/SyntaxChecker.h:

        (JSC::SyntaxChecker::createFunctionExpr):

        (JSC::SyntaxChecker::createFunctionBody):

        (JSC::SyntaxChecker::createFuncDeclStatement):

        (JSC::SyntaxChecker::createGetterOrSetterProperty): Refactored to match

        above interface changes.

        (JSC::SyntaxChecker::setFunctionNameStart): Deleted.

2015-03-20  Yusuke Suzuki  <utatane.tea@gmail.com>

        REGRESSION (r179429): Potential Use after free in JavaScriptCore`WTF::StringImpl::ref + 83

181815

Source/JavaScriptCore/parser/ASTBuilder.h

@@public:

    }

#endif

296 ExpressionNode* createFunctionExpr(const JSTokenLocation& location, const ParserFunctionInfo<ASTBuilder>& info~~, unsigned functionKeywordStart~~)

296 ExpressionNode* createFunctionExpr(const JSTokenLocation& location, const ParserFunctionInfo<ASTBuilder>& info)

    {

        FuncExprNode* result = new (m_parserArena) FuncExprNode(location, *info.name, info.body,

            m_sourceCode->subExpression(info.openBraceOffset, info.closeBraceOffset, info.bodyStartLine, info.bodyStartColumn), info.parameters);

        info.body->setLoc(info.bodyStartLine, info.bodyEndLine, location.startOffset, location.lineStartOffset);

301 info.body->setFunctionKeywordStart(functionKeywordStart);

        return result;

    }

    FunctionBodyNode* createFunctionBody(const JSTokenLocation& startLocation, const JSTokenLocation& endLocation, unsigned startColumn, unsigned endColumn, bool inStrictContext, ConstructorKind constructorKind)

    {

        return new (m_parserArena) FunctionBodyNode(m_parserArena, startLocation, endLocation, startColumn, endColumn, inStrictContext, constructorKind);

    FunctionBodyNode* createFunctionBody(

        const JSTokenLocation& startLocation, const JSTokenLocation& endLocation, 

        unsigned startColumn, unsigned endColumn, int functionKeywordStart, 

        int functionNameStart, int parametersStart, bool inStrictContext, 

        ConstructorKind constructorKind)

    {

        return new (m_parserArena) FunctionBodyNode(

            m_parserArena, startLocation, endLocation, startColumn, endColumn, 

            functionKeywordStart, functionNameStart, parametersStart, 

            inStrictContext, constructorKind);

308314 }

309315

    void setFunctionNameStart(FunctionBodyNode* body, int functionNameStart)

    {

        body->setFunctionNameStart(functionNameStart);

    }

315316 NEVER_INLINE PropertyNode* createGetterOrSetterProperty(const JSTokenLocation& location, PropertyNode::Type type, bool,

316 const Identifier* name, const ParserFunctionInfo<ASTBuilder>& info, ~~unsigned getOrSetStartOffset,~~ SuperBinding superBinding)

317 const Identifier* name, const ParserFunctionInfo<ASTBuilder>& info, SuperBinding superBinding)

    {

        ASSERT(name);

        info.body->setLoc(info.bodyStartLine, info.bodyEndLine, location.startOffset, location.lineStartOffset);

        info.body->setInferredName(*name);

321 info.body->setFunctionKeywordStart(getOrSetStartOffset);

        SourceCode source = m_sourceCode->subExpression(info.openBraceOffset, info.closeBraceOffset, info.bodyStartLine, info.bodyStartColumn);

        FuncExprNode* funcExpr = new (m_parserArena) FuncExprNode(location, m_vm->propertyNames->nullIdentifier, info.body, source, info.parameters);

        return new (m_parserArena) PropertyNode(*name, funcExpr, type, PropertyNode::Unknown, superBinding);

    }

    NEVER_INLINE PropertyNode* createGetterOrSetterProperty(VM* vm, ParserArena& parserArena, const JSTokenLocation& location, PropertyNode::Type type, bool,

328 double name, const ParserFunctionInfo<ASTBuilder>& info, ~~unsigned getOrSetStartOffset,~~ SuperBinding superBinding)

328 double name, const ParserFunctionInfo<ASTBuilder>& info, SuperBinding superBinding)

329329 {

330330 info.body->setLoc(info.bodyStartLine, info.bodyEndLine, location.startOffset, location.lineStartOffset);

331 info.body->setFunctionKeywordStart(getOrSetStartOffset);

        const Identifier& ident = parserArena.identifierArena().makeNumericIdentifier(vm, name);

        SourceCode source = m_sourceCode->subExpression(info.openBraceOffset, info.closeBraceOffset, info.bodyStartLine, info.bodyStartColumn);

        FuncExprNode* funcExpr = new (m_parserArena) FuncExprNode(location, vm->propertyNames->nullIdentifier, info.body, source, info.parameters);

@@public:

    ClauseListNode* createClauseList(CaseClauseNode* clause) { return new (m_parserArena) ClauseListNode(clause); }

    ClauseListNode* createClauseList(ClauseListNode* tail, CaseClauseNode* clause) { return new (m_parserArena) ClauseListNode(tail, clause); }

367 StatementNode* createFuncDeclStatement(const JSTokenLocation& location, const ParserFunctionInfo<ASTBuilder>& info~~, unsigned functionKeywordStart~~)

366 StatementNode* createFuncDeclStatement(const JSTokenLocation& location, const ParserFunctionInfo<ASTBuilder>& info)

    {

        FuncDeclNode* decl = new (m_parserArena) FuncDeclNode(location, *info.name, info.body,

            m_sourceCode->subExpression(info.openBraceOffset, info.closeBraceOffset, info.bodyStartLine, info.bodyStartColumn), info.parameters);

@@public:

            usesArguments();

        m_scope.m_funcDeclarations.append(decl->body());

        info.body->setLoc(info.bodyStartLine, info.bodyEndLine, location.startOffset, location.lineStartOffset);

375 info.body->setFunctionKeywordStart(functionKeywordStart);

        return decl;

    }

181809

Source/JavaScriptCore/parser/Nodes.cpp

@@FunctionParameters::~FunctionParameters(

        patterns()[i]->deref();

}

170 FunctionBodyNode::FunctionBodyNode(ParserArena&, const JSTokenLocation& startLocation, const JSTokenLocation& endLocation, unsigned startColumn, unsigned endColumn, bool isInStrictContext, ConstructorKind constructorKind)

FunctionBodyNode::FunctionBodyNode(

    ParserArena&, const JSTokenLocation& startLocation, 

    const JSTokenLocation& endLocation, unsigned startColumn, unsigned endColumn, 

    int functionKeywordStart, int functionNameStart, int parametersStart,

    bool isInStrictContext, ConstructorKind constructorKind)

    : StatementNode(endLocation)

    , m_startColumn(startColumn)

    , m_endColumn(endColumn)

    , m_functionKeywordStart(functionKeywordStart)

    , m_functionNameStart(functionNameStart)

    , m_parametersStart(parametersStart)

    , m_startStartOffset(startLocation.startOffset)

    , m_isInStrictContext(isInStrictContext)

    , m_constructorKind(static_cast<unsigned>(constructorKind))

181809

Source/JavaScriptCore/parser/Nodes.h

@@namespace JSC {

    public:

        using ParserArenaDeletable::operator new;

1563 FunctionBodyNode(ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, unsigned startColumn, unsigned endColumn, bool isInStrictContext, ConstructorKind);

        FunctionBodyNode(

            ParserArena&, const JSTokenLocation& start, const JSTokenLocation& end, 

            unsigned startColumn, unsigned endColumn, int functionKeywordStart, 

            int functionNameStart, int parametersStart, bool isInStrictContext, 

            ConstructorKind);

        FunctionParameters* parameters() const { return m_parameters.get(); }

@@namespace JSC {

        FunctionMode functionMode() { return m_functionMode; }

1578 void setFunctionNameStart(int functionNameStart) { m_functionNameStart = functionNameStart; }

15791582 int functionNameStart() const { return m_functionNameStart; }

1580 void setFunctionKeywordStart(int functionKeywordStart) { m_functionKeywordStart = functionKeywordStart; }

        int functionKeywordStart() const { return m_functionKeywordStart; }

        unsigned startColumn() const { return m_startColumn; }

        unsigned endColumn() const { return m_endColumn; }

@@namespace JSC {

        Identifier m_inferredName;

        FunctionMode m_functionMode;

        RefPtr<FunctionParameters> m_parameters;

1598 int m_functionNameStart;

1599 int m_functionKeywordStart;

16001600 unsigned m_startColumn;

16011601 unsigned m_endColumn;

        int m_functionKeywordStart;

        int m_functionNameStart;

        int m_parametersStart;

        SourceCode m_source;

        int m_startStartOffset;

        unsigned m_isInStrictContext : 1;

181810

Source/JavaScriptCore/parser/Parser.cpp

@@template <class TreeBuilder> TreeFormalP

}

template <typename LexerType>

1263 template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody(TreeBuilder& context, ConstructorKind constructorKind)

template <class TreeBuilder> TreeFunctionBody Parser<LexerType>::parseFunctionBody(

    TreeBuilder& context, int functionKeywordStart, int functionNameStart, 

    int parametersStart, ConstructorKind constructorKind)

{

    JSTokenLocation startLocation(tokenLocation());

    unsigned startColumn = tokenColumn();

@@template <class TreeBuilder> TreeFunctio

    if (match(CLOSEBRACE)) {

        unsigned endColumn = tokenColumn();

1271 return context.createFunctionBody(startLocation, tokenLocation(), startColumn, endColumn, strictMode(), constructorKind);

1273 return context.createFunctionBody(startLocation, tokenLocation(), startColumn, endColumn, functionKeywordStart, functionNameStart, parametersStart, strictMode(), constructorKind);

    }

    DepthManager statementDepth(&m_statementDepth);

    m_statementDepth = 0;

    typename TreeBuilder::FunctionBodyBuilder bodyBuilder(const_cast<VM*>(m_vm), m_lexer.get());

    failIfFalse(parseSourceElements(bodyBuilder, CheckForStrictMode), "Cannot parse body of this function");

    unsigned endColumn = tokenColumn();

1278 return context.createFunctionBody(startLocation, tokenLocation(), startColumn, endColumn, strictMode(), constructorKind);

1280 return context.createFunctionBody(startLocation, tokenLocation(), startColumn, endColumn, functionKeywordStart, functionNameStart, parametersStart, strictMode(), constructorKind);

}

static const char* stringForFunctionMode(FunctionParseMode mode)

@@static const char* stringForFunctionMode

template <typename LexerType>

template <class TreeBuilder> bool Parser<LexerType>::parseFunctionInfo(TreeBuilder& context, FunctionRequirements requirements, FunctionParseMode mode,

1299 bool nameIsInContainingScope, ConstructorKind ownerClassKind, ParserFunctionInfo<TreeBuilder>& info)

1301 bool nameIsInContainingScope, ConstructorKind ownerClassKind, int functionKeywordStart, ParserFunctionInfo<TreeBuilder>& info)

{

    AutoPopScopeRef functionScope(this, pushScope());

    functionScope->setIsFunction();

@@template <class TreeBuilder> bool Parser

        failDueToUnexpectedToken();

        return false;

    }

1321 int parametersStart = m_token.m_location.startOffset;

    if (!consume(OPENPAREN)) {

        semanticFailureDueToKeyword(stringForFunctionMode(mode), " name");

        failWithMessage("Expected an opening '(' before a ", stringForFunctionMode(mode), "'s parameter list");

@@template <class TreeBuilder> bool Parser

            endLocation.startOffset - endLocation.lineStartOffset;

        unsigned currentLineStartOffset = m_token.m_location.lineStartOffset;

1361 info.body = context.createFunctionBody(startLocation, endLocation, info.bodyStartColumn, bodyEndColumn, cachedInfo->strictMode, constructorKind);

        info.body = context.createFunctionBody(

            startLocation, endLocation, info.bodyStartColumn, bodyEndColumn, 

            functionKeywordStart, functionNameStart, parametersStart, 

            cachedInfo->strictMode, constructorKind);

        
        functionScope->restoreFromSourceProviderCache(cachedInfo);

        failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo), "Parser error");

        info.closeBraceOffset = cachedInfo->closeBraceOffset;

1368 context.setFunctionNameStart(info.body, functionNameStart);

        m_token = cachedInfo->closeBraceToken();

        if (endColumnIsOnStartLine)

            m_token.m_location.lineStartOffset = currentLineStartOffset;

@@template <class TreeBuilder> bool Parser

    }

    m_lastFunctionName = lastFunctionName;

    ParserState oldState = saveState();

1384 info.body = parseFunctionBody(context, constructorKind);

1389 info.body = parseFunctionBody(context, functionKeywordStart, functionNameStart, parametersStart, constructorKind);

    restoreState(oldState);

    failIfFalse(info.body, "Cannot parse the body of this ", stringForFunctionMode(mode));

    context.setEndOffset(info.body, m_lexer->currentOffset());

@@template <class TreeBuilder> bool Parser

        newInfo = SourceProviderCacheItem::create(parameters);

    }

1419 context.setFunctionNameStart(info.body, functionNameStart);

    
    failIfFalse(popScope(functionScope, TreeBuilder::NeedsFreeVariableInfo), "Parser error");

    matchOrFail(CLOSEBRACE, "Expected a closing '}' after a ", stringForFunctionMode(mode), " body");

@@template <class TreeBuilder> TreeStateme

    unsigned functionKeywordStart = tokenStart();

    next();

    ParserFunctionInfo<TreeBuilder> info;

1440 failIfFalse((parseFunctionInfo(context, FunctionNeedsName, FunctionMode, true, ConstructorKind::None, info)), "Cannot parse this function");

1444 failIfFalse((parseFunctionInfo(context, FunctionNeedsName, FunctionMode, true, ConstructorKind::None, functionKeywordStart, info)), "Cannot parse this function");

14411445 failIfFalse(info.name, "Function statements must have a name");

14421446 failIfFalseIfStrict(declareVariable(info.name), "Cannot declare a function named '", info.name->impl(), "' in strict mode");

1443 return context.createFuncDeclStatement(location, info~~, functionKeywordStart~~);

1447 return context.createFuncDeclStatement(location, info);

}

#if ENABLE(ES6_CLASS_SYNTAX)

@@template <class TreeBuilder> TreeClassEx

            failIfFalse(property, "Cannot parse this method");

        } else {

            ParserFunctionInfo<TreeBuilder> methodInfo;

1528 failIfFalse((parseFunctionInfo(context, FunctionNeedsName, isStaticMethod ? FunctionMode : MethodMode, false, constructorKind, methodInfo)), "Cannot parse this method");

1532 failIfFalse((parseFunctionInfo(context, FunctionNeedsName, isStaticMethod ? FunctionMode : MethodMode, false, constructorKind, methodStart, methodInfo)), "Cannot parse this method");

            failIfFalse(methodInfo.name, "method must have a name");

            failIfFalse(declareVariable(methodInfo.name), "Cannot declare a method named '", methodInfo.name->impl(), "'");

@@template <class TreeBuilder> TreeClassEx

            if (isConstructor)

                methodInfo.name = className;

1536 TreeExpression method = context.createFunctionExpr(methodLocation, methodInfo~~, methodStart~~);

1540 TreeExpression method = context.createFunctionExpr(methodLocation, methodInfo);

            if (isConstructor) {

                semanticFailIfTrue(constructor, "Cannot declare multiple constructors in a single class");

                constructor = method;

@@template <class TreeBuilder> TreeExpress

    JSTokenLocation methodLocation(tokenLocation());

    unsigned methodStart = tokenStart();

    ParserFunctionInfo<TreeBuilder> methodInfo;

2031 failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, MethodMode, false, ConstructorKind::None, methodInfo)), "Cannot parse this method");

2035 failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, MethodMode, false, ConstructorKind::None, methodStart, methodInfo)), "Cannot parse this method");

20322036 methodInfo.name = methodName;

2033 return context.createFunctionExpr(methodLocation, methodInfo~~, methodStart~~);

2037 return context.createFunctionExpr(methodLocation, methodInfo);

}

template <typename LexerType>

@@template <class TreeBuilder> TreePropert

    ParserFunctionInfo<TreeBuilder> info;

    if (type == PropertyNode::Getter) {

        failIfFalse(match(OPENPAREN), "Expected a parameter list for getter definition");

2053 failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, GetterMode, false, constructorKind, info)), "Cannot parse getter definition");

2057 failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, GetterMode, false, constructorKind, getterOrSetterStartOffset, info)), "Cannot parse getter definition");

20542058 } else {

20552059 failIfFalse(match(OPENPAREN), "Expected a parameter list for setter definition");

2056 failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, SetterMode, false, constructorKind, info)), "Cannot parse setter definition");

2060 failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, SetterMode, false, constructorKind, getterOrSetterStartOffset, info)), "Cannot parse setter definition");

20572061 }

20582062 if (stringPropertyName)

2059 return context.createGetterOrSetterProperty(location, type, strict, stringPropertyName, info, ~~getterOrSetterStartOffset,~~ superBinding);

2060 return context.createGetterOrSetterProperty(const_cast<VM*>(m_vm), m_parserArena, location, type, strict, numericPropertyName, info, ~~getterOrSetterStartOffset,~~ superBinding);

2063 return context.createGetterOrSetterProperty(location, type, strict, stringPropertyName, info, superBinding);

2064 return context.createGetterOrSetterProperty(const_cast<VM*>(m_vm), m_parserArena, location, type, strict, numericPropertyName, info, superBinding);

}

template <typename LexerType>

@@template <class TreeBuilder> TreeExpress

        next();

        ParserFunctionInfo<TreeBuilder> info;

        info.name = &m_vm->propertyNames->nullIdentifier;

2245 failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, FunctionMode, false, ConstructorKind::None, info)), "Cannot parse function expression");

2246 return context.createFunctionExpr(location, info~~, functionKeywordStart~~);

2249 failIfFalse((parseFunctionInfo(context, FunctionNoRequirements, FunctionMode, false, ConstructorKind::None, functionKeywordStart, info)), "Cannot parse function expression");

2250 return context.createFunctionExpr(location, info);

    }

#if ENABLE(ES6_CLASS_SYNTAX)

    case CLASSTOKEN:

181809

Source/JavaScriptCore/parser/Parser.h

@@private:

    template <class TreeBuilder> TreeProperty parseProperty(TreeBuilder&, bool strict);

    template <class TreeBuilder> TreeExpression parsePropertyMethod(TreeBuilder& context, const Identifier* methodName);

    template <class TreeBuilder> TreeProperty parseGetterSetter(TreeBuilder&, bool strict, PropertyNode::Type, unsigned getterOrSetterStartOffset, ConstructorKind = ConstructorKind::None, SuperBinding = SuperBinding::NotNeeded);

765 template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&, ConstructorKind);

765 template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&, int functionKeywordStart, int functionNameStart, int parametersStart, ConstructorKind);

    template <class TreeBuilder> ALWAYS_INLINE TreeFormalParameterList parseFormalParameters(TreeBuilder&);

    enum VarDeclarationListContext { ForLoopContext, VarDeclarationContext };

    template <class TreeBuilder> TreeExpression parseVarDeclarationList(TreeBuilder&, int& declarations, TreeDeconstructionPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext);

@@private:

    template <class TreeBuilder> NEVER_INLINE TreeDeconstructionPattern parseDeconstructionPattern(TreeBuilder&, DeconstructionKind, int depth = 0);

    template <class TreeBuilder> NEVER_INLINE TreeDeconstructionPattern tryParseDeconstructionPatternExpression(TreeBuilder&);

775 template <class TreeBuilder> NEVER_INLINE bool parseFunctionInfo(TreeBuilder&, FunctionRequirements, FunctionParseMode, bool nameIsInContainingScope, ConstructorKind, ParserFunctionInfo<TreeBuilder>&);

#if ENABLE(ES6_CLASS_SYNTAX)

    template <class TreeBuilder> NEVER_INLINE TreeClassExpression parseClass(TreeBuilder&, FunctionRequirements);

#endif

181809

Source/JavaScriptCore/parser/SyntaxChecker.h

@@public:

#if ENABLE(ES6_CLASS_SYNTAX)

    ClassExpression createClassExpr(const JSTokenLocation&, const Identifier&, ExpressionType, ExpressionType, PropertyList, PropertyList) { return ClassExpr; }

#endif

    ExpressionType createFunctionExpr(const JSTokenLocation&, const ParserFunctionInfo<SyntaxChecker>&, int) { return FunctionExpr; }

    int createFunctionBody(const JSTokenLocation&, const JSTokenLocation&, int, int, bool, ConstructorKind) { return FunctionBodyResult; }

    void setFunctionNameStart(int, int) { }

171 ExpressionType createFunctionExpr(const JSTokenLocation&, const ParserFunctionInfo<SyntaxChecker>&) { return FunctionExpr; }

172 int createFunctionBody(const JSTokenLocation&, const JSTokenLocation&, int, int, bool, int, int, int, ConstructorKind) { return FunctionBodyResult; }

    int createArguments() { return ArgumentsResult; }

    int createArguments(int) { return ArgumentsResult; }

    ExpressionType createSpreadExpression(const JSTokenLocation&, ExpressionType, int, int, int) { return SpreadExpr; }

@@public:

    int createClause(int, int) { return ClauseResult; }

    int createClauseList(int) { return ClauseListResult; }

    int createClauseList(int, int) { return ClauseListResult; }

205 int createFuncDeclStatement(const JSTokenLocation&, const ParserFunctionInfo<SyntaxChecker>&~~, int~~) { return StatementResult; }

204 int createFuncDeclStatement(const JSTokenLocation&, const ParserFunctionInfo<SyntaxChecker>&) { return StatementResult; }

#if ENABLE(ES6_CLASS_SYNTAX)

    int createClassDeclStatement(const JSTokenLocation&, ClassExpression,

        const JSTextPosition&, const JSTextPosition&, int, int) { return StatementResult; }

@@public:

    int createDebugger(const JSTokenLocation&, int, int) { return StatementResult; }

    int createConstStatement(const JSTokenLocation&, int, int, int) { return StatementResult; }

    int appendConstDecl(const JSTokenLocation&, int, const Identifier*, int) { return StatementResult; }

234 Property createGetterOrSetterProperty(const JSTokenLocation&, PropertyNode::Type type, bool strict, const Identifier* name, const ParserFunctionInfo<SyntaxChecker>&, ~~unsigned,~~ SuperBinding)

233 Property createGetterOrSetterProperty(const JSTokenLocation&, PropertyNode::Type type, bool strict, const Identifier* name, const ParserFunctionInfo<SyntaxChecker>&, SuperBinding)

    {

        ASSERT(name);

        if (!strict)

            return Property(type);

        return Property(name, type);

    }

241 Property createGetterOrSetterProperty(VM* vm, ParserArena& parserArena, const JSTokenLocation&, PropertyNode::Type type, bool strict, double name, const ParserFunctionInfo<SyntaxChecker>&, ~~unsigned,~~ SuperBinding)

240 Property createGetterOrSetterProperty(VM* vm, ParserArena& parserArena, const JSTokenLocation&, PropertyNode::Type type, bool strict, double name, const ParserFunctionInfo<SyntaxChecker>&, SuperBinding)

    {

        if (!strict)

            return Property(type);

181809