Remove unused m_writtenVariables from the parser and related bits
[WebKit-https.git] / Source / JavaScriptCore / parser / Parser.h
1 /*
2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010, 2011, 2013 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #ifndef Parser_h
24 #define Parser_h
25
26 #include "Debugger.h"
27 #include "ExceptionHelpers.h"
28 #include "Executable.h"
29 #include "JSGlobalObject.h"
30 #include "Lexer.h"
31 #include "Nodes.h"
32 #include "ParserArena.h"
33 #include "ParserError.h"
34 #include "ParserFunctionInfo.h"
35 #include "ParserTokens.h"
36 #include "SourceProvider.h"
37 #include "SourceProviderCache.h"
38 #include "SourceProviderCacheItem.h"
39 #include "VariableEnvironment.h"
40 #include <wtf/Forward.h>
41 #include <wtf/Noncopyable.h>
42 #include <wtf/RefPtr.h>
43
44 namespace JSC {
45
46 class ExecState;
47 class FunctionMetadataNode;
48 class FunctionParameters;
49 class Identifier;
50 class VM;
51 class ProgramNode;
52 class SourceCode;
53
54 // Macros to make the more common TreeBuilder types a little less verbose
55 #define TreeStatement typename TreeBuilder::Statement
56 #define TreeExpression typename TreeBuilder::Expression
57 #define TreeFormalParameterList typename TreeBuilder::FormalParameterList
58 #define TreeSourceElements typename TreeBuilder::SourceElements
59 #define TreeClause typename TreeBuilder::Clause
60 #define TreeClauseList typename TreeBuilder::ClauseList
61 #define TreeArguments typename TreeBuilder::Arguments
62 #define TreeArgumentsList typename TreeBuilder::ArgumentsList
63 #define TreeFunctionBody typename TreeBuilder::FunctionBody
64 #define TreeClassExpression typename TreeBuilder::ClassExpression
65 #define TreeProperty typename TreeBuilder::Property
66 #define TreePropertyList typename TreeBuilder::PropertyList
67 #define TreeDestructuringPattern typename TreeBuilder::DestructuringPattern
68
69 COMPILE_ASSERT(LastUntaggedToken < 64, LessThan64UntaggedTokens);
70
71 enum SourceElementsMode { CheckForStrictMode, DontCheckForStrictMode };
72 enum FunctionBodyType { ArrowFunctionBodyExpression, ArrowFunctionBodyBlock, StandardFunctionBodyBlock };
73 enum FunctionRequirements { FunctionNoRequirements, FunctionNeedsName };
74
75 enum class DestructuringKind {
76     DestructureToVariables,
77     DestructureToLet,
78     DestructureToConst,
79     DestructureToCatchParameters,
80     DestructureToParameters,
81     DestructureToExpressions
82 };
83
84 enum class DeclarationType { 
85     VarDeclaration, 
86     LetDeclaration,
87     ConstDeclaration
88 };
89
90 enum class DeclarationImportType {
91     Imported,
92     ImportedNamespace,
93     NotImported
94 };
95
96 enum DeclarationResult {
97     Valid = 0,
98     InvalidStrictMode = 1 << 0,
99     InvalidDuplicateDeclaration = 1 << 1
100 };
101
102 typedef uint8_t DeclarationResultMask;
103
104
105 template <typename T> inline bool isEvalNode() { return false; }
106 template <> inline bool isEvalNode<EvalNode>() { return true; }
107
108 struct ScopeLabelInfo {
109     UniquedStringImpl* uid;
110     bool isLoop;
111 };
112
113 ALWAYS_INLINE static bool isArguments(const VM* vm, const Identifier* ident)
114 {
115     return vm->propertyNames->arguments == *ident;
116 }
117 ALWAYS_INLINE static bool isEval(const VM* vm, const Identifier* ident)
118 {
119     return vm->propertyNames->eval == *ident;
120 }
121 ALWAYS_INLINE static bool isEvalOrArgumentsIdentifier(const VM* vm, const Identifier* ident)
122 {
123     return isEval(vm, ident) || isArguments(vm, ident);
124 }
125 ALWAYS_INLINE static bool isIdentifierOrKeyword(const JSToken& token)
126 {
127     return token.m_type == IDENT || token.m_type & KeywordTokenFlag;
128 }
129
130 class ModuleScopeData : public RefCounted<ModuleScopeData> {
131 public:
132     static Ref<ModuleScopeData> create() { return adoptRef(*new ModuleScopeData); }
133
134     const IdentifierSet& exportedBindings() const { return m_exportedBindings; }
135
136     bool exportName(const Identifier& exportedName)
137     {
138         return m_exportedNames.add(exportedName.impl()).isNewEntry;
139     }
140
141     void exportBinding(const Identifier& localName)
142     {
143         m_exportedBindings.add(localName.impl());
144     }
145
146 private:
147     IdentifierSet m_exportedNames { };
148     IdentifierSet m_exportedBindings { };
149 };
150
151 struct Scope {
152     WTF_MAKE_NONCOPYABLE(Scope);
153
154 public:
155     Scope(const VM* vm, bool isFunction, bool isGenerator, bool strictMode, bool isArrowFunction)
156         : m_vm(vm)
157         , m_shadowsArguments(false)
158         , m_usesEval(false)
159         , m_needsFullActivation(false)
160         , m_hasDirectSuper(false)
161         , m_needsSuperBinding(false)
162         , m_allowsVarDeclarations(true)
163         , m_allowsLexicalDeclarations(true)
164         , m_strictMode(strictMode)
165         , m_isFunction(isFunction)
166         , m_isGenerator(isGenerator)
167         , m_isGeneratorBoundary(false)
168         , m_isArrowFunction(isArrowFunction)
169         , m_isArrowFunctionBoundary(false)
170         , m_isLexicalScope(false)
171         , m_isFunctionBoundary(false)
172         , m_isValidStrictMode(true)
173         , m_hasArguments(false)
174         , m_isEvalContext(false)
175         , m_evalContextType(EvalContextType::None)
176         , m_constructorKind(static_cast<unsigned>(ConstructorKind::None))
177         , m_expectedSuperBinding(static_cast<unsigned>(SuperBinding::NotNeeded))
178         , m_loopDepth(0)
179         , m_switchDepth(0)
180         , m_innerArrowFunctionFeatures(0)
181     {
182         m_usedVariables.append(UniquedStringImplPtrSet());
183     }
184
185     Scope(Scope&& other)
186         : m_vm(other.m_vm)
187         , m_shadowsArguments(other.m_shadowsArguments)
188         , m_usesEval(other.m_usesEval)
189         , m_needsFullActivation(other.m_needsFullActivation)
190         , m_hasDirectSuper(other.m_hasDirectSuper)
191         , m_needsSuperBinding(other.m_needsSuperBinding)
192         , m_allowsVarDeclarations(other.m_allowsVarDeclarations)
193         , m_allowsLexicalDeclarations(other.m_allowsLexicalDeclarations)
194         , m_strictMode(other.m_strictMode)
195         , m_isFunction(other.m_isFunction)
196         , m_isGenerator(other.m_isGenerator)
197         , m_isGeneratorBoundary(other.m_isGeneratorBoundary)
198         , m_isArrowFunction(other.m_isArrowFunction)
199         , m_isArrowFunctionBoundary(other.m_isArrowFunctionBoundary)
200         , m_isLexicalScope(other.m_isLexicalScope)
201         , m_isFunctionBoundary(other.m_isFunctionBoundary)
202         , m_isValidStrictMode(other.m_isValidStrictMode)
203         , m_hasArguments(other.m_hasArguments)
204         , m_isEvalContext(other.m_isEvalContext)
205         , m_constructorKind(other.m_constructorKind)
206         , m_expectedSuperBinding(other.m_expectedSuperBinding)
207         , m_loopDepth(other.m_loopDepth)
208         , m_switchDepth(other.m_switchDepth)
209         , m_innerArrowFunctionFeatures(other.m_innerArrowFunctionFeatures)
210         , m_labels(WTFMove(other.m_labels))
211         , m_declaredParameters(WTFMove(other.m_declaredParameters))
212         , m_declaredVariables(WTFMove(other.m_declaredVariables))
213         , m_lexicalVariables(WTFMove(other.m_lexicalVariables))
214         , m_usedVariables(WTFMove(other.m_usedVariables))
215         , m_closedVariableCandidates(WTFMove(other.m_closedVariableCandidates))
216         , m_moduleScopeData(WTFMove(other.m_moduleScopeData))
217         , m_functionDeclarations(WTFMove(other.m_functionDeclarations))
218     {
219     }
220
221     void startSwitch() { m_switchDepth++; }
222     void endSwitch() { m_switchDepth--; }
223     void startLoop() { m_loopDepth++; }
224     void endLoop() { ASSERT(m_loopDepth); m_loopDepth--; }
225     bool inLoop() { return !!m_loopDepth; }
226     bool breakIsValid() { return m_loopDepth || m_switchDepth; }
227     bool continueIsValid() { return m_loopDepth; }
228
229     void pushLabel(const Identifier* label, bool isLoop)
230     {
231         if (!m_labels)
232             m_labels = std::make_unique<LabelStack>();
233         m_labels->append(ScopeLabelInfo { label->impl(), isLoop });
234     }
235
236     void popLabel()
237     {
238         ASSERT(m_labels);
239         ASSERT(m_labels->size());
240         m_labels->removeLast();
241     }
242
243     ScopeLabelInfo* getLabel(const Identifier* label)
244     {
245         if (!m_labels)
246             return 0;
247         for (int i = m_labels->size(); i > 0; i--) {
248             if (m_labels->at(i - 1).uid == label->impl())
249                 return &m_labels->at(i - 1);
250         }
251         return 0;
252     }
253
254     void setSourceParseMode(SourceParseMode mode)
255     {
256         switch (mode) {
257         case SourceParseMode::GeneratorBodyMode:
258             setIsGenerator();
259             break;
260
261         case SourceParseMode::GeneratorWrapperFunctionMode:
262             setIsGeneratorFunction();
263             break;
264
265         case SourceParseMode::NormalFunctionMode:
266         case SourceParseMode::GetterMode:
267         case SourceParseMode::SetterMode:
268         case SourceParseMode::MethodMode:
269             setIsFunction();
270             break;
271
272         case SourceParseMode::ArrowFunctionMode:
273             setIsArrowFunction();
274             break;
275
276         case SourceParseMode::ProgramMode:
277             break;
278
279         case SourceParseMode::ModuleAnalyzeMode:
280         case SourceParseMode::ModuleEvaluateMode:
281             setIsModule();
282             break;
283         }
284     }
285
286     bool isFunction() const { return m_isFunction; }
287     bool isFunctionBoundary() const { return m_isFunctionBoundary; }
288     bool isGenerator() const { return m_isGenerator; }
289     bool isGeneratorBoundary() const { return m_isGeneratorBoundary; }
290
291     bool hasArguments() const { return m_hasArguments; }
292
293     void setIsLexicalScope() 
294     { 
295         m_isLexicalScope = true;
296         m_allowsLexicalDeclarations = true;
297     }
298     bool isLexicalScope() { return m_isLexicalScope; }
299
300     const IdentifierSet& closedVariableCandidates() const { return m_closedVariableCandidates; }
301     VariableEnvironment& declaredVariables() { return m_declaredVariables; }
302     VariableEnvironment& lexicalVariables() { return m_lexicalVariables; }
303     VariableEnvironment& finalizeLexicalEnvironment() 
304     { 
305         if (m_usesEval || m_needsFullActivation)
306             m_lexicalVariables.markAllVariablesAsCaptured();
307         else
308             computeLexicallyCapturedVariablesAndPurgeCandidates();
309
310         return m_lexicalVariables;
311     }
312
313     ModuleScopeData& moduleScopeData() const
314     {
315         ASSERT(m_moduleScopeData);
316         return *m_moduleScopeData;
317     }
318
319     void computeLexicallyCapturedVariablesAndPurgeCandidates()
320     {
321         // Because variables may be defined at any time in the range of a lexical scope, we must
322         // track lexical variables that might be captured. Then, when we're preparing to pop the top
323         // lexical scope off the stack, we should find which variables are truly captured, and which
324         // variable still may be captured in a parent scope.
325         if (m_lexicalVariables.size() && m_closedVariableCandidates.size()) {
326             auto end = m_closedVariableCandidates.end();
327             for (auto iter = m_closedVariableCandidates.begin(); iter != end; ++iter)
328                 m_lexicalVariables.markVariableAsCapturedIfDefined(iter->get());
329         }
330
331         // We can now purge values from the captured candidates because they're captured in this scope.
332         {
333             for (auto entry : m_lexicalVariables) {
334                 if (entry.value.isCaptured())
335                     m_closedVariableCandidates.remove(entry.key);
336             }
337         }
338     }
339
340     DeclarationResultMask declareCallee(const Identifier* ident)
341     {
342         auto addResult = m_declaredVariables.add(ident->impl());
343         // We want to track if callee is captured, but we don't want to act like it's a 'var'
344         // because that would cause the BytecodeGenerator to emit bad code.
345         addResult.iterator->value.clearIsVar();
346
347         DeclarationResultMask result = DeclarationResult::Valid;
348         if (isEvalOrArgumentsIdentifier(m_vm, ident))
349             result |= DeclarationResult::InvalidStrictMode;
350         return result;
351     }
352
353     DeclarationResultMask declareVariable(const Identifier* ident)
354     {
355         ASSERT(m_allowsVarDeclarations);
356         DeclarationResultMask result = DeclarationResult::Valid;
357         bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);
358         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
359         auto addResult = m_declaredVariables.add(ident->impl());
360         addResult.iterator->value.setIsVar();
361         if (!isValidStrictMode)
362             result |= DeclarationResult::InvalidStrictMode;
363         if (m_lexicalVariables.contains(ident->impl()))
364             result |= DeclarationResult::InvalidDuplicateDeclaration;
365         return result;
366     }
367
368     DeclarationResultMask declareFunction(const Identifier* ident, bool declareAsVar, bool isSloppyModeHoistingCandidate)
369     {
370         ASSERT(m_allowsVarDeclarations || m_allowsLexicalDeclarations);
371         DeclarationResultMask result = DeclarationResult::Valid;
372         bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);
373         if (!isValidStrictMode)
374             result |= DeclarationResult::InvalidStrictMode;
375         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
376         auto addResult = declareAsVar ? m_declaredVariables.add(ident->impl()) : m_lexicalVariables.add(ident->impl());
377         if (isSloppyModeHoistingCandidate)
378             addResult.iterator->value.setIsSloppyModeHoistingCandidate();
379         if (declareAsVar) {
380             addResult.iterator->value.setIsVar();
381             if (m_lexicalVariables.contains(ident->impl()))
382                 result |= DeclarationResult::InvalidDuplicateDeclaration;
383         } else {
384             addResult.iterator->value.setIsLet();
385             ASSERT_WITH_MESSAGE(!m_declaredVariables.size(), "We should only declare a function as a lexically scoped variable in scopes where var declarations aren't allowed. I.e, in strict mode and not at the top-level scope of a function or program.");
386             if (!addResult.isNewEntry) {
387                 if (!isSloppyModeHoistingCandidate || !addResult.iterator->value.isFunction())
388                     result |= DeclarationResult::InvalidDuplicateDeclaration;
389             }
390         }
391
392         addResult.iterator->value.setIsFunction();
393
394         return result;
395     }
396
397     void addSloppyModeHoistableFunctionCandidate(const Identifier* ident)
398     {
399         ASSERT(m_allowsVarDeclarations);
400         m_sloppyModeHoistableFunctionCandidates.add(ident->impl());
401     }
402
403     void appendFunction(FunctionMetadataNode* node)
404     { 
405         ASSERT(node);
406         m_functionDeclarations.append(node);
407     }
408     DeclarationStacks::FunctionStack&& takeFunctionDeclarations() { return WTFMove(m_functionDeclarations); }
409     
410
411     DeclarationResultMask declareLexicalVariable(const Identifier* ident, bool isConstant, DeclarationImportType importType = DeclarationImportType::NotImported)
412     {
413         ASSERT(m_allowsLexicalDeclarations);
414         DeclarationResultMask result = DeclarationResult::Valid;
415         bool isValidStrictMode = !isEvalOrArgumentsIdentifier(m_vm, ident);
416         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
417         auto addResult = m_lexicalVariables.add(ident->impl());
418         if (isConstant)
419             addResult.iterator->value.setIsConst();
420         else
421             addResult.iterator->value.setIsLet();
422
423         if (importType == DeclarationImportType::Imported)
424             addResult.iterator->value.setIsImported();
425         else if (importType == DeclarationImportType::ImportedNamespace) {
426             addResult.iterator->value.setIsImported();
427             addResult.iterator->value.setIsImportedNamespace();
428         }
429
430         if (!addResult.isNewEntry)
431             result |= DeclarationResult::InvalidDuplicateDeclaration;
432         if (!isValidStrictMode)
433             result |= DeclarationResult::InvalidStrictMode;
434
435         return result;
436     }
437
438     bool hasDeclaredVariable(const Identifier& ident)
439     {
440         return hasDeclaredVariable(ident.impl());
441     }
442
443     bool hasDeclaredVariable(const RefPtr<UniquedStringImpl>& ident)
444     {
445         auto iter = m_declaredVariables.find(ident.get());
446         if (iter == m_declaredVariables.end())
447             return false;
448         VariableEnvironmentEntry entry = iter->value;
449         return entry.isVar(); // The callee isn't a "var".
450     }
451
452     bool hasLexicallyDeclaredVariable(const RefPtr<UniquedStringImpl>& ident) const
453     {
454         return m_lexicalVariables.contains(ident.get());
455     }
456     
457     ALWAYS_INLINE bool hasDeclaredParameter(const Identifier& ident)
458     {
459         return hasDeclaredParameter(ident.impl());
460     }
461
462     bool hasDeclaredParameter(const RefPtr<UniquedStringImpl>& ident)
463     {
464         return m_declaredParameters.contains(ident.get()) || hasDeclaredVariable(ident);
465     }
466     
467     void preventAllVariableDeclarations()
468     {
469         m_allowsVarDeclarations = false; 
470         m_allowsLexicalDeclarations = false;
471     }
472     void preventVarDeclarations() { m_allowsVarDeclarations = false; }
473     bool allowsVarDeclarations() const { return m_allowsVarDeclarations; }
474     bool allowsLexicalDeclarations() const { return m_allowsLexicalDeclarations; }
475
476     DeclarationResultMask declareParameter(const Identifier* ident)
477     {
478         ASSERT(m_allowsVarDeclarations);
479         DeclarationResultMask result = DeclarationResult::Valid;
480         bool isArgumentsIdent = isArguments(m_vm, ident);
481         auto addResult = m_declaredVariables.add(ident->impl());
482         addResult.iterator->value.clearIsVar();
483         addResult.iterator->value.setIsParameter();
484         bool isValidStrictMode = addResult.isNewEntry && m_vm->propertyNames->eval != *ident && !isArgumentsIdent;
485         m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
486         m_declaredParameters.add(ident->impl());
487         if (!isValidStrictMode)
488             result |= DeclarationResult::InvalidStrictMode;
489         if (isArgumentsIdent)
490             m_shadowsArguments = true;
491         if (!addResult.isNewEntry)
492             result |= DeclarationResult::InvalidDuplicateDeclaration;
493
494         return result;
495     }
496     
497     bool usedVariablesContains(UniquedStringImpl* impl) const
498     { 
499         for (const UniquedStringImplPtrSet& set : m_usedVariables) {
500             if (set.contains(impl))
501                 return true;
502         }
503         return false;
504     }
505     void useVariable(const Identifier* ident, bool isEval)
506     {
507         useVariable(ident->impl(), isEval);
508     }
509     void useVariable(UniquedStringImpl* impl, bool isEval)
510     {
511         m_usesEval |= isEval;
512         m_usedVariables.last().add(impl);
513     }
514
515     void pushUsedVariableSet() { m_usedVariables.append(UniquedStringImplPtrSet()); }
516     size_t currentUsedVariablesSize() { return m_usedVariables.size(); }
517
518     void revertToPreviousUsedVariables(size_t size) { m_usedVariables.resize(size); }
519
520     void setNeedsFullActivation() { m_needsFullActivation = true; }
521     bool needsFullActivation() const { return m_needsFullActivation; }
522     bool isArrowFunctionBoundary() { return m_isArrowFunctionBoundary; }
523     bool isArrowFunction() { return m_isArrowFunction; }
524
525     bool hasDirectSuper() { return m_hasDirectSuper; }
526     void setHasDirectSuper() { m_hasDirectSuper = true; }
527
528     bool needsSuperBinding() { return m_needsSuperBinding; }
529     void setNeedsSuperBinding() { m_needsSuperBinding = true; }
530     
531     void setEvalContextType(EvalContextType evalContextType) { m_evalContextType = evalContextType; }
532     EvalContextType evalContextType() { return m_evalContextType; }
533     
534     InnerArrowFunctionCodeFeatures innerArrowFunctionFeatures() { return m_innerArrowFunctionFeatures; }
535     
536     void setExpectedSuperBinding(SuperBinding superBinding) { m_expectedSuperBinding = static_cast<unsigned>(superBinding); }
537     SuperBinding expectedSuperBinding() const { return static_cast<SuperBinding>(m_expectedSuperBinding); }
538     void setConstructorKind(ConstructorKind constructorKind) { m_constructorKind = static_cast<unsigned>(constructorKind); }
539     ConstructorKind constructorKind() const { return static_cast<ConstructorKind>(m_constructorKind); }
540
541     void setInnerArrowFunctionUsesSuperCall() { m_innerArrowFunctionFeatures |= SuperCallInnerArrowFunctionFeature; }
542     void setInnerArrowFunctionUsesSuperProperty() { m_innerArrowFunctionFeatures |= SuperPropertyInnerArrowFunctionFeature; }
543     void setInnerArrowFunctionUsesEval() { m_innerArrowFunctionFeatures |= EvalInnerArrowFunctionFeature; }
544     void setInnerArrowFunctionUsesThis() { m_innerArrowFunctionFeatures |= ThisInnerArrowFunctionFeature; }
545     void setInnerArrowFunctionUsesNewTarget() { m_innerArrowFunctionFeatures |= NewTargetInnerArrowFunctionFeature; }
546     void setInnerArrowFunctionUsesArguments() { m_innerArrowFunctionFeatures |= ArgumentsInnerArrowFunctionFeature; }
547     
548     bool isEvalContext() const { return m_isEvalContext; }
549     void setIsEvalContext(bool isEvalContext) { m_isEvalContext = isEvalContext; }
550
551     void setInnerArrowFunctionUsesEvalAndUseArgumentsIfNeeded()
552     {
553         ASSERT(m_isArrowFunction);
554
555         if (m_usesEval)
556             setInnerArrowFunctionUsesEval();
557         
558         if (usedVariablesContains(m_vm->propertyNames->arguments.impl()))
559             setInnerArrowFunctionUsesArguments();
560     }
561     
562     void collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)
563     {
564         if (nestedScope->m_usesEval)
565             m_usesEval = true;
566
567         {
568             UniquedStringImplPtrSet& destinationSet = m_usedVariables.last();
569             for (const UniquedStringImplPtrSet& usedVariablesSet : nestedScope->m_usedVariables) {
570                 for (UniquedStringImpl* impl : usedVariablesSet) {
571                     if (nestedScope->m_declaredVariables.contains(impl) || nestedScope->m_lexicalVariables.contains(impl))
572                         continue;
573
574                     // "arguments" reference should be resolved at function boudary.
575                     if (nestedScope->isFunctionBoundary() && nestedScope->hasArguments() && impl == m_vm->propertyNames->arguments.impl() && !nestedScope->isArrowFunctionBoundary())
576                         continue;
577
578                     destinationSet.add(impl);
579                     // We don't want a declared variable that is used in an inner scope to be thought of as captured if
580                     // that inner scope is both a lexical scope and not a function. Only inner functions and "catch" 
581                     // statements can cause variables to be captured.
582                     if (shouldTrackClosedVariables && (nestedScope->m_isFunctionBoundary || !nestedScope->m_isLexicalScope))
583                         m_closedVariableCandidates.add(impl);
584                 }
585             }
586         }
587         // Propagate closed variable candidates downwards within the same function.
588         // Cross function captures will be realized via m_usedVariables propagation.
589         if (shouldTrackClosedVariables && !nestedScope->m_isFunctionBoundary && nestedScope->m_closedVariableCandidates.size()) {
590             IdentifierSet::iterator end = nestedScope->m_closedVariableCandidates.end();
591             IdentifierSet::iterator begin = nestedScope->m_closedVariableCandidates.begin();
592             m_closedVariableCandidates.add(begin, end);
593         }
594     }
595     
596     void mergeInnerArrowFunctionFeatures(InnerArrowFunctionCodeFeatures arrowFunctionCodeFeatures)
597     {
598         m_innerArrowFunctionFeatures = m_innerArrowFunctionFeatures | arrowFunctionCodeFeatures;
599     }
600     
601     void getSloppyModeHoistedFunctions(UniquedStringImplPtrSet& sloppyModeHoistedFunctions)
602     {
603         for (UniquedStringImpl* function : m_sloppyModeHoistableFunctionCandidates) {
604             // ES6 Annex B.3.3. The only time we can't hoist a function is if a syntax error would
605             // be caused by declaring a var with that function's name or if we have a parameter with
606             // that function's name. Note that we would only cause a syntax error if we had a let/const/class
607             // variable with the same name.
608             if (!m_lexicalVariables.contains(function)) {
609                 auto iter = m_declaredVariables.find(function);
610                 bool isParameter = iter != m_declaredVariables.end() && iter->value.isParameter();
611                 if (!isParameter) {
612                     auto addResult = m_declaredVariables.add(function);
613                     addResult.iterator->value.setIsVar();
614                     sloppyModeHoistedFunctions.add(function);
615                 }
616             }
617         }
618     }
619
620     void getCapturedVars(IdentifierSet& capturedVariables)
621     {
622         if (m_needsFullActivation || m_usesEval) {
623             for (auto& entry : m_declaredVariables)
624                 capturedVariables.add(entry.key);
625             return;
626         }
627         for (IdentifierSet::iterator ptr = m_closedVariableCandidates.begin(); ptr != m_closedVariableCandidates.end(); ++ptr) {
628             // We refer to m_declaredVariables here directly instead of a hasDeclaredVariable because we want to mark the callee as captured.
629             if (!m_declaredVariables.contains(*ptr)) 
630                 continue;
631             capturedVariables.add(*ptr);
632         }
633     }
634     void setStrictMode() { m_strictMode = true; }
635     bool strictMode() const { return m_strictMode; }
636     bool isValidStrictMode() const { return m_isValidStrictMode; }
637     bool shadowsArguments() const { return m_shadowsArguments; }
638
639     void copyCapturedVariablesToVector(const UniquedStringImplPtrSet& capturedVariables, Vector<RefPtr<UniquedStringImpl>>& vector)
640     {
641         for (UniquedStringImpl* impl : capturedVariables) {
642             if (m_declaredVariables.contains(impl) || m_lexicalVariables.contains(impl))
643                 continue;
644             vector.append(impl);
645         }
646     }
647
648     void fillParametersForSourceProviderCache(SourceProviderCacheItemCreationParameters& parameters)
649     {
650         ASSERT(m_isFunction);
651         parameters.usesEval = m_usesEval;
652         parameters.strictMode = m_strictMode;
653         parameters.needsFullActivation = m_needsFullActivation;
654         parameters.innerArrowFunctionFeatures = m_innerArrowFunctionFeatures;
655         for (const UniquedStringImplPtrSet& set : m_usedVariables)
656             copyCapturedVariablesToVector(set, parameters.usedVariables);
657     }
658
659     void restoreFromSourceProviderCache(const SourceProviderCacheItem* info)
660     {
661         ASSERT(m_isFunction);
662         m_usesEval = info->usesEval;
663         m_strictMode = info->strictMode;
664         m_innerArrowFunctionFeatures = info->innerArrowFunctionFeatures;
665         m_needsFullActivation = info->needsFullActivation;
666         UniquedStringImplPtrSet& destSet = m_usedVariables.last();
667         for (unsigned i = 0; i < info->usedVariablesCount; ++i)
668             destSet.add(info->usedVariables()[i]);
669     }
670
671 private:
672     void setIsFunction()
673     {
674         m_isFunction = true;
675         m_isFunctionBoundary = true;
676         m_hasArguments = true;
677         setIsLexicalScope();
678         m_isGenerator = false;
679         m_isGeneratorBoundary = false;
680         m_isArrowFunctionBoundary = false;
681         m_isArrowFunction = false;
682     }
683
684     void setIsGeneratorFunction()
685     {
686         setIsFunction();
687         m_isGenerator = true;
688     }
689
690     void setIsGenerator()
691     {
692         setIsFunction();
693         m_isGenerator = true;
694         m_isGeneratorBoundary = true;
695         m_hasArguments = false;
696     }
697     
698     void setIsArrowFunction()
699     {
700         setIsFunction();
701         m_isArrowFunctionBoundary = true;
702         m_isArrowFunction = true;
703     }
704
705     void setIsModule()
706     {
707         m_moduleScopeData = ModuleScopeData::create();
708     }
709
710     const VM* m_vm;
711     bool m_shadowsArguments;
712     bool m_usesEval;
713     bool m_needsFullActivation;
714     bool m_hasDirectSuper;
715     bool m_needsSuperBinding;
716     bool m_allowsVarDeclarations;
717     bool m_allowsLexicalDeclarations;
718     bool m_strictMode;
719     bool m_isFunction;
720     bool m_isGenerator;
721     bool m_isGeneratorBoundary;
722     bool m_isArrowFunction;
723     bool m_isArrowFunctionBoundary;
724     bool m_isLexicalScope;
725     bool m_isFunctionBoundary;
726     bool m_isValidStrictMode;
727     bool m_hasArguments;
728     bool m_isEvalContext;
729     EvalContextType m_evalContextType;
730     unsigned m_constructorKind;
731     unsigned m_expectedSuperBinding;
732     int m_loopDepth;
733     int m_switchDepth;
734     InnerArrowFunctionCodeFeatures m_innerArrowFunctionFeatures;
735
736     typedef Vector<ScopeLabelInfo, 2> LabelStack;
737     std::unique_ptr<LabelStack> m_labels;
738     UniquedStringImplPtrSet m_declaredParameters;
739     VariableEnvironment m_declaredVariables;
740     VariableEnvironment m_lexicalVariables;
741     Vector<UniquedStringImplPtrSet, 6> m_usedVariables;
742     UniquedStringImplPtrSet m_sloppyModeHoistableFunctionCandidates;
743     IdentifierSet m_closedVariableCandidates;
744     RefPtr<ModuleScopeData> m_moduleScopeData;
745     DeclarationStacks::FunctionStack m_functionDeclarations;
746 };
747
748 typedef Vector<Scope, 10> ScopeStack;
749
750 struct ScopeRef {
751     ScopeRef(ScopeStack* scopeStack, unsigned index)
752         : m_scopeStack(scopeStack)
753         , m_index(index)
754     {
755     }
756     Scope* operator->() { return &m_scopeStack->at(m_index); }
757     unsigned index() const { return m_index; }
758
759     bool hasContainingScope()
760     {
761         return m_index && !m_scopeStack->at(m_index).isFunctionBoundary();
762     }
763
764     ScopeRef containingScope()
765     {
766         ASSERT(hasContainingScope());
767         return ScopeRef(m_scopeStack, m_index - 1);
768     }
769
770     bool operator==(const ScopeRef& other)
771     {
772         ASSERT(other.m_scopeStack == m_scopeStack);
773         return m_index == other.m_index;
774     }
775
776     bool operator!=(const ScopeRef& other)
777     {
778         return !(*this == other);
779     }
780
781 private:
782     ScopeStack* m_scopeStack;
783     unsigned m_index;
784 };
785
786 enum class ArgumentType {
787     Normal,
788     Spread
789 };
790
791 template <typename LexerType>
792 class Parser {
793     WTF_MAKE_NONCOPYABLE(Parser);
794     WTF_MAKE_FAST_ALLOCATED;
795
796 public:
797     Parser(VM*, const SourceCode&, JSParserBuiltinMode, JSParserStrictMode, SourceParseMode, SuperBinding, ConstructorKind defaultConstructorKind = ConstructorKind::None, ThisTDZMode = ThisTDZMode::CheckIfNeeded, DerivedContextType = DerivedContextType::None, bool isEvalContext = false, EvalContextType = EvalContextType::None);
798     ~Parser();
799
800     template <class ParsedNode>
801     std::unique_ptr<ParsedNode> parse(ParserError&, const Identifier&, SourceParseMode);
802
803     JSTextPosition positionBeforeLastNewline() const { return m_lexer->positionBeforeLastNewline(); }
804     JSTokenLocation locationBeforeLastToken() const { return m_lexer->lastTokenLocation(); }
805
806 private:
807     struct AllowInOverride {
808         AllowInOverride(Parser* parser)
809             : m_parser(parser)
810             , m_oldAllowsIn(parser->m_allowsIn)
811         {
812             parser->m_allowsIn = true;
813         }
814         ~AllowInOverride()
815         {
816             m_parser->m_allowsIn = m_oldAllowsIn;
817         }
818         Parser* m_parser;
819         bool m_oldAllowsIn;
820     };
821
822     struct AutoPopScopeRef : public ScopeRef {
823         AutoPopScopeRef(Parser* parser, ScopeRef scope)
824         : ScopeRef(scope)
825         , m_parser(parser)
826         {
827         }
828         
829         ~AutoPopScopeRef()
830         {
831             if (m_parser)
832                 m_parser->popScope(*this, false);
833         }
834         
835         void setPopped()
836         {
837             m_parser = 0;
838         }
839         
840     private:
841         Parser* m_parser;
842     };
843
844     struct AutoCleanupLexicalScope {
845         // We can allocate this object on the stack without actually knowing beforehand if we're 
846         // going to create a new lexical scope. If we decide to create a new lexical scope, we
847         // can pass the scope into this obejct and it will take care of the cleanup for us if the parse fails.
848         // This is helpful if we may fail from syntax errors after creating a lexical scope conditionally.
849         AutoCleanupLexicalScope()
850             : m_scope(nullptr, UINT_MAX)
851             , m_parser(nullptr)
852         {
853         }
854
855         ~AutoCleanupLexicalScope()
856         {
857             // This should only ever be called if we fail from a syntax error. Otherwise
858             // it's the intention that a user of this class pops this scope manually on a 
859             // successful parse. 
860             if (isValid())
861                 m_parser->popScope(*this, false);
862         }
863
864         void setIsValid(ScopeRef& scope, Parser* parser)
865         {
866             RELEASE_ASSERT(scope->isLexicalScope());
867             m_scope = scope;
868             m_parser = parser;
869         }
870
871         bool isValid() const { return !!m_parser; }
872
873         void setPopped()
874         {
875             m_parser = nullptr;
876         }
877
878         ScopeRef& scope() { return m_scope; }
879
880     private:
881         ScopeRef m_scope;
882         Parser* m_parser;
883     };
884
885     enum ExpressionErrorClass {
886         ErrorIndicatesNothing,
887         ErrorIndicatesPattern
888     };
889
890     struct ExpressionErrorClassifier {
891         ExpressionErrorClassifier(Parser* parser)
892             : m_class(ErrorIndicatesNothing)
893             , m_previous(parser->m_expressionErrorClassifier)
894             , m_parser(parser)
895         {
896             m_parser->m_expressionErrorClassifier = this;
897         }
898
899         ~ExpressionErrorClassifier()
900         {
901             m_parser->m_expressionErrorClassifier = m_previous;
902         }
903
904         void classifyExpressionError(ExpressionErrorClass classification)
905         {
906             if (m_class != ErrorIndicatesNothing)
907                 return;
908             m_class = classification;
909         }
910
911         void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
912         {
913             if (m_class != oldClassification)
914                 return;
915             m_class = classification;
916         }
917
918         void propagateExpressionErrorClass()
919         {
920             if (m_previous && m_class != ErrorIndicatesNothing)
921                 m_previous->m_class = m_class;
922         }
923
924         bool indicatesPossiblePattern() const { return m_class == ErrorIndicatesPattern; }
925
926     private:
927         ExpressionErrorClass m_class;
928         ExpressionErrorClassifier* m_previous;
929         Parser* m_parser;
930     };
931
932     ALWAYS_INLINE void classifyExpressionError(ExpressionErrorClass classification)
933     {
934         if (m_expressionErrorClassifier)
935             m_expressionErrorClassifier->classifyExpressionError(classification);
936     }
937
938     ALWAYS_INLINE void reclassifyExpressionError(ExpressionErrorClass oldClassification, ExpressionErrorClass classification)
939     {
940         if (m_expressionErrorClassifier)
941             m_expressionErrorClassifier->reclassifyExpressionError(oldClassification, classification);
942     }
943
944     ALWAYS_INLINE DestructuringKind destructuringKindFromDeclarationType(DeclarationType type)
945     {
946         switch (type) {
947         case DeclarationType::VarDeclaration:
948             return DestructuringKind::DestructureToVariables;
949         case DeclarationType::LetDeclaration:
950             return DestructuringKind::DestructureToLet;
951         case DeclarationType::ConstDeclaration:
952             return DestructuringKind::DestructureToConst;
953         }
954
955         RELEASE_ASSERT_NOT_REACHED();
956         return DestructuringKind::DestructureToVariables;
957     }
958
959     ALWAYS_INLINE AssignmentContext assignmentContextFromDeclarationType(DeclarationType type)
960     {
961         switch (type) {
962         case DeclarationType::ConstDeclaration:
963             return AssignmentContext::ConstDeclarationStatement;
964         default:
965             return AssignmentContext::DeclarationStatement;
966         }
967     }
968
969     ALWAYS_INLINE bool isEvalOrArguments(const Identifier* ident) { return isEvalOrArgumentsIdentifier(m_vm, ident); }
970
971     ScopeRef currentScope()
972     {
973         return ScopeRef(&m_scopeStack, m_scopeStack.size() - 1);
974     }
975
976     ScopeRef currentVariableScope()
977     {
978         unsigned i = m_scopeStack.size() - 1;
979         ASSERT(i < m_scopeStack.size());
980         while (!m_scopeStack[i].allowsVarDeclarations()) {
981             i--;
982             ASSERT(i < m_scopeStack.size());
983         }
984         return ScopeRef(&m_scopeStack, i);
985     }
986
987     ScopeRef currentLexicalDeclarationScope()
988     {
989         unsigned i = m_scopeStack.size() - 1;
990         ASSERT(i < m_scopeStack.size());
991         while (!m_scopeStack[i].allowsLexicalDeclarations()) {
992             i--;
993             ASSERT(i < m_scopeStack.size());
994         }
995
996         return ScopeRef(&m_scopeStack, i);
997     }
998
999     ScopeRef currentFunctionScope()
1000     {
1001         unsigned i = m_scopeStack.size() - 1;
1002         ASSERT(i < m_scopeStack.size());
1003         while (i && !m_scopeStack[i].isFunctionBoundary()) {
1004             i--;
1005             ASSERT(i < m_scopeStack.size());
1006         }
1007         // When reaching the top level scope (it can be non function scope), we return it.
1008         return ScopeRef(&m_scopeStack, i);
1009     }
1010
1011     ScopeRef closestParentOrdinaryFunctionNonLexicalScope()
1012     {
1013         unsigned i = m_scopeStack.size() - 1;
1014         ASSERT(i < m_scopeStack.size() && m_scopeStack.size());
1015         while (i && (!m_scopeStack[i].isFunctionBoundary() || m_scopeStack[i].isGeneratorBoundary() || m_scopeStack[i].isArrowFunctionBoundary()))
1016             i--;
1017         return ScopeRef(&m_scopeStack, i);
1018     }
1019     
1020     ScopeRef pushScope()
1021     {
1022         bool isFunction = false;
1023         bool isStrict = false;
1024         bool isGenerator = false;
1025         bool isArrowFunction = false;
1026         if (!m_scopeStack.isEmpty()) {
1027             isStrict = m_scopeStack.last().strictMode();
1028             isFunction = m_scopeStack.last().isFunction();
1029             isGenerator = m_scopeStack.last().isGenerator();
1030             isArrowFunction = m_scopeStack.last().isArrowFunction();
1031         }
1032         m_scopeStack.constructAndAppend(m_vm, isFunction, isGenerator, isStrict, isArrowFunction);
1033         return currentScope();
1034     }
1035
1036     void popScopeInternal(ScopeRef& scope, bool shouldTrackClosedVariables)
1037     {
1038         ASSERT_UNUSED(scope, scope.index() == m_scopeStack.size() - 1);
1039         ASSERT(m_scopeStack.size() > 1);
1040         m_scopeStack[m_scopeStack.size() - 2].collectFreeVariables(&m_scopeStack.last(), shouldTrackClosedVariables);
1041         
1042         if (m_scopeStack.last().isArrowFunction())
1043             m_scopeStack.last().setInnerArrowFunctionUsesEvalAndUseArgumentsIfNeeded();
1044         
1045         if (!(m_scopeStack.last().isFunctionBoundary() && !m_scopeStack.last().isArrowFunctionBoundary()))
1046             m_scopeStack[m_scopeStack.size() - 2].mergeInnerArrowFunctionFeatures(m_scopeStack.last().innerArrowFunctionFeatures());
1047
1048         if (!m_scopeStack.last().isFunctionBoundary() && m_scopeStack.last().needsFullActivation())
1049             m_scopeStack[m_scopeStack.size() - 2].setNeedsFullActivation();
1050         m_scopeStack.removeLast();
1051     }
1052     
1053     ALWAYS_INLINE void popScope(ScopeRef& scope, bool shouldTrackClosedVariables)
1054     {
1055         popScopeInternal(scope, shouldTrackClosedVariables);
1056     }
1057     
1058     ALWAYS_INLINE void popScope(AutoPopScopeRef& scope, bool shouldTrackClosedVariables)
1059     {
1060         scope.setPopped();
1061         popScopeInternal(scope, shouldTrackClosedVariables);
1062     }
1063
1064     ALWAYS_INLINE void popScope(AutoCleanupLexicalScope& cleanupScope, bool shouldTrackClosedVariables)
1065     {
1066         RELEASE_ASSERT(cleanupScope.isValid());
1067         ScopeRef& scope = cleanupScope.scope();
1068         cleanupScope.setPopped();
1069         popScopeInternal(scope, shouldTrackClosedVariables);
1070     }
1071     
1072     DeclarationResultMask declareVariable(const Identifier* ident, DeclarationType type = DeclarationType::VarDeclaration, DeclarationImportType importType = DeclarationImportType::NotImported)
1073     {
1074         if (type == DeclarationType::VarDeclaration)
1075             return currentVariableScope()->declareVariable(ident);
1076
1077         ASSERT(type == DeclarationType::LetDeclaration || type == DeclarationType::ConstDeclaration);
1078         // Lexical variables declared at a top level scope that shadow arguments or vars are not allowed.
1079         if (m_statementDepth == 1 && (hasDeclaredParameter(*ident) || hasDeclaredVariable(*ident)))
1080             return DeclarationResult::InvalidDuplicateDeclaration;
1081
1082         return currentLexicalDeclarationScope()->declareLexicalVariable(ident, type == DeclarationType::ConstDeclaration, importType);
1083     }
1084
1085     std::pair<DeclarationResultMask, ScopeRef> declareFunction(const Identifier* ident)
1086     {
1087         if (m_statementDepth == 1 || (!strictMode() && !currentScope()->isFunction())) {
1088             // Functions declared at the top-most scope (both in sloppy and strict mode) are declared as vars
1089             // for backwards compatibility. This allows us to declare functions with the same name more than once.
1090             // In sloppy mode, we always declare functions as vars.
1091             bool declareAsVar = true;
1092             bool isSloppyModeHoistingCandidate = false;
1093             ScopeRef variableScope = currentVariableScope();
1094             return std::make_pair(variableScope->declareFunction(ident, declareAsVar, isSloppyModeHoistingCandidate), variableScope);
1095         }
1096
1097         if (!strictMode()) {
1098             ASSERT(currentScope()->isFunction());
1099
1100             // Functions declared inside a function inside a nested block scope in sloppy mode are subject to this
1101             // crazy rule defined inside Annex B.3.3 in the ES6 spec. It basically states that we will create
1102             // the function as a local block scoped variable, but when we evaluate the block that the function is
1103             // contained in, we will assign the function to a "var" variable only if declaring such a "var" wouldn't
1104             // be a syntax error and if there isn't a parameter with the same name. (It would only be a syntax error if
1105             // there are is a let/class/const with the same name). Note that this mean we only do the "var" hoisting 
1106             // binding if the block evaluates. For example, this means we wont won't perform the binding if it's inside
1107             // the untaken branch of an if statement.
1108             bool declareAsVar = false;
1109             bool isSloppyModeHoistingCandidate = true;
1110             ScopeRef lexicalVariableScope = currentLexicalDeclarationScope();
1111             ScopeRef varScope = currentVariableScope();
1112             varScope->addSloppyModeHoistableFunctionCandidate(ident);
1113             ASSERT(varScope != lexicalVariableScope);
1114             return std::make_pair(lexicalVariableScope->declareFunction(ident, declareAsVar, isSloppyModeHoistingCandidate), lexicalVariableScope);
1115         }
1116
1117         bool declareAsVar = false;
1118         bool isSloppyModeHoistingCandidate = false;
1119         ScopeRef lexicalVariableScope = currentLexicalDeclarationScope();
1120         return std::make_pair(lexicalVariableScope->declareFunction(ident, declareAsVar, isSloppyModeHoistingCandidate), lexicalVariableScope);
1121     }
1122
1123     NEVER_INLINE bool hasDeclaredVariable(const Identifier& ident)
1124     {
1125         unsigned i = m_scopeStack.size() - 1;
1126         ASSERT(i < m_scopeStack.size());
1127         while (!m_scopeStack[i].allowsVarDeclarations()) {
1128             i--;
1129             ASSERT(i < m_scopeStack.size());
1130         }
1131         return m_scopeStack[i].hasDeclaredVariable(ident);
1132     }
1133
1134     NEVER_INLINE bool hasDeclaredParameter(const Identifier& ident)
1135     {
1136         unsigned i = m_scopeStack.size() - 1;
1137         ASSERT(i < m_scopeStack.size());
1138         while (!m_scopeStack[i].allowsVarDeclarations()) {
1139             i--;
1140             ASSERT(i < m_scopeStack.size());
1141         }
1142         return m_scopeStack[i].hasDeclaredParameter(ident);
1143     }
1144     
1145     bool exportName(const Identifier& ident)
1146     {
1147         ASSERT(currentScope().index() == 0);
1148         return currentScope()->moduleScopeData().exportName(ident);
1149     }
1150
1151     ScopeStack m_scopeStack;
1152     
1153     const SourceProviderCacheItem* findCachedFunctionInfo(int openBracePos) 
1154     {
1155         return m_functionCache ? m_functionCache->get(openBracePos) : 0;
1156     }
1157
1158     Parser();
1159     String parseInner(const Identifier&, SourceParseMode);
1160
1161     void didFinishParsing(SourceElements*, DeclarationStacks::FunctionStack&&, VariableEnvironment&, UniquedStringImplPtrSet&&, CodeFeatures, int);
1162
1163     // Used to determine type of error to report.
1164     bool isFunctionMetadataNode(ScopeNode*) { return false; }
1165     bool isFunctionMetadataNode(FunctionMetadataNode*) { return true; }
1166
1167     ALWAYS_INLINE void next(unsigned lexerFlags = 0)
1168     {
1169         int lastLine = m_token.m_location.line;
1170         int lastTokenEnd = m_token.m_location.endOffset;
1171         int lastTokenLineStart = m_token.m_location.lineStartOffset;
1172         m_lastTokenEndPosition = JSTextPosition(lastLine, lastTokenEnd, lastTokenLineStart);
1173         m_lexer->setLastLineNumber(lastLine);
1174         m_token.m_type = m_lexer->lex(&m_token, lexerFlags, strictMode());
1175     }
1176
1177     ALWAYS_INLINE void nextExpectIdentifier(unsigned lexerFlags = 0)
1178     {
1179         int lastLine = m_token.m_location.line;
1180         int lastTokenEnd = m_token.m_location.endOffset;
1181         int lastTokenLineStart = m_token.m_location.lineStartOffset;
1182         m_lastTokenEndPosition = JSTextPosition(lastLine, lastTokenEnd, lastTokenLineStart);
1183         m_lexer->setLastLineNumber(lastLine);
1184         m_token.m_type = m_lexer->lexExpectIdentifier(&m_token, lexerFlags, strictMode());
1185     }
1186
1187     ALWAYS_INLINE bool nextTokenIsColon()
1188     {
1189         return m_lexer->nextTokenIsColon();
1190     }
1191
1192     ALWAYS_INLINE bool consume(JSTokenType expected, unsigned flags = 0)
1193     {
1194         bool result = m_token.m_type == expected;
1195         if (result)
1196             next(flags);
1197         return result;
1198     }
1199
1200     void printUnexpectedTokenText(WTF::PrintStream&);
1201     ALWAYS_INLINE StringView getToken() {
1202         SourceProvider* sourceProvider = m_source->provider();
1203         return sourceProvider->getRange(tokenStart(), tokenEndPosition().offset);
1204     }
1205     
1206     ALWAYS_INLINE bool match(JSTokenType expected)
1207     {
1208         return m_token.m_type == expected;
1209     }
1210     
1211     ALWAYS_INLINE bool matchContextualKeyword(const Identifier& identifier)
1212     {
1213         return m_token.m_type == IDENT && *m_token.m_data.ident == identifier;
1214     }
1215
1216     ALWAYS_INLINE bool matchIdentifierOrKeyword()
1217     {
1218         return isIdentifierOrKeyword(m_token);
1219     }
1220     
1221     ALWAYS_INLINE unsigned tokenStart()
1222     {
1223         return m_token.m_location.startOffset;
1224     }
1225     
1226     ALWAYS_INLINE const JSTextPosition& tokenStartPosition()
1227     {
1228         return m_token.m_startPosition;
1229     }
1230
1231     ALWAYS_INLINE int tokenLine()
1232     {
1233         return m_token.m_location.line;
1234     }
1235     
1236     ALWAYS_INLINE int tokenColumn()
1237     {
1238         return tokenStart() - tokenLineStart();
1239     }
1240
1241     ALWAYS_INLINE const JSTextPosition& tokenEndPosition()
1242     {
1243         return m_token.m_endPosition;
1244     }
1245     
1246     ALWAYS_INLINE unsigned tokenLineStart()
1247     {
1248         return m_token.m_location.lineStartOffset;
1249     }
1250     
1251     ALWAYS_INLINE const JSTokenLocation& tokenLocation()
1252     {
1253         return m_token.m_location;
1254     }
1255
1256     void setErrorMessage(const String& message)
1257     {
1258         m_errorMessage = message;
1259     }
1260     
1261     NEVER_INLINE void logError(bool);
1262     template <typename A> NEVER_INLINE void logError(bool, const A&);
1263     template <typename A, typename B> NEVER_INLINE void logError(bool, const A&, const B&);
1264     template <typename A, typename B, typename C> NEVER_INLINE void logError(bool, const A&, const B&, const C&);
1265     template <typename A, typename B, typename C, typename D> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&);
1266     template <typename A, typename B, typename C, typename D, typename E> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&);
1267     template <typename A, typename B, typename C, typename D, typename E, typename F> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&, const F&);
1268     template <typename A, typename B, typename C, typename D, typename E, typename F, typename G> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&, const F&, const G&);
1269     
1270     NEVER_INLINE void updateErrorWithNameAndMessage(const char* beforeMessage, const String& name, const char* afterMessage)
1271     {
1272         m_errorMessage = makeString(beforeMessage, " '", name, "' ", afterMessage);
1273     }
1274     
1275     NEVER_INLINE void updateErrorMessage(const char* msg)
1276     {
1277         ASSERT(msg);
1278         m_errorMessage = String(msg);
1279         ASSERT(!m_errorMessage.isNull());
1280     }
1281     
1282     void startLoop() { currentScope()->startLoop(); }
1283     void endLoop() { currentScope()->endLoop(); }
1284     void startSwitch() { currentScope()->startSwitch(); }
1285     void endSwitch() { currentScope()->endSwitch(); }
1286     void setStrictMode() { currentScope()->setStrictMode(); }
1287     bool strictMode() { return currentScope()->strictMode(); }
1288     bool isValidStrictMode() { return currentScope()->isValidStrictMode(); }
1289     DeclarationResultMask declareParameter(const Identifier* ident) { return currentScope()->declareParameter(ident); }
1290     bool declareRestOrNormalParameter(const Identifier&, const Identifier**);
1291
1292     bool breakIsValid()
1293     {
1294         ScopeRef current = currentScope();
1295         while (!current->breakIsValid()) {
1296             if (!current.hasContainingScope())
1297                 return false;
1298             current = current.containingScope();
1299         }
1300         return true;
1301     }
1302     bool continueIsValid()
1303     {
1304         ScopeRef current = currentScope();
1305         while (!current->continueIsValid()) {
1306             if (!current.hasContainingScope())
1307                 return false;
1308             current = current.containingScope();
1309         }
1310         return true;
1311     }
1312     void pushLabel(const Identifier* label, bool isLoop) { currentScope()->pushLabel(label, isLoop); }
1313     void popLabel(ScopeRef scope) { scope->popLabel(); }
1314     ScopeLabelInfo* getLabel(const Identifier* label)
1315     {
1316         ScopeRef current = currentScope();
1317         ScopeLabelInfo* result = 0;
1318         while (!(result = current->getLabel(label))) {
1319             if (!current.hasContainingScope())
1320                 return 0;
1321             current = current.containingScope();
1322         }
1323         return result;
1324     }
1325
1326     // http://ecma-international.org/ecma-262/6.0/#sec-identifiers-static-semantics-early-errors
1327     ALWAYS_INLINE bool isLETMaskedAsIDENT()
1328     {
1329         return match(LET) && !strictMode();
1330     }
1331
1332     // http://ecma-international.org/ecma-262/6.0/#sec-identifiers-static-semantics-early-errors
1333     ALWAYS_INLINE bool isYIELDMaskedAsIDENT(bool inGenerator)
1334     {
1335         return match(YIELD) && !strictMode() && !inGenerator;
1336     }
1337
1338     // http://ecma-international.org/ecma-262/6.0/#sec-generator-function-definitions-static-semantics-early-errors
1339     ALWAYS_INLINE bool matchSpecIdentifier(bool inGenerator)
1340     {
1341         return match(IDENT) || isLETMaskedAsIDENT() || isYIELDMaskedAsIDENT(inGenerator);
1342     }
1343
1344     ALWAYS_INLINE bool matchSpecIdentifier()
1345     {
1346         return matchSpecIdentifier(currentScope()->isGenerator());
1347     }
1348
1349     template <class TreeBuilder> TreeSourceElements parseSourceElements(TreeBuilder&, SourceElementsMode);
1350     template <class TreeBuilder> TreeSourceElements parseGeneratorFunctionSourceElements(TreeBuilder&, SourceElementsMode);
1351     template <class TreeBuilder> TreeStatement parseStatementListItem(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength);
1352     template <class TreeBuilder> TreeStatement parseStatement(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength = 0);
1353     enum class ExportType { Exported, NotExported };
1354     template <class TreeBuilder> TreeStatement parseClassDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
1355     template <class TreeBuilder> TreeStatement parseFunctionDeclaration(TreeBuilder&, ExportType = ExportType::NotExported);
1356     template <class TreeBuilder> TreeStatement parseVariableDeclaration(TreeBuilder&, DeclarationType, ExportType = ExportType::NotExported);
1357     template <class TreeBuilder> TreeStatement parseDoWhileStatement(TreeBuilder&);
1358     template <class TreeBuilder> TreeStatement parseWhileStatement(TreeBuilder&);
1359     template <class TreeBuilder> TreeStatement parseForStatement(TreeBuilder&);
1360     template <class TreeBuilder> TreeStatement parseBreakStatement(TreeBuilder&);
1361     template <class TreeBuilder> TreeStatement parseContinueStatement(TreeBuilder&);
1362     template <class TreeBuilder> TreeStatement parseReturnStatement(TreeBuilder&);
1363     template <class TreeBuilder> TreeStatement parseThrowStatement(TreeBuilder&);
1364     template <class TreeBuilder> TreeStatement parseWithStatement(TreeBuilder&);
1365     template <class TreeBuilder> TreeStatement parseSwitchStatement(TreeBuilder&);
1366     template <class TreeBuilder> TreeClauseList parseSwitchClauses(TreeBuilder&);
1367     template <class TreeBuilder> TreeClause parseSwitchDefaultClause(TreeBuilder&);
1368     template <class TreeBuilder> TreeStatement parseTryStatement(TreeBuilder&);
1369     template <class TreeBuilder> TreeStatement parseDebuggerStatement(TreeBuilder&);
1370     template <class TreeBuilder> TreeStatement parseExpressionStatement(TreeBuilder&);
1371     template <class TreeBuilder> TreeStatement parseExpressionOrLabelStatement(TreeBuilder&, bool allowFunctionDeclarationAsStatement);
1372     template <class TreeBuilder> TreeStatement parseIfStatement(TreeBuilder&);
1373     template <class TreeBuilder> TreeStatement parseBlockStatement(TreeBuilder&);
1374     template <class TreeBuilder> TreeExpression parseExpression(TreeBuilder&);
1375     template <class TreeBuilder> TreeExpression parseAssignmentExpression(TreeBuilder&, ExpressionErrorClassifier&);
1376     template <class TreeBuilder> TreeExpression parseAssignmentExpression(TreeBuilder&);
1377     template <class TreeBuilder> TreeExpression parseAssignmentExpressionOrPropagateErrorClass(TreeBuilder&);
1378     template <class TreeBuilder> TreeExpression parseYieldExpression(TreeBuilder&);
1379     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseConditionalExpression(TreeBuilder&);
1380     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseBinaryExpression(TreeBuilder&);
1381     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseUnaryExpression(TreeBuilder&);
1382     template <class TreeBuilder> TreeExpression parseMemberExpression(TreeBuilder&);
1383     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parsePrimaryExpression(TreeBuilder&);
1384     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArrayLiteral(TreeBuilder&);
1385     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseObjectLiteral(TreeBuilder&);
1386     template <class TreeBuilder> NEVER_INLINE TreeExpression parseStrictObjectLiteral(TreeBuilder&);
1387     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseFunctionExpression(TreeBuilder&);
1388     template <class TreeBuilder> ALWAYS_INLINE TreeArguments parseArguments(TreeBuilder&);
1389     template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArgument(TreeBuilder&, ArgumentType&);
1390     template <class TreeBuilder> TreeProperty parseProperty(TreeBuilder&, bool strict);
1391     template <class TreeBuilder> TreeExpression parsePropertyMethod(TreeBuilder& context, const Identifier* methodName, bool isGenerator);
1392     template <class TreeBuilder> TreeProperty parseGetterSetter(TreeBuilder&, bool strict, PropertyNode::Type, unsigned getterOrSetterStartOffset, ConstructorKind = ConstructorKind::None, SuperBinding = SuperBinding::NotNeeded);
1393     template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&, const JSTokenLocation&, int, int functionKeywordStart, int functionNameStart, int parametersStart, ConstructorKind, SuperBinding, FunctionBodyType, unsigned, SourceParseMode);
1394     template <class TreeBuilder> ALWAYS_INLINE bool parseFormalParameters(TreeBuilder&, TreeFormalParameterList, unsigned&);
1395     enum VarDeclarationListContext { ForLoopContext, VarDeclarationContext };
1396     template <class TreeBuilder> TreeExpression parseVariableDeclarationList(TreeBuilder&, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext, DeclarationType, ExportType, bool& forLoopConstDoesNotHaveInitializer);
1397     template <class TreeBuilder> TreeSourceElements parseArrowFunctionSingleExpressionBodySourceElements(TreeBuilder&);
1398     template <class TreeBuilder> TreeExpression parseArrowFunctionExpression(TreeBuilder&);
1399     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createBindingPattern(TreeBuilder&, DestructuringKind, ExportType, const Identifier&, JSToken, AssignmentContext, const Identifier** duplicateIdentifier);
1400     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createAssignmentElement(TreeBuilder&, TreeExpression&, const JSTextPosition&, const JSTextPosition&);
1401     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseBindingOrAssignmentElement(TreeBuilder& context, DestructuringKind, ExportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth);
1402     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseAssignmentElement(TreeBuilder& context, DestructuringKind, ExportType, const Identifier** duplicateIdentifier, bool* hasDestructuringPattern, AssignmentContext bindingContext, int depth);
1403     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseDestructuringPattern(TreeBuilder&, DestructuringKind, ExportType, const Identifier** duplicateIdentifier = nullptr, bool* hasDestructuringPattern = nullptr, AssignmentContext = AssignmentContext::DeclarationStatement, int depth = 0);
1404     template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern tryParseDestructuringPatternExpression(TreeBuilder&, AssignmentContext);
1405     template <class TreeBuilder> NEVER_INLINE TreeExpression parseDefaultValueForDestructuringPattern(TreeBuilder&);
1406     template <class TreeBuilder> TreeSourceElements parseModuleSourceElements(TreeBuilder&, SourceParseMode);
1407     enum class ImportSpecifierType { NamespaceImport, NamedImport, DefaultImport };
1408     template <class TreeBuilder> typename TreeBuilder::ImportSpecifier parseImportClauseItem(TreeBuilder&, ImportSpecifierType);
1409     template <class TreeBuilder> typename TreeBuilder::ModuleName parseModuleName(TreeBuilder&);
1410     template <class TreeBuilder> TreeStatement parseImportDeclaration(TreeBuilder&);
1411     template <class TreeBuilder> typename TreeBuilder::ExportSpecifier parseExportSpecifier(TreeBuilder& context, Vector<const Identifier*>& maybeLocalNames, bool& hasKeywordForLocalBindings);
1412     template <class TreeBuilder> TreeStatement parseExportDeclaration(TreeBuilder&);
1413
1414     enum class FunctionDefinitionType { Expression, Declaration, Method };
1415     template <class TreeBuilder> NEVER_INLINE bool parseFunctionInfo(TreeBuilder&, FunctionRequirements, SourceParseMode, bool nameIsInContainingScope, ConstructorKind, SuperBinding, int functionKeywordStart, ParserFunctionInfo<TreeBuilder>&, FunctionDefinitionType);
1416     
1417     ALWAYS_INLINE bool isArrowFunctionParameters();
1418     
1419     template <class TreeBuilder> NEVER_INLINE int parseFunctionParameters(TreeBuilder&, SourceParseMode, ParserFunctionInfo<TreeBuilder>&);
1420     template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::FormalParameterList createGeneratorParameters(TreeBuilder&);
1421
1422     template <class TreeBuilder> NEVER_INLINE TreeClassExpression parseClass(TreeBuilder&, FunctionRequirements, ParserClassInfo<TreeBuilder>&);
1423
1424     template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::TemplateString parseTemplateString(TreeBuilder& context, bool isTemplateHead, typename LexerType::RawStringsBuildMode, bool& elementIsTail);
1425     template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::TemplateLiteral parseTemplateLiteral(TreeBuilder&, typename LexerType::RawStringsBuildMode);
1426
1427     template <class TreeBuilder> ALWAYS_INLINE bool shouldCheckPropertyForUnderscoreProtoDuplicate(TreeBuilder&, const TreeProperty&);
1428
1429     ALWAYS_INLINE int isBinaryOperator(JSTokenType);
1430     bool allowAutomaticSemicolon();
1431     
1432     bool autoSemiColon()
1433     {
1434         if (m_token.m_type == SEMICOLON) {
1435             next();
1436             return true;
1437         }
1438         return allowAutomaticSemicolon();
1439     }
1440     
1441     bool canRecurse()
1442     {
1443         return m_vm->isSafeToRecurse();
1444     }
1445     
1446     const JSTextPosition& lastTokenEndPosition() const
1447     {
1448         return m_lastTokenEndPosition;
1449     }
1450
1451     bool hasError() const
1452     {
1453         return !m_errorMessage.isNull();
1454     }
1455
1456     enum class FunctionParsePhase { Parameters, Body };
1457     struct ParserState {
1458         int assignmentCount { 0 };
1459         int nonLHSCount { 0 };
1460         int nonTrivialExpressionCount { 0 };
1461         FunctionParsePhase functionParsePhase { FunctionParsePhase::Body };
1462         const Identifier* lastIdentifier { nullptr };
1463         const Identifier* lastFunctionName { nullptr };
1464     };
1465
1466     // If you're using this directly, you probably should be using
1467     // createSavePoint() instead.
1468     ALWAYS_INLINE ParserState internalSaveParserState()
1469     {
1470         return m_parserState;
1471     }
1472
1473     ALWAYS_INLINE void restoreParserState(const ParserState& state)
1474     {
1475         m_parserState = state;
1476     }
1477
1478     struct LexerState {
1479         int startOffset;
1480         unsigned oldLineStartOffset;
1481         unsigned oldLastLineNumber;
1482         unsigned oldLineNumber;
1483     };
1484
1485     // If you're using this directly, you probably should be using
1486     // createSavePoint() instead.
1487     // i.e, if you parse any kind of AssignmentExpression between
1488     // saving/restoring, you should definitely not be using this directly.
1489     ALWAYS_INLINE LexerState internalSaveLexerState()
1490     {
1491         LexerState result;
1492         result.startOffset = m_token.m_location.startOffset;
1493         result.oldLineStartOffset = m_token.m_location.lineStartOffset;
1494         result.oldLastLineNumber = m_lexer->lastLineNumber();
1495         result.oldLineNumber = m_lexer->lineNumber();
1496         return result;
1497     }
1498
1499     ALWAYS_INLINE void restoreLexerState(const LexerState& lexerState)
1500     {
1501         m_lexer->setOffset(lexerState.startOffset, lexerState.oldLineStartOffset);
1502         next();
1503         m_lexer->setLastLineNumber(lexerState.oldLastLineNumber);
1504         m_lexer->setLineNumber(lexerState.oldLineNumber);
1505     }
1506
1507     struct SavePoint {
1508         ParserState parserState;
1509         LexerState lexerState;
1510     };
1511     
1512     ALWAYS_INLINE SavePoint createSavePointForError()
1513     {
1514         SavePoint result;
1515         result.parserState = internalSaveParserState();
1516         result.lexerState = internalSaveLexerState();
1517         return result;
1518     }
1519     
1520     ALWAYS_INLINE SavePoint createSavePoint()
1521     {
1522         ASSERT(!hasError());
1523         return createSavePointForError();
1524     }
1525
1526     ALWAYS_INLINE void restoreSavePointWithError(const SavePoint& savePoint, const String& message)
1527     {
1528         m_errorMessage = message;
1529         restoreLexerState(savePoint.lexerState);
1530         restoreParserState(savePoint.parserState);
1531     }
1532
1533     ALWAYS_INLINE void restoreSavePoint(const SavePoint& savePoint)
1534     {
1535         restoreSavePointWithError(savePoint, String());
1536     }
1537
1538     VM* m_vm;
1539     const SourceCode* m_source;
1540     ParserArena m_parserArena;
1541     std::unique_ptr<LexerType> m_lexer;
1542     FunctionParameters* m_parameters { nullptr };
1543
1544     ParserState m_parserState;
1545     
1546     bool m_hasStackOverflow;
1547     String m_errorMessage;
1548     JSToken m_token;
1549     bool m_allowsIn;
1550     JSTextPosition m_lastTokenEndPosition;
1551     bool m_syntaxAlreadyValidated;
1552     int m_statementDepth;
1553     RefPtr<SourceProviderCache> m_functionCache;
1554     SourceElements* m_sourceElements;
1555     bool m_parsingBuiltin;
1556     SuperBinding m_superBinding;
1557     ConstructorKind m_defaultConstructorKind;
1558     ThisTDZMode m_thisTDZMode;
1559     VariableEnvironment m_varDeclarations;
1560     DeclarationStacks::FunctionStack m_funcDeclarations;
1561     UniquedStringImplPtrSet m_sloppyModeHoistedFunctions;
1562     CodeFeatures m_features;
1563     int m_numConstants;
1564     ExpressionErrorClassifier* m_expressionErrorClassifier;
1565     bool m_isEvalContext;
1566     bool m_immediateParentAllowsFunctionDeclarationInStatement;
1567     
1568     struct DepthManager {
1569         DepthManager(int* depth)
1570         : m_originalDepth(*depth)
1571         , m_depth(depth)
1572         {
1573         }
1574         
1575         ~DepthManager()
1576         {
1577             *m_depth = m_originalDepth;
1578         }
1579         
1580     private:
1581         int m_originalDepth;
1582         int* m_depth;
1583     };
1584 };
1585
1586
1587 template <typename LexerType>
1588 template <class ParsedNode>
1589 std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error, const Identifier& calleeName, SourceParseMode parseMode)
1590 {
1591     int errLine;
1592     String errMsg;
1593
1594     if (ParsedNode::scopeIsFunction)
1595         m_lexer->setIsReparsingFunction();
1596
1597     m_sourceElements = 0;
1598
1599     errLine = -1;
1600     errMsg = String();
1601
1602     JSTokenLocation startLocation(tokenLocation());
1603     ASSERT(m_source->startColumn() > 0);
1604     unsigned startColumn = m_source->startColumn() - 1;
1605
1606     String parseError = parseInner(calleeName, parseMode);
1607
1608     int lineNumber = m_lexer->lineNumber();
1609     bool lexError = m_lexer->sawError();
1610     String lexErrorMessage = lexError ? m_lexer->getErrorMessage() : String();
1611     ASSERT(lexErrorMessage.isNull() != lexError);
1612     m_lexer->clear();
1613
1614     if (!parseError.isNull() || lexError) {
1615         errLine = lineNumber;
1616         errMsg = !lexErrorMessage.isNull() ? lexErrorMessage : parseError;
1617         m_sourceElements = 0;
1618     }
1619
1620     std::unique_ptr<ParsedNode> result;
1621     if (m_sourceElements) {
1622         JSTokenLocation endLocation;
1623         endLocation.line = m_lexer->lineNumber();
1624         endLocation.lineStartOffset = m_lexer->currentLineStartOffset();
1625         endLocation.startOffset = m_lexer->currentOffset();
1626         unsigned endColumn = endLocation.startOffset - endLocation.lineStartOffset;
1627         result = std::make_unique<ParsedNode>(m_parserArena,
1628                                     startLocation,
1629                                     endLocation,
1630                                     startColumn,
1631                                     endColumn,
1632                                     m_sourceElements,
1633                                     m_varDeclarations,
1634                                     WTFMove(m_funcDeclarations),
1635                                     currentScope()->finalizeLexicalEnvironment(),
1636                                     WTFMove(m_sloppyModeHoistedFunctions),
1637                                     m_parameters,
1638                                     *m_source,
1639                                     m_features,
1640                                     currentScope()->innerArrowFunctionFeatures(),
1641                                     m_numConstants);
1642         result->setLoc(m_source->firstLine(), m_lexer->lineNumber(), m_lexer->currentOffset(), m_lexer->currentLineStartOffset());
1643         result->setEndOffset(m_lexer->currentOffset());
1644
1645         if (!isFunctionParseMode(parseMode)) {
1646             m_source->provider()->setSourceURLDirective(m_lexer->sourceURL());
1647             m_source->provider()->setSourceMappingURLDirective(m_lexer->sourceMappingURL());
1648         }
1649     } else {
1650         // We can never see a syntax error when reparsing a function, since we should have
1651         // reported the error when parsing the containing program or eval code. So if we're
1652         // parsing a function body node, we assume that what actually happened here is that
1653         // we ran out of stack while parsing. If we see an error while parsing eval or program
1654         // code we assume that it was a syntax error since running out of stack is much less
1655         // likely, and we are currently unable to distinguish between the two cases.
1656         if (isFunctionMetadataNode(static_cast<ParsedNode*>(0)) || m_hasStackOverflow)
1657             error = ParserError(ParserError::StackOverflow, ParserError::SyntaxErrorNone, m_token);
1658         else {
1659             ParserError::SyntaxErrorType errorType = ParserError::SyntaxErrorIrrecoverable;
1660             if (m_token.m_type == EOFTOK)
1661                 errorType = ParserError::SyntaxErrorRecoverable;
1662             else if (m_token.m_type & UnterminatedErrorTokenFlag) {
1663                 // Treat multiline capable unterminated literals as recoverable.
1664                 if (m_token.m_type == UNTERMINATED_MULTILINE_COMMENT_ERRORTOK || m_token.m_type == UNTERMINATED_TEMPLATE_LITERAL_ERRORTOK)
1665                     errorType = ParserError::SyntaxErrorRecoverable;
1666                 else
1667                     errorType = ParserError::SyntaxErrorUnterminatedLiteral;
1668             }
1669             
1670             if (isEvalNode<ParsedNode>())
1671                 error = ParserError(ParserError::EvalError, errorType, m_token, errMsg, errLine);
1672             else
1673                 error = ParserError(ParserError::SyntaxError, errorType, m_token, errMsg, errLine);
1674         }
1675     }
1676
1677     return result;
1678 }
1679
1680 template <class ParsedNode>
1681 std::unique_ptr<ParsedNode> parse(
1682     VM* vm, const SourceCode& source,
1683     const Identifier& name, JSParserBuiltinMode builtinMode,
1684     JSParserStrictMode strictMode, SourceParseMode parseMode, SuperBinding superBinding,
1685     ParserError& error, JSTextPosition* positionBeforeLastNewline = nullptr,
1686     ConstructorKind defaultConstructorKind = ConstructorKind::None, ThisTDZMode thisTDZMode = ThisTDZMode::CheckIfNeeded, 
1687     DerivedContextType derivedContextType = DerivedContextType::None, EvalContextType evalContextType = EvalContextType::None)
1688 {
1689     ASSERT(!source.provider()->source().isNull());
1690     if (source.provider()->source().is8Bit()) {
1691         Parser<Lexer<LChar>> parser(vm, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, thisTDZMode, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
1692         std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
1693         if (positionBeforeLastNewline)
1694             *positionBeforeLastNewline = parser.positionBeforeLastNewline();
1695         if (builtinMode == JSParserBuiltinMode::Builtin) {
1696             if (!result)
1697                 WTF::dataLog("Error compiling builtin: ", error.message(), "\n");
1698         }
1699         return result;
1700     }
1701     ASSERT_WITH_MESSAGE(defaultConstructorKind == ConstructorKind::None, "BuiltinExecutables::createDefaultConstructor should always use a 8-bit string");
1702     Parser<Lexer<UChar>> parser(vm, source, builtinMode, strictMode, parseMode, superBinding, defaultConstructorKind, thisTDZMode, derivedContextType, isEvalNode<ParsedNode>(), evalContextType);
1703     std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error, name, parseMode);
1704     if (positionBeforeLastNewline)
1705         *positionBeforeLastNewline = parser.positionBeforeLastNewline();
1706     return result;
1707 }
1708
1709 } // namespace
1710 #endif