Skip to content

Commit 14f0388

Browse files
bryanlohxzbryanlohxz
committed
Duplicate ast extractor into type checker
1 parent 37c2cef commit 14f0388

15 files changed

+1975
-1
lines changed

‎src/types/ast/astExtractor/ast-extractor.ts‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
import { BaseJavaCstVisitorWithDefaults, CstNode, TypeDeclarationCtx } from "java-parser";
2+
3+
import { NormalClassDeclaration } from "../types/classes";
4+
import { AST } from "../types/packages-and-modules";
5+
import { ClassExtractor } from "./class-extractor";
6+
7+
export class ASTExtractor extends BaseJavaCstVisitorWithDefaults {
8+
private topLevelClassOrInterfaceDeclarations: NormalClassDeclaration[] = [];
9+
10+
extract(cst: CstNode): AST {
11+
this.visit(cst);
12+
return {
13+
kind: "CompilationUnit",
14+
importDeclarations: [],
15+
topLevelClassOrInterfaceDeclarations: this.topLevelClassOrInterfaceDeclarations,
16+
location: cst.location,
17+
}
18+
}
19+
20+
typeDeclaration(ctx: TypeDeclarationCtx) {
21+
if (ctx.classDeclaration) {
22+
ctx.classDeclaration.forEach((x) => {
23+
const classExtractor = new ClassExtractor();
24+
this.topLevelClassOrInterfaceDeclarations.push(
25+
classExtractor.extract(x)
26+
);
27+
});
28+
}
29+
}
30+
}

‎src/types/ast/astExtractor/block-statement-extractor.ts‎

Lines changed: 101 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,101 @@
1+
import {
2+
ArrayInitializerCtx,
3+
BaseJavaCstVisitorWithDefaults,
4+
BlockStatementCstNode,
5+
LocalVariableDeclarationCtx,
6+
LocalVariableDeclarationStatementCtx,
7+
LocalVariableTypeCtx,
8+
VariableDeclaratorCtx,
9+
VariableDeclaratorIdCtx,
10+
VariableDeclaratorListCtx,
11+
VariableInitializerCtx,
12+
VariableInitializerListCtx,
13+
} from "java-parser";
14+
import {
15+
BlockStatement,
16+
LocalVariableDeclarationStatement,
17+
VariableDeclarator,
18+
} from "../types/blocks-and-statements";
19+
import { ExpressionExtractor } from "./expression-extractor";
20+
import { StatementExtractor } from "./statement-extractor";
21+
import { TypeExtractor } from "./type-extractor";
22+
23+
export class BlockStatementExtractor extends BaseJavaCstVisitorWithDefaults {
24+
extract(cst: BlockStatementCstNode): BlockStatement {
25+
this.visit(cst);
26+
if (cst.children.localVariableDeclarationStatement) {
27+
return this.visit(cst.children.localVariableDeclarationStatement);
28+
} /* if (cst.children.statement) */ else {
29+
const statementExtractor = new StatementExtractor();
30+
return statementExtractor.extract(cst.children.statement![0]);
31+
}
32+
}
33+
34+
localVariableDeclarationStatement(
35+
ctx: LocalVariableDeclarationStatementCtx
36+
): LocalVariableDeclarationStatement {
37+
return {
38+
kind: "LocalVariableDeclarationStatement",
39+
...this.visit(ctx.localVariableDeclaration),
40+
};
41+
}
42+
43+
localVariableDeclaration(
44+
ctx: LocalVariableDeclarationCtx
45+
): Omit<LocalVariableDeclarationStatement, "kind"> {
46+
return {
47+
localVariableType: this.visit(ctx.localVariableType),
48+
variableDeclaratorList: this.visit(ctx.variableDeclaratorList),
49+
};
50+
}
51+
52+
localVariableType(ctx: LocalVariableTypeCtx) {
53+
const typeExtractor = new TypeExtractor();
54+
if (ctx.unannType) {
55+
return typeExtractor.extract(ctx.unannType[0]);
56+
} else if (ctx.Var) {
57+
throw new Error("Not implemented");
58+
}
59+
}
60+
61+
variableDeclaratorList(ctx: VariableDeclaratorListCtx) {
62+
return ctx.variableDeclarator.map((variableDeclarator) => {
63+
return this.visit(variableDeclarator);
64+
});
65+
}
66+
67+
variableDeclarator(ctx: VariableDeclaratorCtx): VariableDeclarator {
68+
return {
69+
kind: "VariableDeclarator",
70+
variableDeclaratorId: this.visit(ctx.variableDeclaratorId),
71+
variableInitializer: ctx.variableInitializer
72+
? this.visit(ctx.variableInitializer)
73+
: undefined,
74+
};
75+
}
76+
77+
variableDeclaratorId(ctx: VariableDeclaratorIdCtx) {
78+
return ctx.Identifier[0].image;
79+
}
80+
81+
variableInitializer(ctx: VariableInitializerCtx) {
82+
if (ctx.expression) {
83+
const expressionExtractor = new ExpressionExtractor();
84+
return expressionExtractor.extract(ctx.expression[0]);
85+
} else if (ctx.arrayInitializer) {
86+
return this.visit(ctx.arrayInitializer);
87+
}
88+
}
89+
90+
arrayInitializer(ctx: ArrayInitializerCtx) {
91+
if (ctx.variableInitializerList) {
92+
return this.visit(ctx.variableInitializerList);
93+
}
94+
}
95+
96+
variableInitializerList(ctx: VariableInitializerListCtx) {
97+
return ctx.variableInitializer.map((variableInitializer) => {
98+
return this.visit(variableInitializer);
99+
});
100+
}
101+
}

