src/ast/ast-expression-visitor.cc - Issue 2169833002: [parser] Refactor AstTraversalVisitor

Side by Side Diff: src/ast/ast-expression-visitor.cc

Issue 2169833002: [parser] Refactor AstTraversalVisitor (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master

Patch Set: Rebase Created 4 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
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

13 namespace v8 {

14 namespace internal {

15

16 AstExpressionVisitor::AstExpressionVisitor(Isolate* isolate, Expression* root)

17 : AstTraversalVisitor(isolate), root_(root) {}

18

19 AstExpressionVisitor::AstExpressionVisitor(uintptr_t stack_limit,

20 Expression* root)

21 : AstTraversalVisitor(stack_limit), root_(root) {}

22

23 void AstExpressionVisitor::Run() { Visit(root_); }

24

25 void AstExpressionVisitor::VisitFunctionLiteral(FunctionLiteral* expr) {

26 VisitExpression(expr);

27 AstTraversalVisitor::VisitFunctionLiteral(expr);

28 }

29

30 void AstExpressionVisitor::VisitNativeFunctionLiteral(

31 NativeFunctionLiteral* expr) {

32 AstTraversalVisitor::VisitNativeFunctionLiteral(expr);

33 }

34

35 void AstExpressionVisitor::VisitDoExpression(DoExpression* expr) {

36 VisitExpression(expr);

37 AstTraversalVisitor::VisitDoExpression(expr);

38 }

39

40 void AstExpressionVisitor::VisitConditional(Conditional* expr) {

41 VisitExpression(expr);

42 AstTraversalVisitor::VisitConditional(expr);

43 }

44

45 void AstExpressionVisitor::VisitVariableProxy(VariableProxy* expr) {

46 VisitExpression(expr);

47 AstTraversalVisitor::VisitVariableProxy(expr);

48 }

49

50 void AstExpressionVisitor::VisitLiteral(Literal* expr) {

51 VisitExpression(expr);

52 AstTraversalVisitor::VisitLiteral(expr);

53 }

54

55 void AstExpressionVisitor::VisitRegExpLiteral(RegExpLiteral* expr) {

56 VisitExpression(expr);

57 AstTraversalVisitor::VisitRegExpLiteral(expr);

58 }

59

60 void AstExpressionVisitor::VisitObjectLiteral(ObjectLiteral* expr) {

61 VisitExpression(expr);

62 AstTraversalVisitor::VisitObjectLiteral(expr);

63 }

64

65 void AstExpressionVisitor::VisitArrayLiteral(ArrayLiteral* expr) {

66 VisitExpression(expr);

67 AstTraversalVisitor::VisitArrayLiteral(expr);

68 }

69

70 void AstExpressionVisitor::VisitAssignment(Assignment* expr) {

71 VisitExpression(expr);

72 AstTraversalVisitor::VisitAssignment(expr);

73 }

74

75 void AstExpressionVisitor::VisitYield(Yield* expr) {

76 VisitExpression(expr);

77 AstTraversalVisitor::VisitYield(expr);

78 }

79

80 void AstExpressionVisitor::VisitThrow(Throw* expr) {

81 VisitExpression(expr);

82 AstTraversalVisitor::VisitThrow(expr);

83 }

84

85 void AstExpressionVisitor::VisitProperty(Property* expr) {

86 VisitExpression(expr);

87 AstTraversalVisitor::VisitProperty(expr);

88 }

89

90 void AstExpressionVisitor::VisitCall(Call* expr) {

91 VisitExpression(expr);

92 AstTraversalVisitor::VisitCall(expr);

93 }

94

95 void AstExpressionVisitor::VisitCallNew(CallNew* expr) {

96 VisitExpression(expr);

97 AstTraversalVisitor::VisitCallNew(expr);

98 }

99

100 void AstExpressionVisitor::VisitCallRuntime(CallRuntime* expr) {

101 VisitExpression(expr);

102 AstTraversalVisitor::VisitCallRuntime(expr);

103 }

104

105 void AstExpressionVisitor::VisitUnaryOperation(UnaryOperation* expr) {

106 VisitExpression(expr);

107 AstTraversalVisitor::VisitUnaryOperation(expr);

108 }

109

110 void AstExpressionVisitor::VisitCountOperation(CountOperation* expr) {

111 VisitExpression(expr);

112 AstTraversalVisitor::VisitCountOperation(expr);

113 }

114

115 void AstExpressionVisitor::VisitBinaryOperation(BinaryOperation* expr) {

116 VisitExpression(expr);

117 AstTraversalVisitor::VisitBinaryOperation(expr);

118 }

119

120 void AstExpressionVisitor::VisitCompareOperation(CompareOperation* expr) {

121 VisitExpression(expr);

122 AstTraversalVisitor::VisitCompareOperation(expr);

123 }

124

125 void AstExpressionVisitor::VisitThisFunction(ThisFunction* expr) {

126 VisitExpression(expr);

127 AstTraversalVisitor::VisitThisFunction(expr);

128 }

129

130 void AstExpressionVisitor::VisitClassLiteral(ClassLiteral* expr) {

131 VisitExpression(expr);

132 AstTraversalVisitor::VisitClassLiteral(expr);

133 }

134

135 void AstExpressionVisitor::VisitSpread(Spread* expr) {

136 VisitExpression(expr);

137 AstTraversalVisitor::VisitSpread(expr);

138 }

139

140 void AstExpressionVisitor::VisitSuperPropertyReference(

141 SuperPropertyReference* expr) {

142 VisitExpression(expr);

143 AstTraversalVisitor::VisitSuperPropertyReference(expr);

144 }

145

146 void AstExpressionVisitor::VisitSuperCallReference(SuperCallReference* expr) {

147 VisitExpression(expr);

148 AstTraversalVisitor::VisitSuperCallReference(expr);

149 }

150

151 void AstExpressionVisitor::VisitCaseClause(CaseClause* expr) {

152 AstTraversalVisitor::VisitCaseClause(expr);

153 }

154

155 void AstExpressionVisitor::VisitEmptyParentheses(EmptyParentheses* expr) {

156 AstTraversalVisitor::VisitEmptyParentheses(expr);

157 }

158

159 void AstExpressionVisitor::VisitRewritableExpression(

160 RewritableExpression* expr) {

161 VisitExpression(expr);

162 AstTraversalVisitor::VisitRewritableExpression(expr);

163 }

164

165

166 } // namespace internal

167 } // namespace v8

OLD	NEW

« no previous file with comments | « src/ast/ast-expression-visitor.h ('k') | src/ast/ast-traversal-visitor.h » ('j') | no next file with comments »