removing UsingClause, UsingTarget, VariableDeclarationType, VersionExpression, and VersionLiteral from the AST tree

Author: Janther

src/slang-nodes/UsingClause.ts

@@ -1,6 +1,6 @@
 import * as ast from '@nomicfoundation/slang/ast';
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { SlangNode } from './SlangNode.js';
 import { IdentifierPath } from './IdentifierPath.js';
 import { UsingDeconstruction } from './UsingDeconstruction.js';
 
@@ -17,7 +17,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class UsingClause extends PolymorphicNode {
+export class UsingClause extends SlangNode {
   readonly kind = NonterminalKind.UsingClause;
 
   variant: IdentifierPath | UsingDeconstruction;

src/slang-nodes/UsingDirective.ts

@@ -1,5 +1,5 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { UsingClause } from './UsingClause.js';
 import { UsingTarget } from './UsingTarget.js';
@@ -12,17 +12,17 @@ import type { AstNode } from './types.d.ts';
 export class UsingDirective extends SlangNode {
   readonly kind = NonterminalKind.UsingDirective;
 
-  clause: UsingClause;
+  clause: UsingClause['variant'];
 
-  target: UsingTarget;
+  target: UsingTarget['variant'];
 
   globalKeyword?: string;
 
   constructor(ast: ast.UsingDirective, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.clause = new UsingClause(ast.clause);
-    this.target = new UsingTarget(ast.target, options);
+    this.clause = extractVariant(new UsingClause(ast.clause));
+    this.target = extractVariant(new UsingTarget(ast.target, options));
     this.globalKeyword = ast.globalKeyword?.unparse();
 
     this.updateMetadata(this.clause, this.target);
@@ -31,9 +31,9 @@ export class UsingDirective extends SlangNode {
   print(path: AstPath<UsingDirective>, print: PrintFunction): Doc {
     return [
       'using ',
-      path.call(printVariant(print), 'clause'),
+      path.call(print, 'clause'),
       ' for ',
-      path.call(printVariant(print), 'target'),
+      path.call(print, 'target'),
       this.globalKeyword ? ' global;' : ';'
     ];
   }

src/slang-nodes/UsingTarget.ts

@@ -3,15 +3,15 @@ import {
   TerminalNode as SlangTerminalNode
 } from '@nomicfoundation/slang/cst';
 import { extractVariant } from '../slang-utils/extract-variant.js';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { SlangNode } from './SlangNode.js';
 import { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
 
-export class UsingTarget extends PolymorphicNode {
+export class UsingTarget extends SlangNode {
   readonly kind = NonterminalKind.UsingTarget;
 
   variant: TypeName['variant'] | TerminalNode;

src/slang-nodes/VariableDeclarationStatement.ts

@@ -1,7 +1,7 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { doc } from 'prettier';
 import { printGroupAndIndentIfBreakPair } from '../slang-printers/print-group-and-indent-if-break-pair.js';
-import { printVariant } from '../slang-printers/print-variant.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { VariableDeclarationType } from './VariableDeclarationType.js';
 import { StorageLocation } from './StorageLocation.js';
@@ -18,7 +18,7 @@ const { indent, line } = doc.builders;
 export class VariableDeclarationStatement extends SlangNode {
   readonly kind = NonterminalKind.VariableDeclarationStatement;
 
-  variableType: VariableDeclarationType;
+  variableType: VariableDeclarationType['variant'];
 
   storageLocation?: StorageLocation;
 
@@ -32,7 +32,9 @@ export class VariableDeclarationStatement extends SlangNode {
   ) {
     super(ast);
 
-    this.variableType = new VariableDeclarationType(ast.variableType, options);
+    this.variableType = extractVariant(
+      new VariableDeclarationType(ast.variableType, options)
+    );
     if (ast.storageLocation) {
       this.storageLocation = new StorageLocation(ast.storageLocation);
     }
@@ -50,7 +52,7 @@ export class VariableDeclarationStatement extends SlangNode {
   ): Doc {
     return printGroupAndIndentIfBreakPair(
       [
-        path.call(printVariant(print), 'variableType'),
+        path.call(print, 'variableType'),
         this.storageLocation
           ? indent([line, path.call(print, 'storageLocation')])
           : '',

src/slang-nodes/VariableDeclarationType.ts

@@ -3,15 +3,15 @@ import {
   TerminalNode as SlangTerminalNode
 } from '@nomicfoundation/slang/cst';
 import { extractVariant } from '../slang-utils/extract-variant.js';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { SlangNode } from './SlangNode.js';
 import { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
 
-export class VariableDeclarationType extends PolymorphicNode {
+export class VariableDeclarationType extends SlangNode {
   readonly kind = NonterminalKind.VariableDeclarationType;
 
   variant: TypeName['variant'] | TerminalNode;

src/slang-nodes/VersionExpression.ts

@@ -1,6 +1,6 @@
 import * as ast from '@nomicfoundation/slang/ast';
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { SlangNode } from './SlangNode.js';
 import { VersionRange } from './VersionRange.js';
 import { VersionTerm } from './VersionTerm.js';
 
@@ -17,7 +17,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class VersionExpression extends PolymorphicNode {
+export class VersionExpression extends SlangNode {
   readonly kind = NonterminalKind.VersionExpression;
 
   variant: VersionRange | VersionTerm;

src/slang-nodes/VersionExpressionSet.ts

@@ -1,6 +1,6 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { doc } from 'prettier';
-import { printVariant } from '../slang-printers/print-variant.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { VersionExpression } from './VersionExpression.js';
 
@@ -13,15 +13,17 @@ const { join } = doc.builders;
 export class VersionExpressionSet extends SlangNode {
   readonly kind = NonterminalKind.VersionExpressionSet;
 
-  items: VersionExpression[];
+  items: VersionExpression['variant'][];
 
   constructor(ast: ast.VersionExpressionSet) {
     super(ast, true);
 
-    this.items = ast.items.map((item) => new VersionExpression(item));
+    this.items = ast.items.map((item) =>
+      extractVariant(new VersionExpression(item))
+    );
   }
 
   print(path: AstPath<VersionExpressionSet>, print: PrintFunction): Doc {
-    return join(' ', path.map(printVariant(print), 'items'));
+    return join(' ', path.map(print, 'items'));
   }
 }

src/slang-nodes/VersionLiteral.ts

@@ -2,13 +2,13 @@ import {
   NonterminalKind,
   TerminalNode as SlangTerminalNode
 } from '@nomicfoundation/slang/cst';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { SlangNode } from './SlangNode.js';
 import { SimpleVersionLiteral } from './SimpleVersionLiteral.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 
-export class VersionLiteral extends PolymorphicNode {
+export class VersionLiteral extends SlangNode {
   readonly kind = NonterminalKind.VersionLiteral;
 
   variant: SimpleVersionLiteral | TerminalNode;

src/slang-nodes/VersionRange.ts

@@ -1,5 +1,5 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { VersionLiteral } from './VersionLiteral.js';
 
@@ -10,24 +10,20 @@ import type { PrintFunction } from '../types.d.ts';
 export class VersionRange extends SlangNode {
   readonly kind = NonterminalKind.VersionRange;
 
-  start: VersionLiteral;
+  start: VersionLiteral['variant'];
 
-  end: VersionLiteral;
+  end: VersionLiteral['variant'];
 
   constructor(ast: ast.VersionRange) {
     super(ast);
 
-    this.start = new VersionLiteral(ast.start);
-    this.end = new VersionLiteral(ast.end);
+    this.start = extractVariant(new VersionLiteral(ast.start));
+    this.end = extractVariant(new VersionLiteral(ast.end));
 
     this.updateMetadata(this.start, this.end);
   }
 
   print(path: AstPath<VersionRange>, print: PrintFunction): Doc {
-    return [
-      path.call(printVariant(print), 'start'),
-      ' - ',
-      path.call(printVariant(print), 'end')
-    ];
+    return [path.call(print, 'start'), ' - ', path.call(print, 'end')];
   }
 }

src/slang-nodes/VersionTerm.ts

@@ -1,5 +1,5 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { VersionOperator } from './VersionOperator.js';
 import { VersionLiteral } from './VersionLiteral.js';
@@ -13,23 +13,20 @@ export class VersionTerm extends SlangNode {
 
   operator?: VersionOperator;
 
-  literal: VersionLiteral;
+  literal: VersionLiteral['variant'];
 
   constructor(ast: ast.VersionTerm) {
     super(ast);
 
     if (ast.operator) {
       this.operator = new VersionOperator(ast.operator);
     }
-    this.literal = new VersionLiteral(ast.literal);
+    this.literal = extractVariant(new VersionLiteral(ast.literal));
 
     this.updateMetadata(this.operator, this.literal);
   }
 
   print(path: AstPath<VersionTerm>, print: PrintFunction): Doc {
-    return [
-      path.call(print, 'operator'),
-      path.call(printVariant(print), 'literal')
-    ];
+    return [path.call(print, 'operator'), path.call(print, 'literal')];
   }
 }