Skip to content
This repository was archived by the owner on Jan 8, 2023. It is now read-only.

Commit 7614624

Browse files
author
ApsarasX
committed
optimize: optimize the structure of ASTVisitor and its base class
1 parent 00cad04 commit 7614624

6 files changed

Lines changed: 60 additions & 156 deletions

File tree

‎include/Sema/ASTVisitor.h‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,10 @@
66
/// AST遍历器
77
class ASTVisitor : public std::enable_shared_from_this<ASTVisitor> {
88
public:
9+
inline void resolve(const SharedPtr<ModuleNode> &module) {
10+
module->accept(shared_from_this());
11+
}
12+
913
virtual void visit(const SharedPtr<ModuleNode> &module);
1014

1115
virtual void visit(const SharedPtr<BuiltinTypeNode> &builtinType);
@@ -49,4 +53,32 @@ class ASTVisitor : public std::enable_shared_from_this<ASTVisitor> {
4953
virtual void visit(const SharedPtr<BreakStmtNode> &breakStmt);
5054

5155
virtual void visit(const SharedPtr<ReturnStmtNode> &returnStmt);
56+
57+
protected:
58+
/**
59+
* @brief 将作用域压栈
60+
*
61+
* @param scope 作用域
62+
*/
63+
inline void pushScope(const SharedPtr<Scope> &scope) {
64+
scopeStack.push(scope);
65+
}
66+
67+
/**
68+
* @brief 作用域出栈
69+
*/
70+
inline void popScope() {
71+
scopeStack.pop();
72+
}
73+
74+
/**
75+
* @brief 获取当前作用域
76+
* @return 当前作用域
77+
*/
78+
inline const SharedPtr<Scope> &getCurrentScope() {
79+
return scopeStack.top();
80+
}
81+
82+
/// 作用域栈
83+
std::stack<SharedPtr<Scope>> scopeStack;
5284
};

‎include/Sema/ReferenceResolver.h‎

Lines changed: 0 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -7,11 +7,6 @@
77

88
/// 引用消解器
99
class ReferenceResolver final : public ASTVisitor {
10-
public:
11-
inline void resolve(const SharedPtr<ModuleNode> &module) {
12-
module->accept(getThisSharedPtr());
13-
}
14-
1510
private:
1611
void visit(const SharedPtr<ModuleNode> &module) override;
1712

@@ -45,22 +40,6 @@ class ReferenceResolver final : public ASTVisitor {
4540

4641
void visit(const SharedPtr<ReturnStmtNode> &returnStmt) override;
4742

48-
inline SharedPtr<ReferenceResolver> getThisSharedPtr() {
49-
return staticPtrCast<ReferenceResolver>(shared_from_this());
50-
}
51-
52-
inline void pushScope(const SharedPtr<Scope> &scope) {
53-
scopeStack.push(scope);
54-
}
55-
56-
inline void popScope() {
57-
scopeStack.pop();
58-
}
59-
60-
inline const SharedPtr<Scope> &getCurrentScope() {
61-
return scopeStack.top();
62-
}
63-
6443
/**
6544
* @brief 查找变量
6645
* @details 沿着当前作用域递归向上查找变量
@@ -82,7 +61,4 @@ class ReferenceResolver final : public ASTVisitor {
8261
inline SharedPtr<FunctionDeclNode> resolveFunction(const String &name) {
8362
return getCurrentScope()->getTopLevel()->resolveFunction(name);
8463
}
85-
86-
/// 作用域栈
87-
std::stack<SharedPtr<Scope>> scopeStack;
8864
};

‎include/Sema/ScopeScanner.h‎

Lines changed: 0 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -6,11 +6,6 @@
66

77
/// 作用域扫描器
88
class ScopeScanner final : public ASTVisitor {
9-
public:
10-
inline void resolve(const SharedPtr<ModuleNode> &module) {
11-
module->accept(getThisSharedPtr());
12-
}
13-
149
private:
1510
void visit(const SharedPtr<ModuleNode> &module) override;
1611

@@ -53,39 +48,4 @@ class ScopeScanner final : public ASTVisitor {
5348
void visit(const SharedPtr<BreakStmtNode> &breakStmt) override;
5449

5550
void visit(const SharedPtr<ReturnStmtNode> &returnStmt) override;
56-
57-
/**
58-
* @brief 获取当前扫描器实例的智能指针
59-
* @return 当前扫描器实例的智能指针
60-
*/
61-
inline SharedPtr<ScopeScanner> getThisSharedPtr() {
62-
return staticPtrCast<ScopeScanner>(shared_from_this());
63-
}
64-
65-
/**
66-
* @brief 将作用域压栈
67-
*
68-
* @param scope 作用域
69-
*/
70-
inline void pushScope(const SharedPtr<Scope> &scope) {
71-
scopeStack.push(scope);
72-
}
73-
74-
/**
75-
* @brief 作用域出栈
76-
*/
77-
inline void popScope() {
78-
scopeStack.pop();
79-
}
80-
81-
/**
82-
* @brief 获取当前作用域
83-
* @return 当前作用域
84-
*/
85-
inline const SharedPtr<Scope> &getCurrentScope() {
86-
return scopeStack.top();
87-
}
88-
89-
/// 作用域栈
90-
std::stack<SharedPtr<Scope>> scopeStack;
9151
};

‎lib/Driver/Driver.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -23,8 +23,8 @@ int main(int argc, char *argv[]) {
2323
antlr4::tree::ParseTree *tree = parser.module();
2424
ASTBuilder builder(codeFilename);
2525
SharedPtr<ModuleNode> module = builder.visit(tree);
26-
// SharedPtr<ScopeScanner> scanner = makeShared<ScopeScanner>();
27-
// scanner->resolve(module);
26+
SharedPtr<ScopeScanner> scanner = makeShared<ScopeScanner>();
27+
scanner->resolve(module);
2828
SharedPtr<ReferenceResolver> resolver = makeShared<ReferenceResolver>();
2929
resolver->resolve(module);
3030
} else {

‎lib/Sema/ReferenceResolver.cpp‎

Lines changed: 13 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -2,9 +2,7 @@
22

33
void ReferenceResolver::visit(const SharedPtr<ModuleNode> &module) {
44
pushScope(module->internalScope);
5-
for (const SharedPtr<StmtNode> &stmt: module->childStmts) {
6-
stmt->accept(getThisSharedPtr());
7-
}
5+
ASTVisitor::visit(module);
86
popScope();
97
}
108

@@ -20,10 +18,7 @@ void ReferenceResolver::visit(const SharedPtr<FunctionDeclNode> &funcDecl) {
2018
const SharedPtr<TopLevelScope> &topLevelScope = dynPtrCast<TopLevelScope>(getCurrentScope());
2119
topLevelScope->addFunction(funcDecl->name, funcDecl);
2220
pushScope(funcDecl->internalScope);
23-
for (const SharedPtr<ParmVarDeclNode> &paramVarDecl : funcDecl->params) {
24-
paramVarDecl->accept(getThisSharedPtr());
25-
}
26-
funcDecl->body->accept(getThisSharedPtr());
21+
ASTVisitor::visit(funcDecl);
2722
popScope();
2823
}
2924

@@ -43,76 +38,49 @@ void ReferenceResolver::visit(const SharedPtr<CallExprNode> &callExpr) {
4338
} else {
4439
throw SemanticException("函数未定义: " + callExpr->calleeName);
4540
}
46-
for (const SharedPtr<ExprNode> &argExpr: callExpr->args) {
47-
argExpr->accept(getThisSharedPtr());
48-
}
41+
ASTVisitor::visit(callExpr);
4942
}
5043

5144
void ReferenceResolver::visit(const SharedPtr<UnaryOperatorExprNode> &uopExpr) {
52-
uopExpr->subExpr->accept(getThisSharedPtr());
45+
ASTVisitor::visit(uopExpr);
5346
}
5447

5548
void ReferenceResolver::visit(const SharedPtr<BinaryOperatorExprNode> &bopExpr) {
56-
bopExpr->lhs->accept(getThisSharedPtr());
57-
bopExpr->rhs->accept(getThisSharedPtr());
49+
ASTVisitor::visit(bopExpr);
5850
}
5951

6052
void ReferenceResolver::visit(const SharedPtr<ExprStmtNode> &exprStmt) {
61-
exprStmt->expr->accept(getThisSharedPtr());
53+
ASTVisitor::visit(exprStmt);
6254
}
6355

6456
void ReferenceResolver::visit(const SharedPtr<CompoundStmtNode> &compStmt) {
6557
pushScope(compStmt->internalScope);
66-
for (const SharedPtr<StmtNode> &stmt: compStmt->childStmts) {
67-
stmt->accept(getThisSharedPtr());
68-
}
58+
ASTVisitor::visit(compStmt);
6959
popScope();
7060
}
7161

7262
void ReferenceResolver::visit(const SharedPtr<VarDeclStmtNode> &varDeclStmt) {
73-
for (const SharedPtr<VarDeclNode> &varDecl : varDeclStmt->childVarDecls) {
74-
varDecl->accept(getThisSharedPtr());
75-
}
63+
ASTVisitor::visit(varDeclStmt);
7664
}
7765

7866
void ReferenceResolver::visit(const SharedPtr<FunctionDeclStmtNode> &funcDeclStmt) {
79-
funcDeclStmt->childFunctionDecl->accept(getThisSharedPtr());
67+
ASTVisitor::visit(funcDeclStmt);
8068
}
8169

8270
void ReferenceResolver::visit(const SharedPtr<IfStmtNode> &ifStmt) {
83-
ifStmt->condition->accept(getThisSharedPtr());
84-
ifStmt->thenBody->accept(getThisSharedPtr());
85-
if (ifStmt->elseBody) {
86-
ifStmt->elseBody->accept(getThisSharedPtr());
87-
}
71+
ASTVisitor::visit(ifStmt);
8872
}
8973

9074
void ReferenceResolver::visit(const SharedPtr<WhileStmtNode> &whileStmt) {
91-
whileStmt->condition->accept(getThisSharedPtr());
92-
whileStmt->body->accept(getThisSharedPtr());
75+
ASTVisitor::visit(whileStmt);
9376
}
9477

9578
void ReferenceResolver::visit(const SharedPtr<ForStmtNode> &forStmt) {
9679
pushScope(forStmt->internalScope);
97-
if (forStmt->forInitVarDecls) {
98-
forStmt->forInitVarDecls->accept(getThisSharedPtr());
99-
} else {
100-
for (const SharedPtr<ExprNode> &initExpr: forStmt->forInitExprList) {
101-
initExpr->accept(getThisSharedPtr());
102-
}
103-
}
104-
if (forStmt->forCondition) {
105-
forStmt->forCondition->accept(getThisSharedPtr());
106-
}
107-
for (const SharedPtr<ExprNode> &updateExpr: forStmt->forUpdate) {
108-
updateExpr->accept(getThisSharedPtr());
109-
}
110-
forStmt->body->accept(getThisSharedPtr());
80+
ASTVisitor::visit(forStmt);
11181
popScope();
11282
}
11383

11484
void ReferenceResolver::visit(const SharedPtr<ReturnStmtNode> &returnStmt) {
115-
if (returnStmt->returnExpr) {
116-
returnStmt->returnExpr->accept(getThisSharedPtr());
117-
}
85+
ASTVisitor::visit(returnStmt);
11886
}

‎lib/Sema/ScopeScanner.cpp‎

Lines changed: 13 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -4,9 +4,7 @@ void ScopeScanner::visit(const SharedPtr<ModuleNode> &module) {
44
SharedPtr<TopLevelScope> topLevelScope = TopLevelScope::create();
55
module->internalScope = topLevelScope;
66
pushScope(topLevelScope);
7-
for (const SharedPtr<StmtNode> &stmt: module->childStmts) {
8-
stmt->accept(getThisSharedPtr());
9-
}
7+
ASTVisitor::visit(module);
108
popScope();
119
}
1210

@@ -29,10 +27,7 @@ void ScopeScanner::visit(const SharedPtr<FunctionDeclNode> &funcDecl) {
2927
SharedPtr<LocalScope> paramScope = LocalScope::create(topLevelScope);
3028
funcDecl->internalScope = paramScope;
3129
pushScope(paramScope);
32-
for (const SharedPtr<ParmVarDeclNode> &paramVarDecl : funcDecl->params) {
33-
paramVarDecl->accept(getThisSharedPtr());
34-
}
35-
funcDecl->body->accept(getThisSharedPtr());
30+
ASTVisitor::visit(funcDecl);
3631
popScope();
3732
}
3833

@@ -54,84 +49,59 @@ void ScopeScanner::visit(const SharedPtr<IdentifierExprNode> &varExpr) {
5449

5550
void ScopeScanner::visit(const SharedPtr<CallExprNode> &callExpr) {
5651
callExpr->scope = getCurrentScope();
57-
for (const SharedPtr<ExprNode> &argExpr: callExpr->args) {
58-
argExpr->accept(getThisSharedPtr());
59-
}
52+
ASTVisitor::visit(callExpr);
6053
}
6154

6255
void ScopeScanner::visit(const SharedPtr<UnaryOperatorExprNode> &uopExpr) {
6356
uopExpr->scope = getCurrentScope();
64-
uopExpr->subExpr->accept(getThisSharedPtr());
57+
ASTVisitor::visit(uopExpr);
6558
}
6659

6760
void ScopeScanner::visit(const SharedPtr<BinaryOperatorExprNode> &bopExpr) {
6861
bopExpr->scope = getCurrentScope();
69-
bopExpr->lhs->accept(getThisSharedPtr());
70-
bopExpr->rhs->accept(getThisSharedPtr());
62+
ASTVisitor::visit(bopExpr);
7163
}
7264

7365
void ScopeScanner::visit(const SharedPtr<ExprStmtNode> &exprStmt) {
7466
exprStmt->scope = getCurrentScope();
75-
exprStmt->expr->accept(getThisSharedPtr());
67+
ASTVisitor::visit(exprStmt);
7668
}
7769

7870
void ScopeScanner::visit(const SharedPtr<CompoundStmtNode> &compStmt) {
7971
compStmt->scope = getCurrentScope();
8072
SharedPtr<LocalScope> localScope = LocalScope::create(getCurrentScope());
8173
compStmt->internalScope = localScope;
8274
pushScope(localScope);
83-
for (const SharedPtr<StmtNode> &stmt: compStmt->childStmts) {
84-
stmt->accept(getThisSharedPtr());
85-
}
75+
ASTVisitor::visit(compStmt);
8676
popScope();
8777
}
8878

8979
void ScopeScanner::visit(const SharedPtr<VarDeclStmtNode> &varDeclStmt) {
9080
varDeclStmt->scope = getCurrentScope();
91-
for (const SharedPtr<VarDeclNode> &varDecl : varDeclStmt->childVarDecls) {
92-
varDecl->accept(getThisSharedPtr());
93-
}
81+
ASTVisitor::visit(varDeclStmt);
9482
}
9583

9684
void ScopeScanner::visit(const SharedPtr<FunctionDeclStmtNode> &funcDeclStmt) {
9785
funcDeclStmt->scope = getCurrentScope();
98-
funcDeclStmt->childFunctionDecl->accept(getThisSharedPtr());
86+
ASTVisitor::visit(funcDeclStmt);
9987
}
10088

10189
void ScopeScanner::visit(const SharedPtr<IfStmtNode> &ifStmt) {
10290
ifStmt->scope = getCurrentScope();
103-
ifStmt->condition->accept(getThisSharedPtr());
104-
ifStmt->thenBody->accept(getThisSharedPtr());
105-
if (ifStmt->elseBody) {
106-
ifStmt->elseBody->accept(getThisSharedPtr());
107-
}
91+
ASTVisitor::visit(ifStmt);
10892
}
10993

11094
void ScopeScanner::visit(const SharedPtr<WhileStmtNode> &whileStmt) {
11195
whileStmt->scope = getCurrentScope();
112-
whileStmt->condition->accept(getThisSharedPtr());
113-
whileStmt->body->accept(getThisSharedPtr());
96+
ASTVisitor::visit(whileStmt);
11497
}
11598

11699
void ScopeScanner::visit(const SharedPtr<ForStmtNode> &forStmt) {
117100
forStmt->scope = getCurrentScope();
118101
SharedPtr<LocalScope> forScope = LocalScope::create(getCurrentScope());
119102
forStmt->internalScope = forScope;
120103
pushScope(forScope);
121-
if (forStmt->forInitVarDecls) {
122-
forStmt->forInitVarDecls->accept(getThisSharedPtr());
123-
} else {
124-
for (const SharedPtr<ExprNode> &initExpr: forStmt->forInitExprList) {
125-
initExpr->accept(getThisSharedPtr());
126-
}
127-
}
128-
if (forStmt->forCondition) {
129-
forStmt->forCondition->accept(getThisSharedPtr());
130-
}
131-
for (const SharedPtr<ExprNode> &updateExpr: forStmt->forUpdate) {
132-
updateExpr->accept(getThisSharedPtr());
133-
}
134-
forStmt->body->accept(getThisSharedPtr());
104+
ASTVisitor::visit(forStmt);
135105
popScope();
136106
}
137107

@@ -145,7 +115,5 @@ void ScopeScanner::visit(const SharedPtr<BreakStmtNode> &breakStmt) {
145115

146116
void ScopeScanner::visit(const SharedPtr<ReturnStmtNode> &returnStmt) {
147117
returnStmt->scope = getCurrentScope();
148-
if (returnStmt->returnExpr) {
149-
returnStmt->returnExpr->accept(getThisSharedPtr());
150-
}
118+
ASTVisitor::visit(returnStmt);
151119
}

0 commit comments

Comments
 (0)