‎src/types/ast/astExtractor/class-extractor.ts‎

Lines changed: 92 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,92 @@
1+
import {
2+
BaseJavaCstVisitorWithDefaults,
3+
ClassBodyDeclarationCtx,
4+
ClassDeclarationCstNode,
5+
ClassMemberDeclarationCtx,
6+
ClassModifierCtx,
7+
ClassTypeCtx,
8+
TypeIdentifierCtx,
9+
} from "java-parser";
10+
11+
import {
12+
ClassModifier,
13+
Identifier,
14+
ClassBodyDeclaration,
15+
ClassDeclaration,
16+
NormalClassDeclaration
17+
} from "../types/classes";
18+
import { ConstructorExtractor } from "./constructor-extractor";
19+
import { FieldExtractor } from "./field-extractor";
20+
import { MethodExtractor } from "./method-extractor";
21+
22+
export class ClassExtractor extends BaseJavaCstVisitorWithDefaults {
23+
private modifier: Array<ClassModifier> = [];
24+
private identifier: Identifier;
25+
private body: Array<ClassBodyDeclaration> = [];
26+
private sclass: Identifier;
27+
28+
extract(cst: ClassDeclarationCstNode): ClassDeclaration {
29+
this.visit(cst);
30+
return {
31+
kind: "NormalClassDeclaration",
32+
classModifier: this.modifier,
33+
typeIdentifier: this.identifier,
34+
classBody: this.body,
35+
sclass: this.sclass,
36+
location: cst.location,
37+
} as NormalClassDeclaration;
38+
}
39+
40+
classModifier(ctx: ClassModifierCtx) {
41+
const possibleModifiers = [
42+
ctx.Public,
43+
ctx.Protected,
44+
ctx.Private,
45+
ctx.Abstract,
46+
ctx.Static,
47+
ctx.Final,
48+
ctx.Sealed,
49+
ctx.NonSealed,
50+
ctx.Strictfp
51+
].filter(x => x !== undefined).map(x => x ? x[0].image : x);
52+
this.modifier.push(possibleModifiers[0] as ClassModifier);
53+
}
54+
55+
typeIdentifier(ctx: TypeIdentifierCtx) {
56+
this.identifier = ctx.Identifier[0].image;
57+
}
58+
59+
classType(ctx: ClassTypeCtx) {
60+
this.sclass = ctx.Identifier[0].image;
61+
}
62+
63+
classBodyDeclaration(ctx: ClassBodyDeclarationCtx) {
64+
if (ctx.constructorDeclaration) {
65+
ctx.constructorDeclaration.forEach(x => {
66+
const constructorExtractor = new ConstructorExtractor();
67+
const constructorNode = constructorExtractor.extract(x);
68+
this.body.push(constructorNode);
69+
})
70+
}
71+
if (ctx.classMemberDeclaration) {
72+
this.visit(ctx.classMemberDeclaration);
73+
}
74+
}
75+
76+
classMemberDeclaration(ctx: ClassMemberDeclarationCtx) {
77+
if (ctx.fieldDeclaration) {
78+
ctx.fieldDeclaration.forEach(x => {
79+
const fieldExtractor = new FieldExtractor();
80+
const fieldNode = fieldExtractor.extract(x);
81+
this.body.push(fieldNode);
82+
})
83+
}
84+
if (ctx.methodDeclaration) {
85+
ctx.methodDeclaration.forEach(x => {
86+
const methodExtractor = new MethodExtractor();
87+
const methodNode = methodExtractor.extract(x);
88+
this.body.push(methodNode);
89+
})
90+
}
91+
}
92+
}

‎src/types/ast/astExtractor/constructor-extractor.ts‎

