removing the rest of the Polymorphic nodes from the AST tree

src/slang-nodes/ArrayTypeName.ts

@@ -1,5 +1,4 @@
 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 { TypeName } from './TypeName.js';
@@ -13,14 +12,14 @@ import type { AstNode } from './types.d.ts';
 export class ArrayTypeName extends SlangNode {
   readonly kind = NonterminalKind.ArrayTypeName;
 
-  operand: TypeName;
+  operand: TypeName['variant'];
 
   index?: Expression['variant'];
 
   constructor(ast: ast.ArrayTypeName, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.operand = new TypeName(ast.operand, options);
+    this.operand = extractVariant(new TypeName(ast.operand, options));
     if (ast.index) {
       this.index = extractVariant(new Expression(ast.index, options));
     }
@@ -29,11 +28,6 @@ export class ArrayTypeName extends SlangNode {
   }
 
   print(path: AstPath<ArrayTypeName>, print: PrintFunction): Doc {
-    return [
-      path.call(printVariant(print), 'operand'),
-      '[',
-      path.call(print, 'index'),
-      ']'
-    ];
+    return [path.call(print, 'operand'), '[', path.call(print, 'index'), ']'];
   }
 }

src/slang-nodes/ConstantDefinition.ts

@@ -1,5 +1,4 @@
 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 { TypeName } from './TypeName.js';
@@ -14,7 +13,7 @@ import type { AstNode } from './types.d.ts';
 export class ConstantDefinition extends SlangNode {
   readonly kind = NonterminalKind.ConstantDefinition;
 
-  typeName: TypeName;
+  typeName: TypeName['variant'];
 
   name: TerminalNode;
 
@@ -23,7 +22,7 @@ export class ConstantDefinition extends SlangNode {
   constructor(ast: ast.ConstantDefinition, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.typeName = new TypeName(ast.typeName, options);
+    this.typeName = extractVariant(new TypeName(ast.typeName, options));
     this.name = new TerminalNode(ast.name);
     this.value = extractVariant(new Expression(ast.value, options));
 
@@ -32,7 +31,7 @@ export class ConstantDefinition extends SlangNode {
 
   print(path: AstPath<ConstantDefinition>, print: PrintFunction): Doc {
     return [
-      path.call(printVariant(print), 'typeName'),
+      path.call(print, 'typeName'),
       ' constant ',
       path.call(print, 'name'),
       ' = ',

src/slang-nodes/ContractDefinition.ts

@@ -44,7 +44,7 @@ export class ContractDefinition extends SlangNode {
       for (const member of this.members.items) {
         if (
           member.kind === NonterminalKind.FunctionDefinition &&
-          member.name.variant.value !== this.name.value
+          member.name.value !== this.name.value
         ) {
           member.cleanModifierInvocationArguments();
         }

src/slang-nodes/ErrorParameter.ts

@@ -1,6 +1,6 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { joinExisting } from '../slang-utils/join-existing.js';
-import { printVariant } from '../slang-printers/print-variant.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
@@ -13,14 +13,14 @@ import type { AstNode } from './types.d.ts';
 export class ErrorParameter extends SlangNode {
   readonly kind = NonterminalKind.ErrorParameter;
 
-  typeName: TypeName;
+  typeName: TypeName['variant'];
 
   name?: TerminalNode;
 
   constructor(ast: ast.ErrorParameter, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.typeName = new TypeName(ast.typeName, options);
+    this.typeName = extractVariant(new TypeName(ast.typeName, options));
     if (ast.name) {
       this.name = new TerminalNode(ast.name);
     }
@@ -30,7 +30,7 @@ export class ErrorParameter extends SlangNode {
 
   print(path: AstPath<ErrorParameter>, print: PrintFunction): Doc {
     return joinExisting(' ', [
-      path.call(printVariant(print), 'typeName'),
+      path.call(print, 'typeName'),
       path.call(print, 'name')
     ]);
   }

src/slang-nodes/EventParameter.ts

@@ -1,6 +1,6 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { joinExisting } from '../slang-utils/join-existing.js';
-import { printVariant } from '../slang-printers/print-variant.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
@@ -13,7 +13,7 @@ import type { AstNode } from './types.d.ts';
 export class EventParameter extends SlangNode {
   readonly kind = NonterminalKind.EventParameter;
 
-  typeName: TypeName;
+  typeName: TypeName['variant'];
 
   indexedKeyword?: string;
 
@@ -22,7 +22,7 @@ export class EventParameter extends SlangNode {
   constructor(ast: ast.EventParameter, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.typeName = new TypeName(ast.typeName, options);
+    this.typeName = extractVariant(new TypeName(ast.typeName, options));
     this.indexedKeyword = ast.indexedKeyword?.unparse();
     if (ast.name) {
       this.name = new TerminalNode(ast.name);
@@ -33,7 +33,7 @@ export class EventParameter extends SlangNode {
 
   print(path: AstPath<EventParameter>, print: PrintFunction): Doc {
     return joinExisting(' ', [
-      path.call(printVariant(print), 'typeName'),
+      path.call(print, 'typeName'),
       this.indexedKeyword,
       path.call(print, 'name')
     ]);

src/slang-nodes/Expression.ts

@@ -117,7 +117,7 @@ function createNonterminalVariant(
     return new DecimalNumberExpression(variant);
   }
   if (variant instanceof ast.StringExpression) {
-    return new StringExpression(variant, options);
+    return extractVariant(new StringExpression(variant, options));
   }
   if (variant instanceof ast.ElementaryType) {
     return extractVariant(new ElementaryType(variant));
@@ -155,7 +155,7 @@ export class Expression extends SlangNode {
     | ArrayExpression
     | HexNumberExpression
     | DecimalNumberExpression
-    | StringExpression
+    | StringExpression['variant']
     | ElementaryType['variant']
     | TerminalNode;
 

src/slang-nodes/FallbackFunctionDefinition.ts

@@ -1,5 +1,6 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printFunctionWithBody } from '../slang-printers/print-function.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { ParametersDeclaration } from './ParametersDeclaration.js';
 import { FallbackFunctionAttributes } from './FallbackFunctionAttributes.js';
@@ -20,7 +21,7 @@ export class FallbackFunctionDefinition extends SlangNode {
 
   returns?: ReturnsDeclaration;
 
-  body: FunctionBody;
+  body: FunctionBody['variant'];
 
   constructor(
     ast: ast.FallbackFunctionDefinition,
@@ -33,7 +34,7 @@ export class FallbackFunctionDefinition extends SlangNode {
     if (ast.returns) {
       this.returns = new ReturnsDeclaration(ast.returns, options);
     }
-    this.body = new FunctionBody(ast.body, options);
+    this.body = extractVariant(new FunctionBody(ast.body, options));
 
     this.updateMetadata(
       this.parameters,

src/slang-nodes/ForStatement.ts

@@ -2,7 +2,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { doc } from 'prettier';
 import { printSeparatedList } from '../slang-printers/print-separated-list.js';
 import { printIndentedGroupOrSpacedDocument } from '../slang-printers/print-indented-group-or-spaced-document.js';
-import { printVariant } from '../slang-printers/print-variant.js';
 import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { ForStatementInitialization } from './ForStatementInitialization.js';
@@ -20,9 +19,9 @@ const { line } = doc.builders;
 export class ForStatement extends SlangNode {
   readonly kind = NonterminalKind.ForStatement;
 
-  initialization: ForStatementInitialization;
+  initialization: ForStatementInitialization['variant'];
 
-  condition: ForStatementCondition;
+  condition: ForStatementCondition['variant'];
 
   iterator?: Expression['variant'];
 
@@ -31,11 +30,12 @@ export class ForStatement extends SlangNode {
   constructor(ast: ast.ForStatement, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.initialization = new ForStatementInitialization(
-      ast.initialization,
-      options
+    this.initialization = extractVariant(
+      new ForStatementInitialization(ast.initialization, options)
+    );
+    this.condition = extractVariant(
+      new ForStatementCondition(ast.condition, options)
     );
-    this.condition = new ForStatementCondition(ast.condition, options);
     if (ast.iterator) {
       this.iterator = extractVariant(new Expression(ast.iterator, options));
     }
@@ -50,8 +50,8 @@ export class ForStatement extends SlangNode {
   }
 
   print(path: AstPath<ForStatement>, print: PrintFunction): Doc {
-    const initialization = path.call(printVariant(print), 'initialization');
-    const condition = path.call(printVariant(print), 'condition');
+    const initialization = path.call(print, 'initialization');
+    const condition = path.call(print, 'condition');
     const iterator = path.call(print, 'iterator');
 
     return [

src/slang-nodes/ForStatementCondition.ts

@@ -2,15 +2,15 @@ import {
   NonterminalKind,
   TerminalNode as SlangTerminalNode
 } from '@nomicfoundation/slang/cst';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { SlangNode } from './SlangNode.js';
 import { ExpressionStatement } from './ExpressionStatement.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 ForStatementCondition extends PolymorphicNode {
+export class ForStatementCondition extends SlangNode {
   readonly kind = NonterminalKind.ForStatementCondition;
 
   variant: ExpressionStatement | TerminalNode;

src/slang-nodes/ForStatementInitialization.ts

@@ -3,7 +3,7 @@ import {
   NonterminalKind,
   TerminalNode as SlangTerminalNode
 } from '@nomicfoundation/slang/cst';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { SlangNode } from './SlangNode.js';
 import { ExpressionStatement } from './ExpressionStatement.js';
 import { VariableDeclarationStatement } from './VariableDeclarationStatement.js';
 import { TupleDeconstructionStatement } from './TupleDeconstructionStatement.js';
@@ -32,7 +32,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class ForStatementInitialization extends PolymorphicNode {
+export class ForStatementInitialization extends SlangNode {
   readonly kind = NonterminalKind.ForStatementInitialization;
 
   variant:

src/slang-nodes/FunctionBody.ts

@@ -2,15 +2,15 @@ import {
   NonterminalKind,
   TerminalNode as SlangTerminalNode
 } from '@nomicfoundation/slang/cst';
-import { PolymorphicNode } from './PolymorphicNode.js';
+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 { ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
 
-export class FunctionBody extends PolymorphicNode {
+export class FunctionBody extends SlangNode {
   readonly kind = NonterminalKind.FunctionBody;
 
   variant: Block | TerminalNode;

src/slang-nodes/FunctionDefinition.ts

@@ -1,7 +1,7 @@
 import { satisfies } from 'semver';
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printFunctionWithBody } from '../slang-printers/print-function.js';
-import { printVariant } from '../slang-printers/print-variant.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { FunctionName } from './FunctionName.js';
 import { ParametersDeclaration } from './ParametersDeclaration.js';
@@ -17,26 +17,26 @@ import type { AstNode } from './types.d.ts';
 export class FunctionDefinition extends SlangNode {
   readonly kind = NonterminalKind.FunctionDefinition;
 
-  name: FunctionName;
+  name: FunctionName['variant'];
 
   parameters: ParametersDeclaration;
 
   attributes: FunctionAttributes;
 
   returns?: ReturnsDeclaration;
 
-  body: FunctionBody;
+  body: FunctionBody['variant'];
 
   constructor(ast: ast.FunctionDefinition, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.name = new FunctionName(ast.name);
+    this.name = extractVariant(new FunctionName(ast.name));
     this.parameters = new ParametersDeclaration(ast.parameters, options);
     this.attributes = new FunctionAttributes(ast.attributes, options);
     if (ast.returns) {
       this.returns = new ReturnsDeclaration(ast.returns, options);
     }
-    this.body = new FunctionBody(ast.body, options);
+    this.body = extractVariant(new FunctionBody(ast.body, options));
 
     this.updateMetadata(
       this.name,
@@ -66,7 +66,7 @@ export class FunctionDefinition extends SlangNode {
 
   print(path: AstPath<FunctionDefinition>, print: PrintFunction): Doc {
     return printFunctionWithBody(
-      ['function ', path.call(printVariant(print), 'name')],
+      ['function ', path.call(print, 'name')],
       this,
       path,
       print

src/slang-nodes/FunctionName.ts

@@ -1,10 +1,10 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { SlangNode } from './SlangNode.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 
-export class FunctionName extends PolymorphicNode {
+export class FunctionName extends SlangNode {
   readonly kind = NonterminalKind.FunctionName;
 
   variant: TerminalNode;

src/slang-nodes/ImportClause.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 { PathImport } from './PathImport.js';
 import { NamedImport } from './NamedImport.js';
 import { ImportDeconstruction } from './ImportDeconstruction.js';
@@ -25,7 +25,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class ImportClause extends PolymorphicNode {
+export class ImportClause extends SlangNode {
   readonly kind = NonterminalKind.ImportClause;
 
   variant: PathImport | NamedImport | ImportDeconstruction;

src/slang-nodes/ImportDirective.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 { ImportClause } from './ImportClause.js';
 
@@ -11,17 +11,17 @@ import type { AstNode } from './types.d.ts';
 export class ImportDirective extends SlangNode {
   readonly kind = NonterminalKind.ImportDirective;
 
-  clause: ImportClause;
+  clause: ImportClause['variant'];
 
   constructor(ast: ast.ImportDirective, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.clause = new ImportClause(ast.clause, options);
+    this.clause = extractVariant(new ImportClause(ast.clause, options));
 
     this.updateMetadata(this.clause);
   }
 
   print(path: AstPath<ImportDirective>, print: PrintFunction): Doc {
-    return ['import ', path.call(printVariant(print), 'clause'), ';'];
+    return ['import ', path.call(print, 'clause'), ';'];
   }
 }