Migrating all variant values with the possibility to be a string to TerminalNode for easier printing logic

Author: Janther

src/slang-nodes/ConstructorAttribute.ts

@@ -1,7 +1,10 @@
-import { NonterminalKind, TerminalNode } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import {
+  NonterminalKind,
+  TerminalNode as SlangTerminalNode
+} from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 import { ModifierInvocation } from './ModifierInvocation.js';
+import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
@@ -11,14 +14,14 @@ import type { PrintFunction } from '../types.d.ts';
 export class ConstructorAttribute extends SlangNode {
   readonly kind = NonterminalKind.ConstructorAttribute;
 
-  variant: ModifierInvocation | string;
+  variant: ModifierInvocation | TerminalNode;
 
   constructor(ast: ast.ConstructorAttribute, options: ParserOptions<AstNode>) {
     super(ast);
 
     const variant = ast.variant;
-    if (variant instanceof TerminalNode) {
-      this.variant = variant.unparse();
+    if (variant instanceof SlangTerminalNode) {
+      this.variant = new TerminalNode(variant);
       return;
     }
     this.variant = new ModifierInvocation(variant, options);
@@ -27,6 +30,6 @@ export class ConstructorAttribute extends SlangNode {
   }
 
   print(path: AstPath<ConstructorAttribute>, print: PrintFunction): Doc {
-    return printVariant(this, path, print);
+    return path.call(print, 'variant');
   }
 }

src/slang-nodes/ElementaryType.ts

@@ -1,7 +1,10 @@
-import { NonterminalKind, TerminalNode } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import {
+  NonterminalKind,
+  TerminalNode as SlangTerminalNode
+} from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 import { AddressType } from './AddressType.js';
+import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
@@ -10,14 +13,14 @@ import type { PrintFunction } from '../types.d.ts';
 export class ElementaryType extends SlangNode {
   readonly kind = NonterminalKind.ElementaryType;
 
-  variant: AddressType | string;
+  variant: AddressType | TerminalNode;
 
   constructor(ast: ast.ElementaryType) {
     super(ast);
 
     const variant = ast.variant;
-    if (variant instanceof TerminalNode) {
-      this.variant = variant.unparse();
+    if (variant instanceof SlangTerminalNode) {
+      this.variant = new TerminalNode(variant);
       return;
     }
     this.variant = new AddressType(variant);
@@ -26,6 +29,6 @@ export class ElementaryType extends SlangNode {
   }
 
   print(path: AstPath<ElementaryType>, print: PrintFunction): Doc {
-    return printVariant(this, path, print);
+    return path.call(print, 'variant');
   }
 }

src/slang-nodes/FallbackFunctionAttribute.ts

@@ -1,18 +1,21 @@
 import * as ast from '@nomicfoundation/slang/ast';
-import { NonterminalKind, TerminalNode } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import {
+  NonterminalKind,
+  TerminalNode as SlangTerminalNode
+} from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 import { ModifierInvocation } from './ModifierInvocation.js';
 import { OverrideSpecifier } from './OverrideSpecifier.js';
+import { TerminalNode } from './TerminalNode.js';
 
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
 import type { PrintFunction } from '../types.d.ts';
 
 function createNonterminalVariant(
-  variant: Exclude<ast.FallbackFunctionAttribute['variant'], TerminalNode>,
+  variant: Exclude<ast.FallbackFunctionAttribute['variant'], SlangTerminalNode>,
   options: ParserOptions<AstNode>
-): Exclude<FallbackFunctionAttribute['variant'], string> {
+): Exclude<FallbackFunctionAttribute['variant'], TerminalNode> {
   if (variant instanceof ast.ModifierInvocation) {
     return new ModifierInvocation(variant, options);
   }
@@ -26,7 +29,7 @@ function createNonterminalVariant(
 export class FallbackFunctionAttribute extends SlangNode {
   readonly kind = NonterminalKind.FallbackFunctionAttribute;
 
-  variant: ModifierInvocation | OverrideSpecifier | string;
+  variant: ModifierInvocation | OverrideSpecifier | TerminalNode;
 
   constructor(
     ast: ast.FallbackFunctionAttribute,
@@ -35,8 +38,8 @@ export class FallbackFunctionAttribute extends SlangNode {
     super(ast);
 
     const variant = ast.variant;
-    if (variant instanceof TerminalNode) {
-      this.variant = variant.unparse();
+    if (variant instanceof SlangTerminalNode) {
+      this.variant = new TerminalNode(variant);
       return;
     }
     this.variant = createNonterminalVariant(variant, options);
@@ -45,6 +48,6 @@ export class FallbackFunctionAttribute extends SlangNode {
   }
 
   print(path: AstPath<FallbackFunctionAttribute>, print: PrintFunction): Doc {
-    return printVariant(this, path, print);
+    return path.call(print, 'variant');
   }
 }

src/slang-nodes/ForStatementCondition.ts

@@ -1,24 +1,27 @@
-import { NonterminalKind, TerminalNode } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import {
+  NonterminalKind,
+  TerminalNode as SlangTerminalNode
+} from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 import { ExpressionStatement } from './ExpressionStatement.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
 import type { PrintFunction } from '../types.d.ts';
+import { TerminalNode } from './TerminalNode.js';
 
 export class ForStatementCondition extends SlangNode {
   readonly kind = NonterminalKind.ForStatementCondition;
 
-  variant: ExpressionStatement | string;
+  variant: ExpressionStatement | TerminalNode;
 
   constructor(ast: ast.ForStatementCondition, options: ParserOptions<AstNode>) {
     super(ast);
 
     const variant = ast.variant;
-    if (variant instanceof TerminalNode) {
-      this.variant = variant.unparse();
+    if (variant instanceof SlangTerminalNode) {
+      this.variant = new TerminalNode(variant);
       return;
     }
     this.variant = new ExpressionStatement(variant, options);
@@ -27,6 +30,6 @@ export class ForStatementCondition extends SlangNode {
   }
 
   print(path: AstPath<ForStatementCondition>, print: PrintFunction): Doc {
-    return printVariant(this, path, print);
+    return path.call(print, 'variant');
   }
 }

src/slang-nodes/ForStatementInitialization.ts

@@ -1,19 +1,25 @@
 import * as ast from '@nomicfoundation/slang/ast';
-import { NonterminalKind, TerminalNode } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import {
+  NonterminalKind,
+  TerminalNode as SlangTerminalNode
+} from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 import { ExpressionStatement } from './ExpressionStatement.js';
 import { VariableDeclarationStatement } from './VariableDeclarationStatement.js';
 import { TupleDeconstructionStatement } from './TupleDeconstructionStatement.js';
+import { TerminalNode } from './TerminalNode.js';
 
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
 import type { PrintFunction } from '../types.d.ts';
 
 function createNonterminalVariant(
-  variant: Exclude<ast.ForStatementInitialization['variant'], TerminalNode>,
+  variant: Exclude<
+    ast.ForStatementInitialization['variant'],
+    SlangTerminalNode
+  >,
   options: ParserOptions<AstNode>
-): Exclude<ForStatementInitialization['variant'], string> {
+): Exclude<ForStatementInitialization['variant'], TerminalNode> {
   if (variant instanceof ast.ExpressionStatement) {
     return new ExpressionStatement(variant, options);
   }
@@ -34,7 +40,7 @@ export class ForStatementInitialization extends SlangNode {
     | ExpressionStatement
     | VariableDeclarationStatement
     | TupleDeconstructionStatement
-    | string;
+    | TerminalNode;
 
   constructor(
     ast: ast.ForStatementInitialization,
@@ -43,8 +49,8 @@ export class ForStatementInitialization extends SlangNode {
     super(ast);
 
     const variant = ast.variant;
-    if (variant instanceof TerminalNode) {
-      this.variant = variant.unparse();
+    if (variant instanceof SlangTerminalNode) {
+      this.variant = new TerminalNode(variant);
       return;
     }
     this.variant = createNonterminalVariant(variant, options);
@@ -53,6 +59,6 @@ export class ForStatementInitialization extends SlangNode {
   }
 
   print(path: AstPath<ForStatementInitialization>, print: PrintFunction): Doc {
-    return printVariant(this, path, print);
+    return path.call(print, 'variant');
   }
 }

src/slang-nodes/FunctionAttribute.ts

@@ -1,18 +1,21 @@
 import * as ast from '@nomicfoundation/slang/ast';
-import { NonterminalKind, TerminalNode } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import {
+  NonterminalKind,
+  TerminalNode as SlangTerminalNode
+} from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 import { ModifierInvocation } from './ModifierInvocation.js';
 import { OverrideSpecifier } from './OverrideSpecifier.js';
+import { TerminalNode } from './TerminalNode.js';
 
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
 import type { PrintFunction } from '../types.d.ts';
 
 function createNonterminalVariant(
-  variant: Exclude<ast.FunctionAttribute['variant'], TerminalNode>,
+  variant: Exclude<ast.FunctionAttribute['variant'], SlangTerminalNode>,
   options: ParserOptions<AstNode>
-): Exclude<FunctionAttribute['variant'], string> {
+): Exclude<FunctionAttribute['variant'], TerminalNode> {
   if (variant instanceof ast.ModifierInvocation) {
     return new ModifierInvocation(variant, options);
   }
@@ -26,14 +29,14 @@ function createNonterminalVariant(
 export class FunctionAttribute extends SlangNode {
   readonly kind = NonterminalKind.FunctionAttribute;
 
-  variant: ModifierInvocation | OverrideSpecifier | string;
+  variant: ModifierInvocation | OverrideSpecifier | TerminalNode;
 
   constructor(ast: ast.FunctionAttribute, options: ParserOptions<AstNode>) {
     super(ast);
 
     const variant = ast.variant;
-    if (variant instanceof TerminalNode) {
-      this.variant = variant.unparse();
+    if (variant instanceof SlangTerminalNode) {
+      this.variant = new TerminalNode(variant);
       return;
     }
     this.variant = createNonterminalVariant(variant, options);
@@ -42,6 +45,6 @@ export class FunctionAttribute extends SlangNode {
   }
 
   print(path: AstPath<FunctionAttribute>, print: PrintFunction): Doc {
-    return printVariant(this, path, print);
+    return path.call(print, 'variant');
   }
 }

src/slang-nodes/FunctionBody.ts

@@ -1,7 +1,10 @@
-import { NonterminalKind, TerminalNode } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import {
+  NonterminalKind,
+  TerminalNode as SlangTerminalNode
+} from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 import { Block } from './Block.js';
+import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
@@ -11,14 +14,14 @@ import type { PrintFunction } from '../types.d.ts';
 export class FunctionBody extends SlangNode {
   readonly kind = NonterminalKind.FunctionBody;
 
-  variant: Block | string;
+  variant: Block | TerminalNode;
 
   constructor(ast: ast.FunctionBody, options: ParserOptions<AstNode>) {
     super(ast);
 
     const variant = ast.variant;
-    if (variant instanceof TerminalNode) {
-      this.variant = variant.unparse();
+    if (variant instanceof SlangTerminalNode) {
+      this.variant = new TerminalNode(variant);
       return;
     }
     this.variant = new Block(variant, options);
@@ -27,6 +30,6 @@ export class FunctionBody extends SlangNode {
   }
 
   print(path: AstPath<FunctionBody>, print: PrintFunction): Doc {
-    return printVariant(this, path, print);
+    return path.call(print, 'variant');
   }
 }

src/slang-nodes/FunctionTypeAttribute.ts

@@ -1,21 +1,23 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
+import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { Doc } from 'prettier';
+import type { AstPath, Doc } from 'prettier';
+import type { PrintFunction } from '../types.d.ts';
 
 export class FunctionTypeAttribute extends SlangNode {
   readonly kind = NonterminalKind.FunctionTypeAttribute;
 
-  variant: string;
+  variant: TerminalNode;
 
   constructor(ast: ast.FunctionTypeAttribute) {
     super(ast);
 
-    this.variant = ast.variant.unparse();
+    this.variant = new TerminalNode(ast.variant);
   }
 
-  print(): Doc {
-    return this.variant;
+  print(path: AstPath<FunctionTypeAttribute>, print: PrintFunction): Doc {
+    return path.call(print, 'variant');
   }
 }

src/slang-nodes/ModifierAttribute.ts

@@ -1,7 +1,10 @@
-import { NonterminalKind, TerminalNode } from '@nomicfoundation/slang/cst';
-import { printVariant } from '../slang-printers/print-variant.js';
+import {
+  NonterminalKind,
+  TerminalNode as SlangTerminalNode
+} from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 import { OverrideSpecifier } from './OverrideSpecifier.js';
+import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
@@ -10,14 +13,14 @@ import type { PrintFunction } from '../types.d.ts';
 export class ModifierAttribute extends SlangNode {
   readonly kind = NonterminalKind.ModifierAttribute;
 
-  variant: OverrideSpecifier | string;
+  variant: OverrideSpecifier | TerminalNode;
 
   constructor(ast: ast.ModifierAttribute) {
     super(ast);
 
     const variant = ast.variant;
-    if (variant instanceof TerminalNode) {
-      this.variant = variant.unparse();
+    if (variant instanceof SlangTerminalNode) {
+      this.variant = new TerminalNode(variant);
       return;
     }
     this.variant = new OverrideSpecifier(variant);
@@ -26,6 +29,6 @@ export class ModifierAttribute extends SlangNode {
   }
 
   print(path: AstPath<ModifierAttribute>, print: PrintFunction): Doc {
-    return printVariant(this, path, print);
+    return path.call(print, 'variant');
   }
 }