• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1"use strict";
2
3Object.defineProperty(exports, "__esModule", {
4  value: true
5});
6exports.assertArrayExpression = assertArrayExpression;
7exports.assertAssignmentExpression = assertAssignmentExpression;
8exports.assertBinaryExpression = assertBinaryExpression;
9exports.assertInterpreterDirective = assertInterpreterDirective;
10exports.assertDirective = assertDirective;
11exports.assertDirectiveLiteral = assertDirectiveLiteral;
12exports.assertBlockStatement = assertBlockStatement;
13exports.assertBreakStatement = assertBreakStatement;
14exports.assertCallExpression = assertCallExpression;
15exports.assertCatchClause = assertCatchClause;
16exports.assertConditionalExpression = assertConditionalExpression;
17exports.assertContinueStatement = assertContinueStatement;
18exports.assertDebuggerStatement = assertDebuggerStatement;
19exports.assertDoWhileStatement = assertDoWhileStatement;
20exports.assertEmptyStatement = assertEmptyStatement;
21exports.assertExpressionStatement = assertExpressionStatement;
22exports.assertFile = assertFile;
23exports.assertForInStatement = assertForInStatement;
24exports.assertForStatement = assertForStatement;
25exports.assertFunctionDeclaration = assertFunctionDeclaration;
26exports.assertFunctionExpression = assertFunctionExpression;
27exports.assertIdentifier = assertIdentifier;
28exports.assertIfStatement = assertIfStatement;
29exports.assertLabeledStatement = assertLabeledStatement;
30exports.assertStringLiteral = assertStringLiteral;
31exports.assertNumericLiteral = assertNumericLiteral;
32exports.assertNullLiteral = assertNullLiteral;
33exports.assertBooleanLiteral = assertBooleanLiteral;
34exports.assertRegExpLiteral = assertRegExpLiteral;
35exports.assertLogicalExpression = assertLogicalExpression;
36exports.assertMemberExpression = assertMemberExpression;
37exports.assertNewExpression = assertNewExpression;
38exports.assertProgram = assertProgram;
39exports.assertObjectExpression = assertObjectExpression;
40exports.assertObjectMethod = assertObjectMethod;
41exports.assertObjectProperty = assertObjectProperty;
42exports.assertRestElement = assertRestElement;
43exports.assertReturnStatement = assertReturnStatement;
44exports.assertSequenceExpression = assertSequenceExpression;
45exports.assertParenthesizedExpression = assertParenthesizedExpression;
46exports.assertSwitchCase = assertSwitchCase;
47exports.assertSwitchStatement = assertSwitchStatement;
48exports.assertThisExpression = assertThisExpression;
49exports.assertThrowStatement = assertThrowStatement;
50exports.assertTryStatement = assertTryStatement;
51exports.assertUnaryExpression = assertUnaryExpression;
52exports.assertUpdateExpression = assertUpdateExpression;
53exports.assertVariableDeclaration = assertVariableDeclaration;
54exports.assertVariableDeclarator = assertVariableDeclarator;
55exports.assertWhileStatement = assertWhileStatement;
56exports.assertWithStatement = assertWithStatement;
57exports.assertAssignmentPattern = assertAssignmentPattern;
58exports.assertArrayPattern = assertArrayPattern;
59exports.assertArrowFunctionExpression = assertArrowFunctionExpression;
60exports.assertClassBody = assertClassBody;
61exports.assertClassDeclaration = assertClassDeclaration;
62exports.assertClassExpression = assertClassExpression;
63exports.assertExportAllDeclaration = assertExportAllDeclaration;
64exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration;
65exports.assertExportNamedDeclaration = assertExportNamedDeclaration;
66exports.assertExportSpecifier = assertExportSpecifier;
67exports.assertForOfStatement = assertForOfStatement;
68exports.assertImportDeclaration = assertImportDeclaration;
69exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier;
70exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier;
71exports.assertImportSpecifier = assertImportSpecifier;
72exports.assertMetaProperty = assertMetaProperty;
73exports.assertClassMethod = assertClassMethod;
74exports.assertObjectPattern = assertObjectPattern;
75exports.assertSpreadElement = assertSpreadElement;
76exports.assertSuper = assertSuper;
77exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression;
78exports.assertTemplateElement = assertTemplateElement;
79exports.assertTemplateLiteral = assertTemplateLiteral;
80exports.assertYieldExpression = assertYieldExpression;
81exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation;
82exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation;
83exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation;
84exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation;
85exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation;
86exports.assertClassImplements = assertClassImplements;
87exports.assertDeclareClass = assertDeclareClass;
88exports.assertDeclareFunction = assertDeclareFunction;
89exports.assertDeclareInterface = assertDeclareInterface;
90exports.assertDeclareModule = assertDeclareModule;
91exports.assertDeclareModuleExports = assertDeclareModuleExports;
92exports.assertDeclareTypeAlias = assertDeclareTypeAlias;
93exports.assertDeclareOpaqueType = assertDeclareOpaqueType;
94exports.assertDeclareVariable = assertDeclareVariable;
95exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration;
96exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration;
97exports.assertDeclaredPredicate = assertDeclaredPredicate;
98exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation;
99exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;
100exports.assertFunctionTypeParam = assertFunctionTypeParam;
101exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation;
102exports.assertInferredPredicate = assertInferredPredicate;
103exports.assertInterfaceExtends = assertInterfaceExtends;
104exports.assertInterfaceDeclaration = assertInterfaceDeclaration;
105exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation;
106exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;
107exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation;
108exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;
109exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation;
110exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;
111exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation;
112exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation;
113exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot;
114exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty;
115exports.assertObjectTypeIndexer = assertObjectTypeIndexer;
116exports.assertObjectTypeProperty = assertObjectTypeProperty;
117exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;
118exports.assertOpaqueType = assertOpaqueType;
119exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
120exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
121exports.assertStringTypeAnnotation = assertStringTypeAnnotation;
122exports.assertThisTypeAnnotation = assertThisTypeAnnotation;
123exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation;
124exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;
125exports.assertTypeAlias = assertTypeAlias;
126exports.assertTypeAnnotation = assertTypeAnnotation;
127exports.assertTypeCastExpression = assertTypeCastExpression;
128exports.assertTypeParameter = assertTypeParameter;
129exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration;
130exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation;
131exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation;
132exports.assertVariance = assertVariance;
133exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation;
134exports.assertJSXAttribute = assertJSXAttribute;
135exports.assertJSXClosingElement = assertJSXClosingElement;
136exports.assertJSXElement = assertJSXElement;
137exports.assertJSXEmptyExpression = assertJSXEmptyExpression;
138exports.assertJSXExpressionContainer = assertJSXExpressionContainer;
139exports.assertJSXSpreadChild = assertJSXSpreadChild;
140exports.assertJSXIdentifier = assertJSXIdentifier;
141exports.assertJSXMemberExpression = assertJSXMemberExpression;
142exports.assertJSXNamespacedName = assertJSXNamespacedName;
143exports.assertJSXOpeningElement = assertJSXOpeningElement;
144exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute;
145exports.assertJSXText = assertJSXText;
146exports.assertJSXFragment = assertJSXFragment;
147exports.assertJSXOpeningFragment = assertJSXOpeningFragment;
148exports.assertJSXClosingFragment = assertJSXClosingFragment;
149exports.assertNoop = assertNoop;
150exports.assertPlaceholder = assertPlaceholder;
151exports.assertArgumentPlaceholder = assertArgumentPlaceholder;
152exports.assertAwaitExpression = assertAwaitExpression;
153exports.assertBindExpression = assertBindExpression;
154exports.assertClassProperty = assertClassProperty;
155exports.assertOptionalMemberExpression = assertOptionalMemberExpression;
156exports.assertPipelineTopicExpression = assertPipelineTopicExpression;
157exports.assertPipelineBareFunction = assertPipelineBareFunction;
158exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference;
159exports.assertOptionalCallExpression = assertOptionalCallExpression;
160exports.assertClassPrivateProperty = assertClassPrivateProperty;
161exports.assertClassPrivateMethod = assertClassPrivateMethod;
162exports.assertImport = assertImport;
163exports.assertDecorator = assertDecorator;
164exports.assertDoExpression = assertDoExpression;
165exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
166exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
167exports.assertPrivateName = assertPrivateName;
168exports.assertBigIntLiteral = assertBigIntLiteral;
169exports.assertTSParameterProperty = assertTSParameterProperty;
170exports.assertTSDeclareFunction = assertTSDeclareFunction;
171exports.assertTSDeclareMethod = assertTSDeclareMethod;
172exports.assertTSQualifiedName = assertTSQualifiedName;
173exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;
174exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;
175exports.assertTSPropertySignature = assertTSPropertySignature;
176exports.assertTSMethodSignature = assertTSMethodSignature;
177exports.assertTSIndexSignature = assertTSIndexSignature;
178exports.assertTSAnyKeyword = assertTSAnyKeyword;
179exports.assertTSUnknownKeyword = assertTSUnknownKeyword;
180exports.assertTSNumberKeyword = assertTSNumberKeyword;
181exports.assertTSObjectKeyword = assertTSObjectKeyword;
182exports.assertTSBooleanKeyword = assertTSBooleanKeyword;
183exports.assertTSStringKeyword = assertTSStringKeyword;
184exports.assertTSSymbolKeyword = assertTSSymbolKeyword;
185exports.assertTSVoidKeyword = assertTSVoidKeyword;
186exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword;
187exports.assertTSNullKeyword = assertTSNullKeyword;
188exports.assertTSNeverKeyword = assertTSNeverKeyword;
189exports.assertTSThisType = assertTSThisType;
190exports.assertTSFunctionType = assertTSFunctionType;
191exports.assertTSConstructorType = assertTSConstructorType;
192exports.assertTSTypeReference = assertTSTypeReference;
193exports.assertTSTypePredicate = assertTSTypePredicate;
194exports.assertTSTypeQuery = assertTSTypeQuery;
195exports.assertTSTypeLiteral = assertTSTypeLiteral;
196exports.assertTSArrayType = assertTSArrayType;
197exports.assertTSTupleType = assertTSTupleType;
198exports.assertTSOptionalType = assertTSOptionalType;
199exports.assertTSRestType = assertTSRestType;
200exports.assertTSUnionType = assertTSUnionType;
201exports.assertTSIntersectionType = assertTSIntersectionType;
202exports.assertTSConditionalType = assertTSConditionalType;
203exports.assertTSInferType = assertTSInferType;
204exports.assertTSParenthesizedType = assertTSParenthesizedType;
205exports.assertTSTypeOperator = assertTSTypeOperator;
206exports.assertTSIndexedAccessType = assertTSIndexedAccessType;
207exports.assertTSMappedType = assertTSMappedType;
208exports.assertTSLiteralType = assertTSLiteralType;
209exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments;
210exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration;
211exports.assertTSInterfaceBody = assertTSInterfaceBody;
212exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration;
213exports.assertTSAsExpression = assertTSAsExpression;
214exports.assertTSTypeAssertion = assertTSTypeAssertion;
215exports.assertTSEnumDeclaration = assertTSEnumDeclaration;
216exports.assertTSEnumMember = assertTSEnumMember;
217exports.assertTSModuleDeclaration = assertTSModuleDeclaration;
218exports.assertTSModuleBlock = assertTSModuleBlock;
219exports.assertTSImportType = assertTSImportType;
220exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration;
221exports.assertTSExternalModuleReference = assertTSExternalModuleReference;
222exports.assertTSNonNullExpression = assertTSNonNullExpression;
223exports.assertTSExportAssignment = assertTSExportAssignment;
224exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration;
225exports.assertTSTypeAnnotation = assertTSTypeAnnotation;
226exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation;
227exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration;
228exports.assertTSTypeParameter = assertTSTypeParameter;
229exports.assertExpression = assertExpression;
230exports.assertBinary = assertBinary;
231exports.assertScopable = assertScopable;
232exports.assertBlockParent = assertBlockParent;
233exports.assertBlock = assertBlock;
234exports.assertStatement = assertStatement;
235exports.assertTerminatorless = assertTerminatorless;
236exports.assertCompletionStatement = assertCompletionStatement;
237exports.assertConditional = assertConditional;
238exports.assertLoop = assertLoop;
239exports.assertWhile = assertWhile;
240exports.assertExpressionWrapper = assertExpressionWrapper;
241exports.assertFor = assertFor;
242exports.assertForXStatement = assertForXStatement;
243exports.assertFunction = assertFunction;
244exports.assertFunctionParent = assertFunctionParent;
245exports.assertPureish = assertPureish;
246exports.assertDeclaration = assertDeclaration;
247exports.assertPatternLike = assertPatternLike;
248exports.assertLVal = assertLVal;
249exports.assertTSEntityName = assertTSEntityName;
250exports.assertLiteral = assertLiteral;
251exports.assertImmutable = assertImmutable;
252exports.assertUserWhitespacable = assertUserWhitespacable;
253exports.assertMethod = assertMethod;
254exports.assertObjectMember = assertObjectMember;
255exports.assertProperty = assertProperty;
256exports.assertUnaryLike = assertUnaryLike;
257exports.assertPattern = assertPattern;
258exports.assertClass = assertClass;
259exports.assertModuleDeclaration = assertModuleDeclaration;
260exports.assertExportDeclaration = assertExportDeclaration;
261exports.assertModuleSpecifier = assertModuleSpecifier;
262exports.assertFlow = assertFlow;
263exports.assertFlowType = assertFlowType;
264exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation;
265exports.assertFlowDeclaration = assertFlowDeclaration;
266exports.assertFlowPredicate = assertFlowPredicate;
267exports.assertJSX = assertJSX;
268exports.assertPrivate = assertPrivate;
269exports.assertTSTypeElement = assertTSTypeElement;
270exports.assertTSType = assertTSType;
271exports.assertNumberLiteral = assertNumberLiteral;
272exports.assertRegexLiteral = assertRegexLiteral;
273exports.assertRestProperty = assertRestProperty;
274exports.assertSpreadProperty = assertSpreadProperty;
275
276var _is = _interopRequireDefault(require("../../validators/is"));
277
278function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
279
280function assert(type, node, opts) {
281  if (!(0, _is.default)(type, node, opts)) {
282    throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, but instead got "${node.type}".`);
283  }
284}
285
286function assertArrayExpression(node, opts = {}) {
287  assert("ArrayExpression", node, opts);
288}
289
290function assertAssignmentExpression(node, opts = {}) {
291  assert("AssignmentExpression", node, opts);
292}
293
294function assertBinaryExpression(node, opts = {}) {
295  assert("BinaryExpression", node, opts);
296}
297
298function assertInterpreterDirective(node, opts = {}) {
299  assert("InterpreterDirective", node, opts);
300}
301
302function assertDirective(node, opts = {}) {
303  assert("Directive", node, opts);
304}
305
306function assertDirectiveLiteral(node, opts = {}) {
307  assert("DirectiveLiteral", node, opts);
308}
309
310function assertBlockStatement(node, opts = {}) {
311  assert("BlockStatement", node, opts);
312}
313
314function assertBreakStatement(node, opts = {}) {
315  assert("BreakStatement", node, opts);
316}
317
318function assertCallExpression(node, opts = {}) {
319  assert("CallExpression", node, opts);
320}
321
322function assertCatchClause(node, opts = {}) {
323  assert("CatchClause", node, opts);
324}
325
326function assertConditionalExpression(node, opts = {}) {
327  assert("ConditionalExpression", node, opts);
328}
329
330function assertContinueStatement(node, opts = {}) {
331  assert("ContinueStatement", node, opts);
332}
333
334function assertDebuggerStatement(node, opts = {}) {
335  assert("DebuggerStatement", node, opts);
336}
337
338function assertDoWhileStatement(node, opts = {}) {
339  assert("DoWhileStatement", node, opts);
340}
341
342function assertEmptyStatement(node, opts = {}) {
343  assert("EmptyStatement", node, opts);
344}
345
346function assertExpressionStatement(node, opts = {}) {
347  assert("ExpressionStatement", node, opts);
348}
349
350function assertFile(node, opts = {}) {
351  assert("File", node, opts);
352}
353
354function assertForInStatement(node, opts = {}) {
355  assert("ForInStatement", node, opts);
356}
357
358function assertForStatement(node, opts = {}) {
359  assert("ForStatement", node, opts);
360}
361
362function assertFunctionDeclaration(node, opts = {}) {
363  assert("FunctionDeclaration", node, opts);
364}
365
366function assertFunctionExpression(node, opts = {}) {
367  assert("FunctionExpression", node, opts);
368}
369
370function assertIdentifier(node, opts = {}) {
371  assert("Identifier", node, opts);
372}
373
374function assertIfStatement(node, opts = {}) {
375  assert("IfStatement", node, opts);
376}
377
378function assertLabeledStatement(node, opts = {}) {
379  assert("LabeledStatement", node, opts);
380}
381
382function assertStringLiteral(node, opts = {}) {
383  assert("StringLiteral", node, opts);
384}
385
386function assertNumericLiteral(node, opts = {}) {
387  assert("NumericLiteral", node, opts);
388}
389
390function assertNullLiteral(node, opts = {}) {
391  assert("NullLiteral", node, opts);
392}
393
394function assertBooleanLiteral(node, opts = {}) {
395  assert("BooleanLiteral", node, opts);
396}
397
398function assertRegExpLiteral(node, opts = {}) {
399  assert("RegExpLiteral", node, opts);
400}
401
402function assertLogicalExpression(node, opts = {}) {
403  assert("LogicalExpression", node, opts);
404}
405
406function assertMemberExpression(node, opts = {}) {
407  assert("MemberExpression", node, opts);
408}
409
410function assertNewExpression(node, opts = {}) {
411  assert("NewExpression", node, opts);
412}
413
414function assertProgram(node, opts = {}) {
415  assert("Program", node, opts);
416}
417
418function assertObjectExpression(node, opts = {}) {
419  assert("ObjectExpression", node, opts);
420}
421
422function assertObjectMethod(node, opts = {}) {
423  assert("ObjectMethod", node, opts);
424}
425
426function assertObjectProperty(node, opts = {}) {
427  assert("ObjectProperty", node, opts);
428}
429
430function assertRestElement(node, opts = {}) {
431  assert("RestElement", node, opts);
432}
433
434function assertReturnStatement(node, opts = {}) {
435  assert("ReturnStatement", node, opts);
436}
437
438function assertSequenceExpression(node, opts = {}) {
439  assert("SequenceExpression", node, opts);
440}
441
442function assertParenthesizedExpression(node, opts = {}) {
443  assert("ParenthesizedExpression", node, opts);
444}
445
446function assertSwitchCase(node, opts = {}) {
447  assert("SwitchCase", node, opts);
448}
449
450function assertSwitchStatement(node, opts = {}) {
451  assert("SwitchStatement", node, opts);
452}
453
454function assertThisExpression(node, opts = {}) {
455  assert("ThisExpression", node, opts);
456}
457
458function assertThrowStatement(node, opts = {}) {
459  assert("ThrowStatement", node, opts);
460}
461
462function assertTryStatement(node, opts = {}) {
463  assert("TryStatement", node, opts);
464}
465
466function assertUnaryExpression(node, opts = {}) {
467  assert("UnaryExpression", node, opts);
468}
469
470function assertUpdateExpression(node, opts = {}) {
471  assert("UpdateExpression", node, opts);
472}
473
474function assertVariableDeclaration(node, opts = {}) {
475  assert("VariableDeclaration", node, opts);
476}
477
478function assertVariableDeclarator(node, opts = {}) {
479  assert("VariableDeclarator", node, opts);
480}
481
482function assertWhileStatement(node, opts = {}) {
483  assert("WhileStatement", node, opts);
484}
485
486function assertWithStatement(node, opts = {}) {
487  assert("WithStatement", node, opts);
488}
489
490function assertAssignmentPattern(node, opts = {}) {
491  assert("AssignmentPattern", node, opts);
492}
493
494function assertArrayPattern(node, opts = {}) {
495  assert("ArrayPattern", node, opts);
496}
497
498function assertArrowFunctionExpression(node, opts = {}) {
499  assert("ArrowFunctionExpression", node, opts);
500}
501
502function assertClassBody(node, opts = {}) {
503  assert("ClassBody", node, opts);
504}
505
506function assertClassDeclaration(node, opts = {}) {
507  assert("ClassDeclaration", node, opts);
508}
509
510function assertClassExpression(node, opts = {}) {
511  assert("ClassExpression", node, opts);
512}
513
514function assertExportAllDeclaration(node, opts = {}) {
515  assert("ExportAllDeclaration", node, opts);
516}
517
518function assertExportDefaultDeclaration(node, opts = {}) {
519  assert("ExportDefaultDeclaration", node, opts);
520}
521
522function assertExportNamedDeclaration(node, opts = {}) {
523  assert("ExportNamedDeclaration", node, opts);
524}
525
526function assertExportSpecifier(node, opts = {}) {
527  assert("ExportSpecifier", node, opts);
528}
529
530function assertForOfStatement(node, opts = {}) {
531  assert("ForOfStatement", node, opts);
532}
533
534function assertImportDeclaration(node, opts = {}) {
535  assert("ImportDeclaration", node, opts);
536}
537
538function assertImportDefaultSpecifier(node, opts = {}) {
539  assert("ImportDefaultSpecifier", node, opts);
540}
541
542function assertImportNamespaceSpecifier(node, opts = {}) {
543  assert("ImportNamespaceSpecifier", node, opts);
544}
545
546function assertImportSpecifier(node, opts = {}) {
547  assert("ImportSpecifier", node, opts);
548}
549
550function assertMetaProperty(node, opts = {}) {
551  assert("MetaProperty", node, opts);
552}
553
554function assertClassMethod(node, opts = {}) {
555  assert("ClassMethod", node, opts);
556}
557
558function assertObjectPattern(node, opts = {}) {
559  assert("ObjectPattern", node, opts);
560}
561
562function assertSpreadElement(node, opts = {}) {
563  assert("SpreadElement", node, opts);
564}
565
566function assertSuper(node, opts = {}) {
567  assert("Super", node, opts);
568}
569
570function assertTaggedTemplateExpression(node, opts = {}) {
571  assert("TaggedTemplateExpression", node, opts);
572}
573
574function assertTemplateElement(node, opts = {}) {
575  assert("TemplateElement", node, opts);
576}
577
578function assertTemplateLiteral(node, opts = {}) {
579  assert("TemplateLiteral", node, opts);
580}
581
582function assertYieldExpression(node, opts = {}) {
583  assert("YieldExpression", node, opts);
584}
585
586function assertAnyTypeAnnotation(node, opts = {}) {
587  assert("AnyTypeAnnotation", node, opts);
588}
589
590function assertArrayTypeAnnotation(node, opts = {}) {
591  assert("ArrayTypeAnnotation", node, opts);
592}
593
594function assertBooleanTypeAnnotation(node, opts = {}) {
595  assert("BooleanTypeAnnotation", node, opts);
596}
597
598function assertBooleanLiteralTypeAnnotation(node, opts = {}) {
599  assert("BooleanLiteralTypeAnnotation", node, opts);
600}
601
602function assertNullLiteralTypeAnnotation(node, opts = {}) {
603  assert("NullLiteralTypeAnnotation", node, opts);
604}
605
606function assertClassImplements(node, opts = {}) {
607  assert("ClassImplements", node, opts);
608}
609
610function assertDeclareClass(node, opts = {}) {
611  assert("DeclareClass", node, opts);
612}
613
614function assertDeclareFunction(node, opts = {}) {
615  assert("DeclareFunction", node, opts);
616}
617
618function assertDeclareInterface(node, opts = {}) {
619  assert("DeclareInterface", node, opts);
620}
621
622function assertDeclareModule(node, opts = {}) {
623  assert("DeclareModule", node, opts);
624}
625
626function assertDeclareModuleExports(node, opts = {}) {
627  assert("DeclareModuleExports", node, opts);
628}
629
630function assertDeclareTypeAlias(node, opts = {}) {
631  assert("DeclareTypeAlias", node, opts);
632}
633
634function assertDeclareOpaqueType(node, opts = {}) {
635  assert("DeclareOpaqueType", node, opts);
636}
637
638function assertDeclareVariable(node, opts = {}) {
639  assert("DeclareVariable", node, opts);
640}
641
642function assertDeclareExportDeclaration(node, opts = {}) {
643  assert("DeclareExportDeclaration", node, opts);
644}
645
646function assertDeclareExportAllDeclaration(node, opts = {}) {
647  assert("DeclareExportAllDeclaration", node, opts);
648}
649
650function assertDeclaredPredicate(node, opts = {}) {
651  assert("DeclaredPredicate", node, opts);
652}
653
654function assertExistsTypeAnnotation(node, opts = {}) {
655  assert("ExistsTypeAnnotation", node, opts);
656}
657
658function assertFunctionTypeAnnotation(node, opts = {}) {
659  assert("FunctionTypeAnnotation", node, opts);
660}
661
662function assertFunctionTypeParam(node, opts = {}) {
663  assert("FunctionTypeParam", node, opts);
664}
665
666function assertGenericTypeAnnotation(node, opts = {}) {
667  assert("GenericTypeAnnotation", node, opts);
668}
669
670function assertInferredPredicate(node, opts = {}) {
671  assert("InferredPredicate", node, opts);
672}
673
674function assertInterfaceExtends(node, opts = {}) {
675  assert("InterfaceExtends", node, opts);
676}
677
678function assertInterfaceDeclaration(node, opts = {}) {
679  assert("InterfaceDeclaration", node, opts);
680}
681
682function assertInterfaceTypeAnnotation(node, opts = {}) {
683  assert("InterfaceTypeAnnotation", node, opts);
684}
685
686function assertIntersectionTypeAnnotation(node, opts = {}) {
687  assert("IntersectionTypeAnnotation", node, opts);
688}
689
690function assertMixedTypeAnnotation(node, opts = {}) {
691  assert("MixedTypeAnnotation", node, opts);
692}
693
694function assertEmptyTypeAnnotation(node, opts = {}) {
695  assert("EmptyTypeAnnotation", node, opts);
696}
697
698function assertNullableTypeAnnotation(node, opts = {}) {
699  assert("NullableTypeAnnotation", node, opts);
700}
701
702function assertNumberLiteralTypeAnnotation(node, opts = {}) {
703  assert("NumberLiteralTypeAnnotation", node, opts);
704}
705
706function assertNumberTypeAnnotation(node, opts = {}) {
707  assert("NumberTypeAnnotation", node, opts);
708}
709
710function assertObjectTypeAnnotation(node, opts = {}) {
711  assert("ObjectTypeAnnotation", node, opts);
712}
713
714function assertObjectTypeInternalSlot(node, opts = {}) {
715  assert("ObjectTypeInternalSlot", node, opts);
716}
717
718function assertObjectTypeCallProperty(node, opts = {}) {
719  assert("ObjectTypeCallProperty", node, opts);
720}
721
722function assertObjectTypeIndexer(node, opts = {}) {
723  assert("ObjectTypeIndexer", node, opts);
724}
725
726function assertObjectTypeProperty(node, opts = {}) {
727  assert("ObjectTypeProperty", node, opts);
728}
729
730function assertObjectTypeSpreadProperty(node, opts = {}) {
731  assert("ObjectTypeSpreadProperty", node, opts);
732}
733
734function assertOpaqueType(node, opts = {}) {
735  assert("OpaqueType", node, opts);
736}
737
738function assertQualifiedTypeIdentifier(node, opts = {}) {
739  assert("QualifiedTypeIdentifier", node, opts);
740}
741
742function assertStringLiteralTypeAnnotation(node, opts = {}) {
743  assert("StringLiteralTypeAnnotation", node, opts);
744}
745
746function assertStringTypeAnnotation(node, opts = {}) {
747  assert("StringTypeAnnotation", node, opts);
748}
749
750function assertThisTypeAnnotation(node, opts = {}) {
751  assert("ThisTypeAnnotation", node, opts);
752}
753
754function assertTupleTypeAnnotation(node, opts = {}) {
755  assert("TupleTypeAnnotation", node, opts);
756}
757
758function assertTypeofTypeAnnotation(node, opts = {}) {
759  assert("TypeofTypeAnnotation", node, opts);
760}
761
762function assertTypeAlias(node, opts = {}) {
763  assert("TypeAlias", node, opts);
764}
765
766function assertTypeAnnotation(node, opts = {}) {
767  assert("TypeAnnotation", node, opts);
768}
769
770function assertTypeCastExpression(node, opts = {}) {
771  assert("TypeCastExpression", node, opts);
772}
773
774function assertTypeParameter(node, opts = {}) {
775  assert("TypeParameter", node, opts);
776}
777
778function assertTypeParameterDeclaration(node, opts = {}) {
779  assert("TypeParameterDeclaration", node, opts);
780}
781
782function assertTypeParameterInstantiation(node, opts = {}) {
783  assert("TypeParameterInstantiation", node, opts);
784}
785
786function assertUnionTypeAnnotation(node, opts = {}) {
787  assert("UnionTypeAnnotation", node, opts);
788}
789
790function assertVariance(node, opts = {}) {
791  assert("Variance", node, opts);
792}
793
794function assertVoidTypeAnnotation(node, opts = {}) {
795  assert("VoidTypeAnnotation", node, opts);
796}
797
798function assertJSXAttribute(node, opts = {}) {
799  assert("JSXAttribute", node, opts);
800}
801
802function assertJSXClosingElement(node, opts = {}) {
803  assert("JSXClosingElement", node, opts);
804}
805
806function assertJSXElement(node, opts = {}) {
807  assert("JSXElement", node, opts);
808}
809
810function assertJSXEmptyExpression(node, opts = {}) {
811  assert("JSXEmptyExpression", node, opts);
812}
813
814function assertJSXExpressionContainer(node, opts = {}) {
815  assert("JSXExpressionContainer", node, opts);
816}
817
818function assertJSXSpreadChild(node, opts = {}) {
819  assert("JSXSpreadChild", node, opts);
820}
821
822function assertJSXIdentifier(node, opts = {}) {
823  assert("JSXIdentifier", node, opts);
824}
825
826function assertJSXMemberExpression(node, opts = {}) {
827  assert("JSXMemberExpression", node, opts);
828}
829
830function assertJSXNamespacedName(node, opts = {}) {
831  assert("JSXNamespacedName", node, opts);
832}
833
834function assertJSXOpeningElement(node, opts = {}) {
835  assert("JSXOpeningElement", node, opts);
836}
837
838function assertJSXSpreadAttribute(node, opts = {}) {
839  assert("JSXSpreadAttribute", node, opts);
840}
841
842function assertJSXText(node, opts = {}) {
843  assert("JSXText", node, opts);
844}
845
846function assertJSXFragment(node, opts = {}) {
847  assert("JSXFragment", node, opts);
848}
849
850function assertJSXOpeningFragment(node, opts = {}) {
851  assert("JSXOpeningFragment", node, opts);
852}
853
854function assertJSXClosingFragment(node, opts = {}) {
855  assert("JSXClosingFragment", node, opts);
856}
857
858function assertNoop(node, opts = {}) {
859  assert("Noop", node, opts);
860}
861
862function assertPlaceholder(node, opts = {}) {
863  assert("Placeholder", node, opts);
864}
865
866function assertArgumentPlaceholder(node, opts = {}) {
867  assert("ArgumentPlaceholder", node, opts);
868}
869
870function assertAwaitExpression(node, opts = {}) {
871  assert("AwaitExpression", node, opts);
872}
873
874function assertBindExpression(node, opts = {}) {
875  assert("BindExpression", node, opts);
876}
877
878function assertClassProperty(node, opts = {}) {
879  assert("ClassProperty", node, opts);
880}
881
882function assertOptionalMemberExpression(node, opts = {}) {
883  assert("OptionalMemberExpression", node, opts);
884}
885
886function assertPipelineTopicExpression(node, opts = {}) {
887  assert("PipelineTopicExpression", node, opts);
888}
889
890function assertPipelineBareFunction(node, opts = {}) {
891  assert("PipelineBareFunction", node, opts);
892}
893
894function assertPipelinePrimaryTopicReference(node, opts = {}) {
895  assert("PipelinePrimaryTopicReference", node, opts);
896}
897
898function assertOptionalCallExpression(node, opts = {}) {
899  assert("OptionalCallExpression", node, opts);
900}
901
902function assertClassPrivateProperty(node, opts = {}) {
903  assert("ClassPrivateProperty", node, opts);
904}
905
906function assertClassPrivateMethod(node, opts = {}) {
907  assert("ClassPrivateMethod", node, opts);
908}
909
910function assertImport(node, opts = {}) {
911  assert("Import", node, opts);
912}
913
914function assertDecorator(node, opts = {}) {
915  assert("Decorator", node, opts);
916}
917
918function assertDoExpression(node, opts = {}) {
919  assert("DoExpression", node, opts);
920}
921
922function assertExportDefaultSpecifier(node, opts = {}) {
923  assert("ExportDefaultSpecifier", node, opts);
924}
925
926function assertExportNamespaceSpecifier(node, opts = {}) {
927  assert("ExportNamespaceSpecifier", node, opts);
928}
929
930function assertPrivateName(node, opts = {}) {
931  assert("PrivateName", node, opts);
932}
933
934function assertBigIntLiteral(node, opts = {}) {
935  assert("BigIntLiteral", node, opts);
936}
937
938function assertTSParameterProperty(node, opts = {}) {
939  assert("TSParameterProperty", node, opts);
940}
941
942function assertTSDeclareFunction(node, opts = {}) {
943  assert("TSDeclareFunction", node, opts);
944}
945
946function assertTSDeclareMethod(node, opts = {}) {
947  assert("TSDeclareMethod", node, opts);
948}
949
950function assertTSQualifiedName(node, opts = {}) {
951  assert("TSQualifiedName", node, opts);
952}
953
954function assertTSCallSignatureDeclaration(node, opts = {}) {
955  assert("TSCallSignatureDeclaration", node, opts);
956}
957
958function assertTSConstructSignatureDeclaration(node, opts = {}) {
959  assert("TSConstructSignatureDeclaration", node, opts);
960}
961
962function assertTSPropertySignature(node, opts = {}) {
963  assert("TSPropertySignature", node, opts);
964}
965
966function assertTSMethodSignature(node, opts = {}) {
967  assert("TSMethodSignature", node, opts);
968}
969
970function assertTSIndexSignature(node, opts = {}) {
971  assert("TSIndexSignature", node, opts);
972}
973
974function assertTSAnyKeyword(node, opts = {}) {
975  assert("TSAnyKeyword", node, opts);
976}
977
978function assertTSUnknownKeyword(node, opts = {}) {
979  assert("TSUnknownKeyword", node, opts);
980}
981
982function assertTSNumberKeyword(node, opts = {}) {
983  assert("TSNumberKeyword", node, opts);
984}
985
986function assertTSObjectKeyword(node, opts = {}) {
987  assert("TSObjectKeyword", node, opts);
988}
989
990function assertTSBooleanKeyword(node, opts = {}) {
991  assert("TSBooleanKeyword", node, opts);
992}
993
994function assertTSStringKeyword(node, opts = {}) {
995  assert("TSStringKeyword", node, opts);
996}
997
998function assertTSSymbolKeyword(node, opts = {}) {
999  assert("TSSymbolKeyword", node, opts);
1000}
1001
1002function assertTSVoidKeyword(node, opts = {}) {
1003  assert("TSVoidKeyword", node, opts);
1004}
1005
1006function assertTSUndefinedKeyword(node, opts = {}) {
1007  assert("TSUndefinedKeyword", node, opts);
1008}
1009
1010function assertTSNullKeyword(node, opts = {}) {
1011  assert("TSNullKeyword", node, opts);
1012}
1013
1014function assertTSNeverKeyword(node, opts = {}) {
1015  assert("TSNeverKeyword", node, opts);
1016}
1017
1018function assertTSThisType(node, opts = {}) {
1019  assert("TSThisType", node, opts);
1020}
1021
1022function assertTSFunctionType(node, opts = {}) {
1023  assert("TSFunctionType", node, opts);
1024}
1025
1026function assertTSConstructorType(node, opts = {}) {
1027  assert("TSConstructorType", node, opts);
1028}
1029
1030function assertTSTypeReference(node, opts = {}) {
1031  assert("TSTypeReference", node, opts);
1032}
1033
1034function assertTSTypePredicate(node, opts = {}) {
1035  assert("TSTypePredicate", node, opts);
1036}
1037
1038function assertTSTypeQuery(node, opts = {}) {
1039  assert("TSTypeQuery", node, opts);
1040}
1041
1042function assertTSTypeLiteral(node, opts = {}) {
1043  assert("TSTypeLiteral", node, opts);
1044}
1045
1046function assertTSArrayType(node, opts = {}) {
1047  assert("TSArrayType", node, opts);
1048}
1049
1050function assertTSTupleType(node, opts = {}) {
1051  assert("TSTupleType", node, opts);
1052}
1053
1054function assertTSOptionalType(node, opts = {}) {
1055  assert("TSOptionalType", node, opts);
1056}
1057
1058function assertTSRestType(node, opts = {}) {
1059  assert("TSRestType", node, opts);
1060}
1061
1062function assertTSUnionType(node, opts = {}) {
1063  assert("TSUnionType", node, opts);
1064}
1065
1066function assertTSIntersectionType(node, opts = {}) {
1067  assert("TSIntersectionType", node, opts);
1068}
1069
1070function assertTSConditionalType(node, opts = {}) {
1071  assert("TSConditionalType", node, opts);
1072}
1073
1074function assertTSInferType(node, opts = {}) {
1075  assert("TSInferType", node, opts);
1076}
1077
1078function assertTSParenthesizedType(node, opts = {}) {
1079  assert("TSParenthesizedType", node, opts);
1080}
1081
1082function assertTSTypeOperator(node, opts = {}) {
1083  assert("TSTypeOperator", node, opts);
1084}
1085
1086function assertTSIndexedAccessType(node, opts = {}) {
1087  assert("TSIndexedAccessType", node, opts);
1088}
1089
1090function assertTSMappedType(node, opts = {}) {
1091  assert("TSMappedType", node, opts);
1092}
1093
1094function assertTSLiteralType(node, opts = {}) {
1095  assert("TSLiteralType", node, opts);
1096}
1097
1098function assertTSExpressionWithTypeArguments(node, opts = {}) {
1099  assert("TSExpressionWithTypeArguments", node, opts);
1100}
1101
1102function assertTSInterfaceDeclaration(node, opts = {}) {
1103  assert("TSInterfaceDeclaration", node, opts);
1104}
1105
1106function assertTSInterfaceBody(node, opts = {}) {
1107  assert("TSInterfaceBody", node, opts);
1108}
1109
1110function assertTSTypeAliasDeclaration(node, opts = {}) {
1111  assert("TSTypeAliasDeclaration", node, opts);
1112}
1113
1114function assertTSAsExpression(node, opts = {}) {
1115  assert("TSAsExpression", node, opts);
1116}
1117
1118function assertTSTypeAssertion(node, opts = {}) {
1119  assert("TSTypeAssertion", node, opts);
1120}
1121
1122function assertTSEnumDeclaration(node, opts = {}) {
1123  assert("TSEnumDeclaration", node, opts);
1124}
1125
1126function assertTSEnumMember(node, opts = {}) {
1127  assert("TSEnumMember", node, opts);
1128}
1129
1130function assertTSModuleDeclaration(node, opts = {}) {
1131  assert("TSModuleDeclaration", node, opts);
1132}
1133
1134function assertTSModuleBlock(node, opts = {}) {
1135  assert("TSModuleBlock", node, opts);
1136}
1137
1138function assertTSImportType(node, opts = {}) {
1139  assert("TSImportType", node, opts);
1140}
1141
1142function assertTSImportEqualsDeclaration(node, opts = {}) {
1143  assert("TSImportEqualsDeclaration", node, opts);
1144}
1145
1146function assertTSExternalModuleReference(node, opts = {}) {
1147  assert("TSExternalModuleReference", node, opts);
1148}
1149
1150function assertTSNonNullExpression(node, opts = {}) {
1151  assert("TSNonNullExpression", node, opts);
1152}
1153
1154function assertTSExportAssignment(node, opts = {}) {
1155  assert("TSExportAssignment", node, opts);
1156}
1157
1158function assertTSNamespaceExportDeclaration(node, opts = {}) {
1159  assert("TSNamespaceExportDeclaration", node, opts);
1160}
1161
1162function assertTSTypeAnnotation(node, opts = {}) {
1163  assert("TSTypeAnnotation", node, opts);
1164}
1165
1166function assertTSTypeParameterInstantiation(node, opts = {}) {
1167  assert("TSTypeParameterInstantiation", node, opts);
1168}
1169
1170function assertTSTypeParameterDeclaration(node, opts = {}) {
1171  assert("TSTypeParameterDeclaration", node, opts);
1172}
1173
1174function assertTSTypeParameter(node, opts = {}) {
1175  assert("TSTypeParameter", node, opts);
1176}
1177
1178function assertExpression(node, opts = {}) {
1179  assert("Expression", node, opts);
1180}
1181
1182function assertBinary(node, opts = {}) {
1183  assert("Binary", node, opts);
1184}
1185
1186function assertScopable(node, opts = {}) {
1187  assert("Scopable", node, opts);
1188}
1189
1190function assertBlockParent(node, opts = {}) {
1191  assert("BlockParent", node, opts);
1192}
1193
1194function assertBlock(node, opts = {}) {
1195  assert("Block", node, opts);
1196}
1197
1198function assertStatement(node, opts = {}) {
1199  assert("Statement", node, opts);
1200}
1201
1202function assertTerminatorless(node, opts = {}) {
1203  assert("Terminatorless", node, opts);
1204}
1205
1206function assertCompletionStatement(node, opts = {}) {
1207  assert("CompletionStatement", node, opts);
1208}
1209
1210function assertConditional(node, opts = {}) {
1211  assert("Conditional", node, opts);
1212}
1213
1214function assertLoop(node, opts = {}) {
1215  assert("Loop", node, opts);
1216}
1217
1218function assertWhile(node, opts = {}) {
1219  assert("While", node, opts);
1220}
1221
1222function assertExpressionWrapper(node, opts = {}) {
1223  assert("ExpressionWrapper", node, opts);
1224}
1225
1226function assertFor(node, opts = {}) {
1227  assert("For", node, opts);
1228}
1229
1230function assertForXStatement(node, opts = {}) {
1231  assert("ForXStatement", node, opts);
1232}
1233
1234function assertFunction(node, opts = {}) {
1235  assert("Function", node, opts);
1236}
1237
1238function assertFunctionParent(node, opts = {}) {
1239  assert("FunctionParent", node, opts);
1240}
1241
1242function assertPureish(node, opts = {}) {
1243  assert("Pureish", node, opts);
1244}
1245
1246function assertDeclaration(node, opts = {}) {
1247  assert("Declaration", node, opts);
1248}
1249
1250function assertPatternLike(node, opts = {}) {
1251  assert("PatternLike", node, opts);
1252}
1253
1254function assertLVal(node, opts = {}) {
1255  assert("LVal", node, opts);
1256}
1257
1258function assertTSEntityName(node, opts = {}) {
1259  assert("TSEntityName", node, opts);
1260}
1261
1262function assertLiteral(node, opts = {}) {
1263  assert("Literal", node, opts);
1264}
1265
1266function assertImmutable(node, opts = {}) {
1267  assert("Immutable", node, opts);
1268}
1269
1270function assertUserWhitespacable(node, opts = {}) {
1271  assert("UserWhitespacable", node, opts);
1272}
1273
1274function assertMethod(node, opts = {}) {
1275  assert("Method", node, opts);
1276}
1277
1278function assertObjectMember(node, opts = {}) {
1279  assert("ObjectMember", node, opts);
1280}
1281
1282function assertProperty(node, opts = {}) {
1283  assert("Property", node, opts);
1284}
1285
1286function assertUnaryLike(node, opts = {}) {
1287  assert("UnaryLike", node, opts);
1288}
1289
1290function assertPattern(node, opts = {}) {
1291  assert("Pattern", node, opts);
1292}
1293
1294function assertClass(node, opts = {}) {
1295  assert("Class", node, opts);
1296}
1297
1298function assertModuleDeclaration(node, opts = {}) {
1299  assert("ModuleDeclaration", node, opts);
1300}
1301
1302function assertExportDeclaration(node, opts = {}) {
1303  assert("ExportDeclaration", node, opts);
1304}
1305
1306function assertModuleSpecifier(node, opts = {}) {
1307  assert("ModuleSpecifier", node, opts);
1308}
1309
1310function assertFlow(node, opts = {}) {
1311  assert("Flow", node, opts);
1312}
1313
1314function assertFlowType(node, opts = {}) {
1315  assert("FlowType", node, opts);
1316}
1317
1318function assertFlowBaseAnnotation(node, opts = {}) {
1319  assert("FlowBaseAnnotation", node, opts);
1320}
1321
1322function assertFlowDeclaration(node, opts = {}) {
1323  assert("FlowDeclaration", node, opts);
1324}
1325
1326function assertFlowPredicate(node, opts = {}) {
1327  assert("FlowPredicate", node, opts);
1328}
1329
1330function assertJSX(node, opts = {}) {
1331  assert("JSX", node, opts);
1332}
1333
1334function assertPrivate(node, opts = {}) {
1335  assert("Private", node, opts);
1336}
1337
1338function assertTSTypeElement(node, opts = {}) {
1339  assert("TSTypeElement", node, opts);
1340}
1341
1342function assertTSType(node, opts = {}) {
1343  assert("TSType", node, opts);
1344}
1345
1346function assertNumberLiteral(node, opts) {
1347  console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
1348  assert("NumberLiteral", node, opts);
1349}
1350
1351function assertRegexLiteral(node, opts) {
1352  console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
1353  assert("RegexLiteral", node, opts);
1354}
1355
1356function assertRestProperty(node, opts) {
1357  console.trace("The node type RestProperty has been renamed to RestElement");
1358  assert("RestProperty", node, opts);
1359}
1360
1361function assertSpreadProperty(node, opts) {
1362  console.trace("The node type SpreadProperty has been renamed to SpreadElement");
1363  assert("SpreadProperty", node, opts);
1364}