1// Copyright 2015 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "src/v8.h"
6
7#include "src/ast/ast-expression-visitor.h"
8
9#include "src/ast/ast.h"
10#include "src/ast/scopes.h"
11#include "src/codegen.h"
12
13namespace v8 {
14namespace internal {
15
16AstExpressionVisitor::AstExpressionVisitor(Isolate* isolate, Expression* root)
17    : AstTraversalVisitor(isolate), root_(root) {}
18
19AstExpressionVisitor::AstExpressionVisitor(uintptr_t stack_limit,
20                                           Expression* root)
21    : AstTraversalVisitor(stack_limit), root_(root) {}
22
23void AstExpressionVisitor::Run() { Visit(root_); }
24
25void AstExpressionVisitor::VisitFunctionLiteral(FunctionLiteral* expr) {
26  VisitExpression(expr);
27  AstTraversalVisitor::VisitFunctionLiteral(expr);
28}
29
30void AstExpressionVisitor::VisitNativeFunctionLiteral(
31    NativeFunctionLiteral* expr) {
32  AstTraversalVisitor::VisitNativeFunctionLiteral(expr);
33}
34
35void AstExpressionVisitor::VisitDoExpression(DoExpression* expr) {
36  VisitExpression(expr);
37  AstTraversalVisitor::VisitDoExpression(expr);
38}
39
40void AstExpressionVisitor::VisitConditional(Conditional* expr) {
41  VisitExpression(expr);
42  AstTraversalVisitor::VisitConditional(expr);
43}
44
45void AstExpressionVisitor::VisitVariableProxy(VariableProxy* expr) {
46  VisitExpression(expr);
47  AstTraversalVisitor::VisitVariableProxy(expr);
48}
49
50void AstExpressionVisitor::VisitLiteral(Literal* expr) {
51  VisitExpression(expr);
52  AstTraversalVisitor::VisitLiteral(expr);
53}
54
55void AstExpressionVisitor::VisitRegExpLiteral(RegExpLiteral* expr) {
56  VisitExpression(expr);
57  AstTraversalVisitor::VisitRegExpLiteral(expr);
58}
59
60void AstExpressionVisitor::VisitObjectLiteral(ObjectLiteral* expr) {
61  VisitExpression(expr);
62  AstTraversalVisitor::VisitObjectLiteral(expr);
63}
64
65void AstExpressionVisitor::VisitArrayLiteral(ArrayLiteral* expr) {
66  VisitExpression(expr);
67  AstTraversalVisitor::VisitArrayLiteral(expr);
68}
69
70void AstExpressionVisitor::VisitAssignment(Assignment* expr) {
71  VisitExpression(expr);
72  AstTraversalVisitor::VisitAssignment(expr);
73}
74
75void AstExpressionVisitor::VisitYield(Yield* expr) {
76  VisitExpression(expr);
77  AstTraversalVisitor::VisitYield(expr);
78}
79
80void AstExpressionVisitor::VisitThrow(Throw* expr) {
81  VisitExpression(expr);
82  AstTraversalVisitor::VisitThrow(expr);
83}
84
85void AstExpressionVisitor::VisitProperty(Property* expr) {
86  VisitExpression(expr);
87  AstTraversalVisitor::VisitProperty(expr);
88}
89
90void AstExpressionVisitor::VisitCall(Call* expr) {
91  VisitExpression(expr);
92  AstTraversalVisitor::VisitCall(expr);
93}
94
95void AstExpressionVisitor::VisitCallNew(CallNew* expr) {
96  VisitExpression(expr);
97  AstTraversalVisitor::VisitCallNew(expr);
98}
99
100void AstExpressionVisitor::VisitCallRuntime(CallRuntime* expr) {
101  VisitExpression(expr);
102  AstTraversalVisitor::VisitCallRuntime(expr);
103}
104
105void AstExpressionVisitor::VisitUnaryOperation(UnaryOperation* expr) {
106  VisitExpression(expr);
107  AstTraversalVisitor::VisitUnaryOperation(expr);
108}
109
110void AstExpressionVisitor::VisitCountOperation(CountOperation* expr) {
111  VisitExpression(expr);
112  AstTraversalVisitor::VisitCountOperation(expr);
113}
114
115void AstExpressionVisitor::VisitBinaryOperation(BinaryOperation* expr) {
116  VisitExpression(expr);
117  AstTraversalVisitor::VisitBinaryOperation(expr);
118}
119
120void AstExpressionVisitor::VisitCompareOperation(CompareOperation* expr) {
121  VisitExpression(expr);
122  AstTraversalVisitor::VisitCompareOperation(expr);
123}
124
125void AstExpressionVisitor::VisitThisFunction(ThisFunction* expr) {
126  VisitExpression(expr);
127  AstTraversalVisitor::VisitThisFunction(expr);
128}
129
130void AstExpressionVisitor::VisitClassLiteral(ClassLiteral* expr) {
131  VisitExpression(expr);
132  AstTraversalVisitor::VisitClassLiteral(expr);
133}
134
135void AstExpressionVisitor::VisitSpread(Spread* expr) {
136  VisitExpression(expr);
137  AstTraversalVisitor::VisitSpread(expr);
138}
139
140void AstExpressionVisitor::VisitSuperPropertyReference(
141    SuperPropertyReference* expr) {
142  VisitExpression(expr);
143  AstTraversalVisitor::VisitSuperPropertyReference(expr);
144}
145
146void AstExpressionVisitor::VisitSuperCallReference(SuperCallReference* expr) {
147  VisitExpression(expr);
148  AstTraversalVisitor::VisitSuperCallReference(expr);
149}
150
151void AstExpressionVisitor::VisitCaseClause(CaseClause* expr) {
152  AstTraversalVisitor::VisitCaseClause(expr);
153}
154
155void AstExpressionVisitor::VisitEmptyParentheses(EmptyParentheses* expr) {
156  AstTraversalVisitor::VisitEmptyParentheses(expr);
157}
158
159void AstExpressionVisitor::VisitRewritableExpression(
160    RewritableExpression* expr) {
161  VisitExpression(expr);
162  AstTraversalVisitor::VisitRewritableExpression(expr);
163}
164
165
166}  // namespace internal
167}  // namespace v8
168