Skip to content

Commit b21720e

Browse files
JantherJanther
committed
updating all createNonterminalVariant based on Franco's feedback
1 parent 7d53963 commit b21720e

22 files changed

Lines changed: 421 additions & 442 deletions

‎src/slang-nodes/ArgumentsDeclaration.ts‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -14,12 +14,12 @@ function createNonterminalVariant(
1414
): ArgumentsDeclaration['variant'] {
1515
if (variant instanceof ast.PositionalArgumentsDeclaration) {
1616
return new PositionalArgumentsDeclaration(variant, options);
17-
} else if (variant instanceof ast.NamedArgumentsDeclaration) {
17+
}
18+
if (variant instanceof ast.NamedArgumentsDeclaration) {
1819
return new NamedArgumentsDeclaration(variant, options);
19-
} else {
20-
const exhaustiveCheck: never = variant;
21-
return exhaustiveCheck;
2220
}
21+
const exhaustiveCheck: never = variant;
22+
return exhaustiveCheck;
2323
}
2424

2525
export class ArgumentsDeclaration extends SlangNode {

‎src/slang-nodes/ContractMember.ts‎

Lines changed: 41 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
import * as ast from '@nomicfoundation/slang/ast';
12
import { NonterminalKind } from '@nomicfoundation/slang/cst';
23
import { SlangNode } from './SlangNode.js';
34
import { UsingDirective } from './UsingDirective.js';
@@ -14,7 +15,6 @@ import { StateVariableDefinition } from './StateVariableDefinition.js';
1415
import { ErrorDefinition } from './ErrorDefinition.js';
1516
import { UserDefinedValueTypeDefinition } from './UserDefinedValueTypeDefinition.js';
1617

17-
import type * as ast from '@nomicfoundation/slang/ast';
1818
import type { AstPath, Doc, ParserOptions } from 'prettier';
1919
import type { AstNode } from './types.d.ts';
2020
import type { PrintFunction } from '../types.d.ts';
@@ -23,53 +23,47 @@ function createNonterminalVariant(
2323
variant: ast.ContractMember['variant'],
2424
options: ParserOptions<AstNode>
2525
): 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}`);
26+
if (variant instanceof ast.UsingDirective) {
27+
return new UsingDirective(variant, options);
7228
}
29+
if (variant instanceof ast.FunctionDefinition) {
30+
return new FunctionDefinition(variant, options);
31+
}
32+
if (variant instanceof ast.ConstructorDefinition) {
33+
return new ConstructorDefinition(variant, options);
34+
}
35+
if (variant instanceof ast.ReceiveFunctionDefinition) {
36+
return new ReceiveFunctionDefinition(variant, options);
37+
}
38+
if (variant instanceof ast.FallbackFunctionDefinition) {
39+
return new FallbackFunctionDefinition(variant, options);
40+
}
41+
if (variant instanceof ast.UnnamedFunctionDefinition) {
42+
return new UnnamedFunctionDefinition(variant, options);
43+
}
44+
if (variant instanceof ast.ModifierDefinition) {
45+
return new ModifierDefinition(variant, options);
46+
}
47+
if (variant instanceof ast.StructDefinition) {
48+
return new StructDefinition(variant, options);
49+
}
50+
if (variant instanceof ast.EnumDefinition) {
51+
return new EnumDefinition(variant);
52+
}
53+
if (variant instanceof ast.EventDefinition) {
54+
return new EventDefinition(variant, options);
55+
}
56+
if (variant instanceof ast.StateVariableDefinition) {
57+
return new StateVariableDefinition(variant, options);
58+
}
59+
if (variant instanceof ast.ErrorDefinition) {
60+
return new ErrorDefinition(variant, options);
61+
}
62+
if (variant instanceof ast.UserDefinedValueTypeDefinition) {
63+
return new UserDefinedValueTypeDefinition(variant);
64+
}
65+
const exhaustiveCheck: never = variant;
66+
return exhaustiveCheck;
7367
}
7468

7569
export class ContractMember extends SlangNode {

‎src/slang-nodes/ContractSpecifier.ts‎

Lines changed: 8 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,9 @@
1+
import * as ast from '@nomicfoundation/slang/ast';
12
import { NonterminalKind } from '@nomicfoundation/slang/cst';
23
import { SlangNode } from './SlangNode.js';
34
import { InheritanceSpecifier } from './InheritanceSpecifier.js';
45
import { StorageLayoutSpecifier } from './StorageLayoutSpecifier.js';
56

6-
import type * as ast from '@nomicfoundation/slang/ast';
77
import type { AstPath, Doc, ParserOptions } from 'prettier';
88
import type { AstNode } from './types.d.ts';
99
import type { PrintFunction } from '../types.d.ts';
@@ -12,20 +12,14 @@ function createNonterminalVariant(
1212
variant: ast.ContractSpecifier['variant'],
1313
options: ParserOptions<AstNode>
1414
): 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}`);
15+
if (variant instanceof ast.InheritanceSpecifier) {
16+
return new InheritanceSpecifier(variant, options);
2817
}
18+
if (variant instanceof ast.StorageLayoutSpecifier) {
19+
return new StorageLayoutSpecifier(variant, options);
20+
}
21+
const exhaustiveCheck: never = variant;
22+
return exhaustiveCheck;
2923
}
3024

