Skip to content

Commit 13d3b20

Browse files
JantherJanther
committed
helper function for variant creation
1 parent 93e7194 commit 13d3b20

22 files changed

Lines changed: 604 additions & 757 deletions

‎src/slang-nodes/ArgumentsDeclaration.ts‎

Lines changed: 21 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,26 @@ import type { AstPath, Doc, ParserOptions } from 'prettier';
88
import type { AstNode } from './types.d.ts';
99
import type { PrintFunction } from '../types.d.ts';
1010

11+
function createNonterminalVariant(
12+
variant: ast.ArgumentsDeclaration['variant'],
13+
options: ParserOptions<AstNode>
14+
): ArgumentsDeclaration['variant'] {
15+
switch (variant.cst.kind) {
16+
case NonterminalKind.PositionalArgumentsDeclaration:
17+
return new PositionalArgumentsDeclaration(
18+
variant as ast.PositionalArgumentsDeclaration,
19+
options
20+
);
21+
case NonterminalKind.NamedArgumentsDeclaration:
22+
return new NamedArgumentsDeclaration(
23+
variant as ast.NamedArgumentsDeclaration,
24+
options
25+
);
26+
default:
27+
throw new Error(`Unexpected variant: ${variant.cst.kind}`);
28+
}
29+
}
30+
1131
export class ArgumentsDeclaration extends SlangNode {
1232
readonly kind = NonterminalKind.ArgumentsDeclaration;
1333

@@ -16,24 +36,7 @@ export class ArgumentsDeclaration extends SlangNode {
1636
constructor(ast: ast.ArgumentsDeclaration, options: ParserOptions<AstNode>) {
1737
super(ast);
1838

19-
const variant = ast.variant;
20-
const variantKind = variant.cst.kind;
21-
switch (variantKind) {
22-
case NonterminalKind.PositionalArgumentsDeclaration:
23-
this.variant = new PositionalArgumentsDeclaration(
24-
variant as ast.PositionalArgumentsDeclaration,
25-
options
26-
);
27-
break;
28-
case NonterminalKind.NamedArgumentsDeclaration:
29-
this.variant = new NamedArgumentsDeclaration(
30-
variant as ast.NamedArgumentsDeclaration,
31-
options
32-
);
33-
break;
34-
default:
35-
throw new Error(`Unexpected variant: ${variantKind}`);
36-
}
39+
this.variant = createNonterminalVariant(ast.variant, options);
3740

3841
this.updateMetadata(this.variant);
3942
}

‎src/slang-nodes/ContractMember.ts‎

Lines changed: 54 additions & 80 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,59 @@ import type { AstPath, Doc, ParserOptions } from 'prettier';
1919
import type { AstNode } from './types.d.ts';
2020
import type { PrintFunction } from '../types.d.ts';
2121

22+
function createNonterminalVariant(
23+
variant: ast.ContractMember['variant'],
24+
options: ParserOptions<AstNode>
25+
): ContractMember['variant'] {
26+
switch (variant.cst.kind) {
27+
case NonterminalKind.UsingDirective:
28+
return new UsingDirective(variant as ast.UsingDirective, options);
29+
case NonterminalKind.FunctionDefinition:
30+
return new FunctionDefinition(variant as ast.FunctionDefinition, options);
31+
case NonterminalKind.ConstructorDefinition:
32+
return new ConstructorDefinition(
33+
variant as ast.ConstructorDefinition,
34+
options
35+
);
36+
case NonterminalKind.ReceiveFunctionDefinition:
37+
return new ReceiveFunctionDefinition(
38+
variant as ast.ReceiveFunctionDefinition,
39+
options
40+
);
41+
case NonterminalKind.FallbackFunctionDefinition:
42+
return new FallbackFunctionDefinition(
43+
variant as ast.FallbackFunctionDefinition,
44+
options
45+
);
46+
case NonterminalKind.UnnamedFunctionDefinition:
47+
return new UnnamedFunctionDefinition(
48+
variant as ast.UnnamedFunctionDefinition,
49+
options
50+
);
51+
case NonterminalKind.ModifierDefinition:
52+
return new ModifierDefinition(variant as ast.ModifierDefinition, options);
53+
case NonterminalKind.StructDefinition:
54+
return new StructDefinition(variant as ast.StructDefinition, options);
55+
case NonterminalKind.EnumDefinition:
56+
return new EnumDefinition(variant as ast.EnumDefinition);
57+
case NonterminalKind.EventDefinition:
58+
return new EventDefinition(variant as ast.EventDefinition, options);
59+
case NonterminalKind.StateVariableDefinition:
60+
return new StateVariableDefinition(
61+
variant as ast.StateVariableDefinition,
62+
options
63+
);
64+
case NonterminalKind.ErrorDefinition:
65+
return new ErrorDefinition(variant as ast.ErrorDefinition, options);
66+
case NonterminalKind.UserDefinedValueTypeDefinition:
67+
return new UserDefinedValueTypeDefinition(
68+
variant as ast.UserDefinedValueTypeDefinition
69+
);
70+
default:
71+
throw new Error(`Unexpected variant: ${variant.cst.kind}`);
72+
}
73+
}
74+
2275
export class ContractMember extends SlangNode {
2376
readonly kind = NonterminalKind.ContractMember;
2477

@@ -40,86 +93,7 @@ export class ContractMember extends SlangNode {
4093
constructor(ast: ast.ContractMember, options: ParserOptions<AstNode>) {
4194
super(ast);
4295

43-
const variant = ast.variant;
44-
const variantKind = variant.cst.kind;
45-
switch (variantKind) {
46-
case NonterminalKind.UsingDirective:
47-
this.variant = new UsingDirective(
48-
variant as ast.UsingDirective,
49-
options
50-
);
51-
break;
52-
case NonterminalKind.FunctionDefinition:
53-
this.variant = new FunctionDefinition(
54-
variant as ast.FunctionDefinition,
55-
options
56-
);
57-
break;
58-
case NonterminalKind.ConstructorDefinition:
59-
this.variant = new ConstructorDefinition(
60-
variant as ast.ConstructorDefinition,
61-
options
62-
);
63-
break;
64-
case NonterminalKind.ReceiveFunctionDefinition:
65-
this.variant = new ReceiveFunctionDefinition(
66-
variant as ast.ReceiveFunctionDefinition,
67-
options
68-
);
69-
break;
70-
case NonterminalKind.FallbackFunctionDefinition:
71-
this.variant = new FallbackFunctionDefinition(
72-
variant as ast.FallbackFunctionDefinition,
73-
options
74-
);
75-
break;
76-
case NonterminalKind.UnnamedFunctionDefinition:
77-
this.variant = new UnnamedFunctionDefinition(
78-
variant as ast.UnnamedFunctionDefinition,
79-
options
80-
);
81-
break;
82-
case NonterminalKind.ModifierDefinition:
83-
this.variant = new ModifierDefinition(
84-
variant as ast.ModifierDefinition,
85-
options
86-
);
87-
break;
88-
case NonterminalKind.StructDefinition:
89-
this.variant = new StructDefinition(
90-
variant as ast.StructDefinition,
91-
options
92-
);
93-
break;
94-
case NonterminalKind.EnumDefinition:
95-
this.variant = new EnumDefinition(variant as ast.EnumDefinition);
96-
break;
97-
case NonterminalKind.EventDefinition:
98-
this.variant = new EventDefinition(
99-
variant as ast.EventDefinition,
100-
options
101-
);
102-
break;
103-
case NonterminalKind.StateVariableDefinition:
104-
this.variant = new StateVariableDefinition(
105-
variant as ast.StateVariableDefinition,
106-
options
107-
);
108-
break;
109-
case NonterminalKind.ErrorDefinition:
110-
this.variant = new ErrorDefinition(
111-
variant as ast.ErrorDefinition,
112-
options
113-
);
114-
break;
115-
case NonterminalKind.UserDefinedValueTypeDefinition:
116-
this.variant = new UserDefinedValueTypeDefinition(
117-
variant as ast.UserDefinedValueTypeDefinition
118-
);
119-
break;
120-
default:
121-
throw new Error(`Unexpected variant: ${variantKind}`);
122-
}
96+
this.variant = createNonterminalVariant(ast.variant, options);
12397

12498
this.updateMetadata(this.variant);
12599
}

‎src/slang-nodes/ContractSpecifier.ts‎

Lines changed: 22 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,26 @@ import type { AstPath, Doc, ParserOptions } from 'prettier';
88
import type { AstNode } from './types.d.ts';
99
import type { PrintFunction } from '../types.d.ts';
1010

11+
function createNonterminalVariant(
12+
variant: ast.ContractSpecifier['variant'],
13+
options: ParserOptions<AstNode>
14+
): ContractSpecifier['variant'] {
15+
switch (variant.cst.kind) {
16+
case NonterminalKind.InheritanceSpecifier:
17+
return new InheritanceSpecifier(
18+
variant as ast.InheritanceSpecifier,
19+
options
20+
);
21+
case NonterminalKind.StorageLayoutSpecifier:
22+
return new StorageLayoutSpecifier(
23+
variant as ast.StorageLayoutSpecifier,
24+
options
25+
);
26+
default:
27+
throw new Error(`Unexpected variant: ${variant.cst.kind}`);
28+
}
29+
}
30+
1131
export class ContractSpecifier extends SlangNode {
1232
readonly kind = NonterminalKind.ContractSpecifier;
1333

@@ -16,24 +36,8 @@ export class ContractSpecifier extends SlangNode {
1636
constructor(ast: ast.ContractSpecifier, options: ParserOptions<AstNode>) {
1737
super(ast);
1838

19-
const variant = ast.variant;
20-
const variantKind = variant.cst.kind;
21-
switch (variantKind) {
22-
case NonterminalKind.InheritanceSpecifier:
23-
this.variant = new InheritanceSpecifier(
24-
variant as ast.InheritanceSpecifier,
25-
options
26-
);
27-
break;
28-
case NonterminalKind.StorageLayoutSpecifier:
29-
this.variant = new StorageLayoutSpecifier(
30-
variant as ast.StorageLayoutSpecifier,
31-
options
32-
);
33-
break;
34-
default:
35-
throw new Error(`Unexpected variant: ${variantKind}`);
36-
}
39+
this.variant = createNonterminalVariant(ast.variant, options);
40+
3741
this.updateMetadata(this.variant);
3842
}
3943

0 commit comments

Comments
 (0)