Lines changed: 122 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,122 @@
1+
import {
2+
ArgumentListCtx,
3+
BaseJavaCstVisitorWithDefaults,
4+
BlockStatementsCtx,
5+
ConstructorDeclarationCstNode,
6+
ConstructorModifierCtx,
7+
FormalParameterCtx,
8+
FormalParameterListCtx,
9+
SimpleTypeNameCtx,
10+
UnqualifiedExplicitConstructorInvocationCtx,
11+
VariableArityParameterCtx,
12+
VariableDeclaratorIdCtx,
13+
VariableParaRegularParameterCtx,
14+
} from "java-parser";
15+
16+
import {
17+
Identifier,
18+
FormalParameter,
19+
ConstructorModifier,
20+
ConstructorDeclaration,
21+
} from "../types/classes";
22+
import { BlockStatement, ExplicitConstructorInvocation } from "../types/blocks-and-statements";
23+
import { BlockStatementExtractor } from "./block-statement-extractor";
24+
import { TypeExtractor } from "./type-extractor";
25+
import { ExpressionExtractor } from "./expression-extractor";
26+
import { Location } from "../types/ast";
27+
28+
export class ConstructorExtractor extends BaseJavaCstVisitorWithDefaults {
29+
private modifier: Array<ConstructorModifier> = [];
30+
private identifier: Identifier;
31+
private params: Array<FormalParameter> = [];
32+
private body: Array<BlockStatement> = [];
33+
private location: Location;
34+
35+
extract(cst: ConstructorDeclarationCstNode): ConstructorDeclaration {
36+
this.location = cst.location;
37+
this.visit(cst);
38+
return {
39+
kind: "ConstructorDeclaration",
40+
constructorModifier: this.modifier,
41+
constructorDeclarator: {
42+
identifier: this.identifier,
43+
formalParameterList: this.params,
44+
},
45+
constructorBody: {
46+
kind: "Block",
47+
blockStatements: this.body,
48+
location: this.location,
49+
},
50+
location: this.location,
51+
};
52+
}
53+
54+
constructorModifier(ctx: ConstructorModifierCtx) {
55+
const possibleModifiers = [
56+
ctx.Public,
57+
ctx.Protected,
58+
ctx.Private,
59+
].filter(x => x !== undefined).map(x => x ? x[0].image : x);
60+
this.modifier.push(possibleModifiers[0] as ConstructorModifier);
61+
}
62+
63+
simpleTypeName(ctx: SimpleTypeNameCtx) {
64+
this.identifier = ctx.Identifier[0].image;
65+
}
66+
67+
formalParameterList(ctx: FormalParameterListCtx) {
68+
this.params = ctx.formalParameter.map(p => this.visit(p));
69+
}
70+
71+
formalParameter(ctx: FormalParameterCtx) {
72+
if (ctx.variableParaRegularParameter) {
73+
return this.visit(ctx.variableParaRegularParameter);
74+
} else /* if (ctx.variableArityParameter) */ {
75+
return this.visit(ctx.variableArityParameter!);
76+
}
77+
}
78+
79+
variableParaRegularParameter(ctx: VariableParaRegularParameterCtx) {
80+
const typeExtractor = new TypeExtractor();
81+
return {
82+
kind: "FormalParameter",
83+
unannType: typeExtractor.extract(ctx.unannType[0]),
84+
identifier: this.visit(ctx.variableDeclaratorId),
85+
} as FormalParameter;
86+
}
87+
88+
variableArityParameter(ctx: VariableArityParameterCtx) {
89+
const typeExtractor = new TypeExtractor();
90+
return {
91+
kind: "FormalParameter",
92+
unannType: typeExtractor.extract(ctx.unannType[0]),
93+
identifier: ctx.Identifier[0].image,
94+
} as FormalParameter;
95+
}
96+
97+
variableDeclaratorId(ctx: VariableDeclaratorIdCtx) {
98+
return ctx.Identifier[0].image;
99+
}
100+
101+
blockStatements(ctx: BlockStatementsCtx) {
102+
ctx.blockStatement.forEach(x => {
103+
const blockStatementExtractor = new BlockStatementExtractor();
104+
this.body.push(blockStatementExtractor.extract(x));
105+
})
106+
}
107+
108+
unqualifiedExplicitConstructorInvocation(ctx: UnqualifiedExplicitConstructorInvocationCtx) {
109+
const expConInv = {
110+
kind: "ExplicitConstructorInvocation",
111+
thisOrSuper: ctx.This?.[0].image || ctx.Super?.[0].image,
112+
argumentList: ctx.argumentList ? this.visit(ctx.argumentList) : [],
113+
location: this.location,
114+
} as ExplicitConstructorInvocation;
115+
this.body.push(expConInv);
116+
}
117+
118+
argumentList(ctx: ArgumentListCtx) {
119+
const expressionExtractor = new ExpressionExtractor();
120+
return ctx.expression.map(e => expressionExtractor.extract(e));
121+
}
122+
}

0 commit comments

Comments
 (0)