3125
export class ContractSpecifier extends SlangNode {

‎src/slang-nodes/Expression.ts‎

Lines changed: 83 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
import * as ast from '@nomicfoundation/slang/ast';
12
import { NonterminalKind, TerminalNode } from '@nomicfoundation/slang/cst';
23
import { SlangNode } from './SlangNode.js';
34
import { AssignmentExpression } from './AssignmentExpression.js';
@@ -29,7 +30,6 @@ import { StringExpression } from './StringExpression.js';
2930
import { ElementaryType } from './ElementaryType.js';
3031
import { Identifier } from './Identifier.js';
3132

32-
import type * as ast from '@nomicfoundation/slang/ast';
3333
import type { AstPath, Doc, ParserOptions } from 'prettier';
3434
import type { AstNode } from './types.d.ts';
3535
import type { PrintFunction } from '../types.d.ts';
@@ -38,102 +38,89 @@ function createNonterminalVariant(
3838
variant: Exclude<ast.Expression['variant'], TerminalNode>,
3939
options: ParserOptions<AstNode>
4040
): Exclude<Expression['variant'], Identifier> {
41-
switch (variant.cst.kind) {
42-
case NonterminalKind.AssignmentExpression:
43-
return new AssignmentExpression(
44-
variant as ast.AssignmentExpression,
45-
options
46-
);
47-
case NonterminalKind.ConditionalExpression:
48-
return new ConditionalExpression(
49-
variant as ast.ConditionalExpression,
50-
options
51-
);
52-
case NonterminalKind.OrExpression:
53-
return new OrExpression(variant as ast.OrExpression, options);
54-
case NonterminalKind.AndExpression:
55-
return new AndExpression(variant as ast.AndExpression, options);
56-
case NonterminalKind.EqualityExpression:
57-
return new EqualityExpression(variant as ast.EqualityExpression, options);
58-
case NonterminalKind.InequalityExpression:
59-
return new InequalityExpression(
60-
variant as ast.InequalityExpression,
61-
options
62-
);
63-
case NonterminalKind.BitwiseOrExpression:
64-
return new BitwiseOrExpression(
65-
variant as ast.BitwiseOrExpression,
66-
options
67-
);
68-
case NonterminalKind.BitwiseXorExpression:
69-
return new BitwiseXorExpression(
70-
variant as ast.BitwiseXorExpression,
71-
options
72-
);
73-
case NonterminalKind.BitwiseAndExpression:
74-
return new BitwiseAndExpression(
75-
variant as ast.BitwiseAndExpression,
76-
options
77-
);
78-
case NonterminalKind.ShiftExpression:
79-
return new ShiftExpression(variant as ast.ShiftExpression, options);
80-
case NonterminalKind.AdditiveExpression:
81-
return new AdditiveExpression(variant as ast.AdditiveExpression, options);
82-
case NonterminalKind.MultiplicativeExpression:
83-
return new MultiplicativeExpression(
84-
variant as ast.MultiplicativeExpression,
85-
options
86-
);
87-
case NonterminalKind.ExponentiationExpression:
88-
return new ExponentiationExpression(
89-
variant as ast.ExponentiationExpression,
90-
options
91-
);
92-
case NonterminalKind.PostfixExpression:
93-
return new PostfixExpression(variant as ast.PostfixExpression, options);
94-
case NonterminalKind.PrefixExpression:
95-
return new PrefixExpression(variant as ast.PrefixExpression, options);
96-
case NonterminalKind.FunctionCallExpression:
97-
return new FunctionCallExpression(
98-
variant as ast.FunctionCallExpression,
99-
options
100-
);
101-
case NonterminalKind.CallOptionsExpression:
102-
return new CallOptionsExpression(
103-
variant as ast.CallOptionsExpression,
104-
options
105-
);
106-
case NonterminalKind.MemberAccessExpression:
107-
return new MemberAccessExpression(
108-
variant as ast.MemberAccessExpression,
109-
options
110-
);
111-
case NonterminalKind.IndexAccessExpression:
112-
return new IndexAccessExpression(
113-
variant as ast.IndexAccessExpression,
114-
options
115-
);
116-
case NonterminalKind.NewExpression:
117-
return new NewExpression(variant as ast.NewExpression, options);
118-
case NonterminalKind.TupleExpression:
119-
return new TupleExpression(variant as ast.TupleExpression, options);
120-
case NonterminalKind.TypeExpression:
121-
return new TypeExpression(variant as ast.TypeExpression, options);
122-
case NonterminalKind.ArrayExpression:
123-
return new ArrayExpression(variant as ast.ArrayExpression, options);
124-
case NonterminalKind.HexNumberExpression:
125-
return new HexNumberExpression(variant as ast.HexNumberExpression);
126-
case NonterminalKind.DecimalNumberExpression:
127-
return new DecimalNumberExpression(
128-
variant as ast.DecimalNumberExpression
129-
);
130-
case NonterminalKind.StringExpression:
131-
return new StringExpression(variant as ast.StringExpression, options);
132-
case NonterminalKind.ElementaryType:
133-
return new ElementaryType(variant as ast.ElementaryType);
134-
default:
135-
throw new Error(`Unexpected variant: ${variant.cst.kind}`);
41+
if (variant instanceof ast.AssignmentExpression) {
42+
return new AssignmentExpression(variant, options);
13643
}
44+
if (variant instanceof ast.ConditionalExpression) {
45+
return new ConditionalExpression(variant, options);
46+
}
47+
if (variant instanceof ast.OrExpression) {
48+
return new OrExpression(variant, options);
49+
}
50+
if (variant instanceof ast.AndExpression) {
51+
return new AndExpression(variant, options);
52+
}
53+
if (variant instanceof ast.EqualityExpression) {
54+
return new EqualityExpression(variant, options);
55+
}
56+
if (variant instanceof ast.InequalityExpression) {
57+
return new InequalityExpression(variant, options);
58+
}
59+
if (variant instanceof ast.BitwiseOrExpression) {
60+
return new BitwiseOrExpression(variant, options);
61+
}
62+
if (variant instanceof ast.BitwiseXorExpression) {
63+
return new BitwiseXorExpression(variant, options);
64+
}
65+
if (variant instanceof ast.BitwiseAndExpression) {
66+
return new BitwiseAndExpression(variant, options);
67+
}
68+
if (variant instanceof ast.ShiftExpression) {
69+
return new ShiftExpression(variant, options);
70+
}
71+
if (variant instanceof ast.AdditiveExpression) {
72+
return new AdditiveExpression(variant, options);
73+
}
74+
if (variant instanceof ast.MultiplicativeExpression) {
75+
return new MultiplicativeExpression(variant, options);
76+
}
77+
if (variant instanceof ast.ExponentiationExpression) {
78+
return new ExponentiationExpression(variant, options);
79+
}
80+
if (variant instanceof ast.PostfixExpression) {
81+
return new PostfixExpression(variant, options);
82+
}
83+
if (variant instanceof ast.PrefixExpression) {
84+
return new PrefixExpression(variant, options);
85+
}
86+
if (variant instanceof ast.FunctionCallExpression) {
87+
return new FunctionCallExpression(variant, options);
88+
}
89+
if (variant instanceof ast.CallOptionsExpression) {
90+
return new CallOptionsExpression(variant, options);
91+
}
92+
if (variant instanceof ast.MemberAccessExpression) {
93+
return new MemberAccessExpression(variant, options);
94+
}
95+
if (variant instanceof ast.IndexAccessExpression) {
96+
return new IndexAccessExpression(variant, options);
97+
}
98+
if (variant instanceof ast.NewExpression) {
99+
return new NewExpression(variant, options);
100+
}
101+
if (variant instanceof ast.TupleExpression) {
102+
return new TupleExpression(variant, options);
103+
}
104+
if (variant instanceof ast.TypeExpression) {
105+
return new TypeExpression(variant, options);
106+
}
107+
if (variant instanceof ast.ArrayExpression) {
108+
return new ArrayExpression(variant, options);
109+
}
110+
if (variant instanceof ast.HexNumberExpression) {
111+
return new HexNumberExpression(variant);
112+
}
113+
if (variant instanceof ast.DecimalNumberExpression) {
114+
return new DecimalNumberExpression(variant);
115+
}
116+
if (variant instanceof ast.StringExpression) {
117+
return new StringExpression(variant, options);
118+
}
119+
if (variant instanceof ast.ElementaryType) {
120+
return new ElementaryType(variant);
121+
}
122+
const exhaustiveCheck: never = variant;
123+
return exhaustiveCheck;
137124
}
138125

139126
export class Expression extends SlangNode {

‎src/slang-nodes/FallbackFunctionAttribute.ts‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,10 @@
1+
import * as ast from '@nomicfoundation/slang/ast';
12
import { NonterminalKind, TerminalNode } from '@nomicfoundation/slang/cst';
23
import { printVariant } from '../slang-printers/print-variant.js';
34
import { SlangNode } from './SlangNode.js';
45
import { ModifierInvocation } from './ModifierInvocation.js';
56
import { OverrideSpecifier } from './OverrideSpecifier.js';
67

7-
import type * as ast from '@nomicfoundation/slang/ast';
88
import type { AstPath, Doc, ParserOptions } from 'prettier';
99
import type { AstNode } from './types.d.ts';
1010
import type { PrintFunction } from '../types.d.ts';
@@ -13,14 +13,14 @@ function createNonterminalVariant(
1313
variant: Exclude<ast.FallbackFunctionAttribute['variant'], TerminalNode>,
1414
options: ParserOptions<AstNode>
1515
): Exclude<FallbackFunctionAttribute['variant'], string> {
16-
switch (variant.cst.kind) {
17-
case NonterminalKind.ModifierInvocation:
18-
return new ModifierInvocation(variant as ast.ModifierInvocation, options);
19-
case NonterminalKind.OverrideSpecifier:
20-
return new OverrideSpecifier(variant as ast.OverrideSpecifier);
21-
default:
22-
throw new Error(`Unexpected variant: ${variant.cst.kind}`);
16+
if (variant instanceof ast.ModifierInvocation) {
17+
return new ModifierInvocation(variant, options);
2318
}
19+
if (variant instanceof ast.OverrideSpecifier) {
20+
return new OverrideSpecifier(variant);
21+
}
22+
const exhaustiveCheck: never = variant;
23+
return exhaustiveCheck;
2424
}
2525

2626
export class FallbackFunctionAttribute extends SlangNode {

0 commit comments

Comments
 (0)