Skip to content

Commit 7391083

Browse files
CountBleckjtenner
CountBleck
and
jtenner
committed
Update *Kind members as per AssemblyScript/assemblyscript#2501
AssemblyScript now uses Pascal case in its *Kind enums, so this commit changes visitor-as's usage accordingly. AssemblyScript also renamed the "statements" member in some Nodes to "body". That change has also been accounted for. Finally, transformRange.ts, an unused file, has now been deleted. Co-authored-by: Joshua Tenner <[email protected]>
1 parent af7c868 commit 7391083

File tree

8 files changed

+287
-306
lines changed

8 files changed

+287
-306
lines changed

‎src/astBuilder.ts

Lines changed: 135 additions & 135 deletions
Large diffs are not rendered by default.

‎src/base.ts

Lines changed: 72 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -86,249 +86,249 @@ export class BaseVisitor extends AbstractVisitor<Node> {
8686

8787
protected _visit(node: Node): void {
8888
switch (node.kind) {
89-
case NodeKind.SOURCE: {
89+
case NodeKind.Source: {
9090
this.visitSource(<Source>node);
9191
break;
9292
}
9393

9494
// types
9595

96-
case NodeKind.NAMEDTYPE: {
96+
case NodeKind.NamedType: {
9797
this.visitNamedTypeNode(<NamedTypeNode>node);
9898
break;
9999
}
100-
case NodeKind.FUNCTIONTYPE: {
100+
case NodeKind.FunctionType: {
101101
this.visitFunctionTypeNode(<FunctionTypeNode>node);
102102
break;
103103
}
104-
case NodeKind.TYPENAME: {
104+
case NodeKind.TypeName: {
105105
this.visitTypeName(<TypeName>node);
106106
}
107-
case NodeKind.TYPEPARAMETER: {
107+
case NodeKind.TypeParameter: {
108108
this.visitTypeParameter(<TypeParameterNode>node);
109109
break;
110110
}
111111

112112
// expressions
113113

114-
case NodeKind.FALSE:
115-
case NodeKind.NULL:
116-
case NodeKind.SUPER:
117-
case NodeKind.THIS:
118-
case NodeKind.TRUE:
119-
case NodeKind.CONSTRUCTOR:
120-
case NodeKind.IDENTIFIER: {
114+
case NodeKind.False:
115+
case NodeKind.Null:
116+
case NodeKind.Super:
117+
case NodeKind.This:
118+
case NodeKind.True:
119+
case NodeKind.Constructor:
120+
case NodeKind.Identifier: {
121121
this.visitIdentifierExpression(<IdentifierExpression>node);
122122
break;
123123
}
124-
case NodeKind.ASSERTION: {
124+
case NodeKind.Assertion: {
125125
this.visitAssertionExpression(<AssertionExpression>node);
126126
break;
127127
}
128-
case NodeKind.BINARY: {
128+
case NodeKind.Binary: {
129129
this.visitBinaryExpression(<BinaryExpression>node);
130130
break;
131131
}
132-
case NodeKind.CALL: {
132+
case NodeKind.Call: {
133133
this.visitCallExpression(<CallExpression>node);
134134
break;
135135
}
136-
case NodeKind.CLASS: {
136+
case NodeKind.Class: {
137137
this.visitClassExpression(<ClassExpression>node);
138138
break;
139139
}
140-
case NodeKind.COMMA: {
140+
case NodeKind.Comma: {
141141
this.visitCommaExpression(<CommaExpression>node);
142142
break;
143143
}
144-
case NodeKind.ELEMENTACCESS: {
144+
case NodeKind.ElementAccess: {
145145
this.visitElementAccessExpression(
146146
<ElementAccessExpression>node
147147
);
148148
break;
149149
}
150-
case NodeKind.FUNCTION: {
150+
case NodeKind.Function: {
151151
this.visitFunctionExpression(<FunctionExpression>node);
152152
break;
153153
}
154-
case NodeKind.INSTANCEOF: {
154+
case NodeKind.InstanceOf: {
155155
this.visitInstanceOfExpression(<InstanceOfExpression>node);
156156
break;
157157
}
158-
case NodeKind.LITERAL: {
158+
case NodeKind.Literal: {
159159
this.visitLiteralExpression(<LiteralExpression>node);
160160
break;
161161
}
162-
case NodeKind.NEW: {
162+
case NodeKind.New: {
163163
this.visitNewExpression(<NewExpression>node);
164164
break;
165165
}
166-
case NodeKind.PARENTHESIZED: {
166+
case NodeKind.Parenthesized: {
167167
this.visitParenthesizedExpression(
168168
<ParenthesizedExpression>node
169169
);
170170
break;
171171
}
172-
case NodeKind.PROPERTYACCESS: {
172+
case NodeKind.PropertyAccess: {
173173
this.visitPropertyAccessExpression(
174174
<PropertyAccessExpression>node
175175
);
176176
break;
177177
}
178-
case NodeKind.TERNARY: {
178+
case NodeKind.Ternary: {
179179
this.visitTernaryExpression(<TernaryExpression>node);
180180
break;
181181
}
182-
case NodeKind.UNARYPOSTFIX: {
182+
case NodeKind.UnaryPostfix: {
183183
this.visitUnaryPostfixExpression(<UnaryPostfixExpression>node);
184184
break;
185185
}
186-
case NodeKind.UNARYPREFIX: {
186+
case NodeKind.UnaryPrefix: {
187187
this.visitUnaryPrefixExpression(<UnaryPrefixExpression>node);
188188
break;
189189
}
190190

191191
// statements
192192

193-
case NodeKind.BLOCK: {
193+
case NodeKind.Block: {
194194
this.visitBlockStatement(<BlockStatement>node);
195195
break;
196196
}
197-
case NodeKind.BREAK: {
197+
case NodeKind.Break: {
198198
this.visitBreakStatement(<BreakStatement>node);
199199
break;
200200
}
201-
case NodeKind.CONTINUE: {
201+
case NodeKind.Continue: {
202202
this.visitContinueStatement(<ContinueStatement>node);
203203
break;
204204
}
205-
case NodeKind.DO: {
205+
case NodeKind.Do: {
206206
this.visitDoStatement(<DoStatement>node);
207207
break;
208208
}
209-
case NodeKind.EMPTY: {
209+
case NodeKind.Empty: {
210210
this.visitEmptyStatement(<EmptyStatement>node);
211211
break;
212212
}
213-
case NodeKind.EXPORT: {
213+
case NodeKind.Export: {
214214
this.visitExportStatement(<ExportStatement>node);
215215
break;
216216
}
217-
case NodeKind.EXPORTDEFAULT: {
217+
case NodeKind.ExportDefault: {
218218
this.visitExportDefaultStatement(<ExportDefaultStatement>node);
219219
break;
220220
}
221-
case NodeKind.EXPORTIMPORT: {
221+
case NodeKind.ExportImport: {
222222
this.visitExportImportStatement(<ExportImportStatement>node);
223223
break;
224224
}
225-
case NodeKind.EXPRESSION: {
225+
case NodeKind.Expression: {
226226
this.visitExpressionStatement(<ExpressionStatement>node);
227227
break;
228228
}
229-
case NodeKind.FOR: {
229+
case NodeKind.For: {
230230
this.visitForStatement(<ForStatement>node);
231231
break;
232232
}
233-
case NodeKind.IF: {
233+
case NodeKind.If: {
234234
this.visitIfStatement(<IfStatement>node);
235235
break;
236236
}
237-
case NodeKind.IMPORT: {
237+
case NodeKind.Import: {
238238
this.visitImportStatement(<ImportStatement>node);
239239
break;
240240
}
241-
case NodeKind.RETURN: {
241+
case NodeKind.Return: {
242242
this.visitReturnStatement(<ReturnStatement>node);
243243
break;
244244
}
245-
case NodeKind.SWITCH: {
245+
case NodeKind.Switch: {
246246
this.visitSwitchStatement(<SwitchStatement>node);
247247
break;
248248
}
249-
case NodeKind.THROW: {
249+
case NodeKind.Throw: {
250250
this.visitThrowStatement(<ThrowStatement>node);
251251
break;
252252
}
253-
case NodeKind.TRY: {
253+
case NodeKind.Try: {
254254
this.visitTryStatement(<TryStatement>node);
255255
break;
256256
}
257-
case NodeKind.VARIABLE: {
257+
case NodeKind.Variable: {
258258
this.visitVariableStatement(<VariableStatement>node);
259259
break;
260260
}
261-
case NodeKind.WHILE: {
261+
case NodeKind.While: {
262262
this.visitWhileStatement(<WhileStatement>node);
263263
break;
264264
}
265265

266266
// declaration statements
267267

268-
case NodeKind.CLASSDECLARATION: {
268+
case NodeKind.ClassDeclaration: {
269269
this.visitClassDeclaration(<ClassDeclaration>node);
270270
break;
271271
}
272-
case NodeKind.ENUMDECLARATION: {
272+
case NodeKind.EnumDeclaration: {
273273
this.visitEnumDeclaration(<EnumDeclaration>node);
274274
break;
275275
}
276-
case NodeKind.ENUMVALUEDECLARATION: {
276+
case NodeKind.EnumValueDeclaration: {
277277
this.visitEnumValueDeclaration(<EnumValueDeclaration>node);
278278
break;
279279
}
280-
case NodeKind.FIELDDECLARATION: {
280+
case NodeKind.FieldDeclaration: {
281281
this.visitFieldDeclaration(<FieldDeclaration>node);
282282
break;
283283
}
284-
case NodeKind.FUNCTIONDECLARATION: {
284+
case NodeKind.FunctionDeclaration: {
285285
this.visitFunctionDeclaration(<FunctionDeclaration>node);
286286
break;
287287
}
288-
case NodeKind.IMPORTDECLARATION: {
288+
case NodeKind.ImportDeclaration: {
289289
this.visitImportDeclaration(<ImportDeclaration>node);
290290
break;
291291
}
292-
case NodeKind.INTERFACEDECLARATION: {
292+
case NodeKind.InterfaceDeclaration: {
293293
this.visitInterfaceDeclaration(<InterfaceDeclaration>node);
294294
break;
295295
}
296-
case NodeKind.METHODDECLARATION: {
296+
case NodeKind.MethodDeclaration: {
297297
this.visitMethodDeclaration(<MethodDeclaration>node);
298298
break;
299299
}
300-
case NodeKind.NAMESPACEDECLARATION: {
300+
case NodeKind.NamespaceDeclaration: {
301301
this.visitNamespaceDeclaration(<NamespaceDeclaration>node);
302302
break;
303303
}
304-
case NodeKind.TYPEDECLARATION: {
304+
case NodeKind.TypeDeclaration: {
305305
this.visitTypeDeclaration(<TypeDeclaration>node);
306306
break;
307307
}
308-
case NodeKind.VARIABLEDECLARATION: {
308+
case NodeKind.VariableDeclaration: {
309309
this.visitVariableDeclaration(<VariableDeclaration>node);
310310
break;
311311
}
312312

313313
// other
314314

315-
case NodeKind.DECORATOR: {
315+
case NodeKind.Decorator: {
316316
this.visitDecoratorNode(<DecoratorNode>node);
317317
break;
318318
}
319-
case NodeKind.EXPORTMEMBER: {
319+
case NodeKind.ExportMember: {
320320
this.visitExportMember(<ExportMember>node);
321321
break;
322322
}
323-
case NodeKind.PARAMETER: {
323+
case NodeKind.Parameter: {
324324
this.visitParameter(<ParameterNode>node);
325325
break;
326326
}
327-
case NodeKind.SWITCHCASE: {
327+
case NodeKind.SwitchCase: {
328328
this.visitSwitchCase(<SwitchCase>node);
329329
break;
330330
}
331-
case NodeKind.INDEXSIGNATURE: {
331+
case NodeKind.IndexSignature: {
332332
this.visitIndexSignature(<IndexSignatureNode>node);
333333
break;
334334
}
@@ -419,39 +419,39 @@ export class BaseVisitor extends AbstractVisitor<Node> {
419419

420420
visitLiteralExpression(node: LiteralExpression): void {
421421
switch (node.literalKind) {
422-
case LiteralKind.FLOAT: {
422+
case LiteralKind.Float: {
423423
this.visitFloatLiteralExpression(<FloatLiteralExpression>node);
424424
break;
425425
}
426-
case LiteralKind.INTEGER: {
426+
case LiteralKind.Integer: {
427427
this.visitIntegerLiteralExpression(
428428
<IntegerLiteralExpression>node
429429
);
430430
break;
431431
}
432-
case LiteralKind.STRING: {
432+
case LiteralKind.String: {
433433
this.visitStringLiteralExpression(
434434
<StringLiteralExpression>node
435435
);
436436
break;
437437
}
438-
case LiteralKind.TEMPLATE: {
438+
case LiteralKind.Template: {
439439
this.visitTemplateLiteralExpression(
440440
<TemplateLiteralExpression>node
441441
);
442442
break;
443443
}
444-
case LiteralKind.REGEXP: {
444+
case LiteralKind.RegExp: {
445445
this.visitRegexpLiteralExpression(
446446
<RegexpLiteralExpression>node
447447
);
448448
break;
449449
}
450-
case LiteralKind.ARRAY: {
450+
case LiteralKind.Array: {
451451
this.visitArrayLiteralExpression(<ArrayLiteralExpression>node);
452452
break;
453453
}
454-
case LiteralKind.OBJECT: {
454+
case LiteralKind.Object: {
455455
this.visitObjectLiteralExpression(
456456
<ObjectLiteralExpression>node
457457
);
@@ -560,7 +560,7 @@ export class BaseVisitor extends AbstractVisitor<Node> {
560560

561561
visitDoStatement(node: DoStatement): void {
562562
this.visit(node.condition);
563-
this.visit(node.statement);
563+
this.visit(node.body);
564564
}
565565

566566
visitEmptyStatement(node: EmptyStatement): void { }
@@ -610,7 +610,7 @@ export class BaseVisitor extends AbstractVisitor<Node> {
610610
this.visit(node.initializer);
611611
this.visit(node.condition);
612612
this.visit(node.incrementor);
613-
this.visit(node.statement);
613+
this.visit(node.body);
614614
}
615615

616616
visitFunctionDeclaration(
@@ -701,7 +701,7 @@ export class BaseVisitor extends AbstractVisitor<Node> {
701701
}
702702

703703
visitTryStatement(node: TryStatement): void {
704-
this.visit(node.statements);
704+
this.visit(node.bodyStatements);
705705
this.visit(node.catchVariable);
706706
this.visit(node.catchStatements);
707707
this.visit(node.finallyStatements);
@@ -728,7 +728,7 @@ export class BaseVisitor extends AbstractVisitor<Node> {
728728
visitWhileStatement(node: WhileStatement): void {
729729
this.visit(node.condition);
730730
this.depth++;
731-
this.visit(node.statement);
731+
this.visit(node.body);
732732
this.depth--;
733733
}
734734

0 commit comments

Comments
 (0)