diff --git a/src/slang-nodes/ArrayTypeName.ts b/src/slang-nodes/ArrayTypeName.ts
index a7ce37c1..eea23eb1 100644
--- a/src/slang-nodes/ArrayTypeName.ts
+++ b/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'), ']'];
   }
 }
diff --git a/src/slang-nodes/ConstantDefinition.ts b/src/slang-nodes/ConstantDefinition.ts
index 0e2e95a2..0c898b8e 100644
--- a/src/slang-nodes/ConstantDefinition.ts
+++ b/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'),
       ' = ',
diff --git a/src/slang-nodes/ContractDefinition.ts b/src/slang-nodes/ContractDefinition.ts
index 8dfc2b51..41c24bd5 100644
--- a/src/slang-nodes/ContractDefinition.ts
+++ b/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();
         }
diff --git a/src/slang-nodes/ErrorParameter.ts b/src/slang-nodes/ErrorParameter.ts
index 105f0c85..bca479f2 100644
--- a/src/slang-nodes/ErrorParameter.ts
+++ b/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')
     ]);
   }
diff --git a/src/slang-nodes/EventParameter.ts b/src/slang-nodes/EventParameter.ts
index 00114408..4e49d652 100644
--- a/src/slang-nodes/EventParameter.ts
+++ b/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')
     ]);
diff --git a/src/slang-nodes/Expression.ts b/src/slang-nodes/Expression.ts
index 0427f7b0..32b746a4 100644
--- a/src/slang-nodes/Expression.ts
+++ b/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;
 
diff --git a/src/slang-nodes/FallbackFunctionDefinition.ts b/src/slang-nodes/FallbackFunctionDefinition.ts
index 31d067bc..500171d2 100644
--- a/src/slang-nodes/FallbackFunctionDefinition.ts
+++ b/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,
diff --git a/src/slang-nodes/ForStatement.ts b/src/slang-nodes/ForStatement.ts
index e68565be..4dc77208 100644
--- a/src/slang-nodes/ForStatement.ts
+++ b/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 [
diff --git a/src/slang-nodes/ForStatementCondition.ts b/src/slang-nodes/ForStatementCondition.ts
index 852a57bf..0c75d9c9 100644
--- a/src/slang-nodes/ForStatementCondition.ts
+++ b/src/slang-nodes/ForStatementCondition.ts
@@ -2,7 +2,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 { TerminalNode } from './TerminalNode.js';
 
@@ -10,7 +10,7 @@ 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;
diff --git a/src/slang-nodes/ForStatementInitialization.ts b/src/slang-nodes/ForStatementInitialization.ts
index a1f88c98..a26489a0 100644
--- a/src/slang-nodes/ForStatementInitialization.ts
+++ b/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:
diff --git a/src/slang-nodes/FunctionBody.ts b/src/slang-nodes/FunctionBody.ts
index 7a297fdc..364a0923 100644
--- a/src/slang-nodes/FunctionBody.ts
+++ b/src/slang-nodes/FunctionBody.ts
@@ -2,7 +2,7 @@ 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';
 
@@ -10,7 +10,7 @@ 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;
diff --git a/src/slang-nodes/FunctionDefinition.ts b/src/slang-nodes/FunctionDefinition.ts
index 32df3faf..a59d7afb 100644
--- a/src/slang-nodes/FunctionDefinition.ts
+++ b/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,7 +17,7 @@ import type { AstNode } from './types.d.ts';
 export class FunctionDefinition extends SlangNode {
   readonly kind = NonterminalKind.FunctionDefinition;
 
-  name: FunctionName;
+  name: FunctionName['variant'];
 
   parameters: ParametersDeclaration;
 
@@ -25,18 +25,18 @@ export class FunctionDefinition extends SlangNode {
 
   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
diff --git a/src/slang-nodes/FunctionName.ts b/src/slang-nodes/FunctionName.ts
index b3f9620e..59cd6325 100644
--- a/src/slang-nodes/FunctionName.ts
+++ b/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;
diff --git a/src/slang-nodes/ImportClause.ts b/src/slang-nodes/ImportClause.ts
index 3c721dc5..58f3cd96 100644
--- a/src/slang-nodes/ImportClause.ts
+++ b/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;
diff --git a/src/slang-nodes/ImportDirective.ts b/src/slang-nodes/ImportDirective.ts
index a09d5313..0f89c160 100644
--- a/src/slang-nodes/ImportDirective.ts
+++ b/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'), ';'];
   }
 }
diff --git a/src/slang-nodes/MappingKey.ts b/src/slang-nodes/MappingKey.ts
index 997193fc..9c824815 100644
--- a/src/slang-nodes/MappingKey.ts
+++ b/src/slang-nodes/MappingKey.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 { MappingKeyType } from './MappingKeyType.js';
 import { TerminalNode } from './TerminalNode.js';
@@ -12,14 +12,14 @@ import type { PrintFunction } from '../types.d.ts';
 export class MappingKey extends SlangNode {
   readonly kind = NonterminalKind.MappingKey;
 
-  keyType: MappingKeyType;
+  keyType: MappingKeyType['variant'];
 
   name?: TerminalNode;
 
   constructor(ast: ast.MappingKey) {
     super(ast);
 
-    this.keyType = new MappingKeyType(ast.keyType);
+    this.keyType = extractVariant(new MappingKeyType(ast.keyType));
     if (ast.name) {
       this.name = new TerminalNode(ast.name);
     }
@@ -29,7 +29,7 @@ export class MappingKey extends SlangNode {
 
   print(path: AstPath<MappingKey>, print: PrintFunction): Doc {
     return joinExisting(' ', [
-      path.call(printVariant(print), 'keyType'),
+      path.call(print, 'keyType'),
       path.call(print, 'name')
     ]);
   }
diff --git a/src/slang-nodes/MappingKeyType.ts b/src/slang-nodes/MappingKeyType.ts
index ba0fac22..4aa3cbd9 100644
--- a/src/slang-nodes/MappingKeyType.ts
+++ b/src/slang-nodes/MappingKeyType.ts
@@ -1,7 +1,7 @@
 import * as ast from '@nomicfoundation/slang/ast';
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { extractVariant } from '../slang-utils/extract-variant.js';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { SlangNode } from './SlangNode.js';
 import { ElementaryType } from './ElementaryType.js';
 import { IdentifierPath } from './IdentifierPath.js';
 
@@ -18,7 +18,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class MappingKeyType extends PolymorphicNode {
+export class MappingKeyType extends SlangNode {
   readonly kind = NonterminalKind.MappingKeyType;
 
   variant: ElementaryType['variant'] | IdentifierPath;
diff --git a/src/slang-nodes/MappingValue.ts b/src/slang-nodes/MappingValue.ts
index 7221d9d5..e22917a2 100644
--- a/src/slang-nodes/MappingValue.ts
+++ b/src/slang-nodes/MappingValue.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 MappingValue extends SlangNode {
   readonly kind = NonterminalKind.MappingValue;
 
-  typeName: TypeName;
+  typeName: TypeName['variant'];
 
   name?: TerminalNode;
 
   constructor(ast: ast.MappingValue, 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 MappingValue extends SlangNode {
 
   print(path: AstPath<MappingValue>, print: PrintFunction): Doc {
     return joinExisting(' ', [
-      path.call(printVariant(print), 'typeName'),
+      path.call(print, 'typeName'),
       path.call(print, 'name')
     ]);
   }
diff --git a/src/slang-nodes/ModifierDefinition.ts b/src/slang-nodes/ModifierDefinition.ts
index af3cc526..d668f397 100644
--- a/src/slang-nodes/ModifierDefinition.ts
+++ b/src/slang-nodes/ModifierDefinition.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 { TerminalNode } from './TerminalNode.js';
 import { ParametersDeclaration } from './ParametersDeclaration.js';
@@ -21,7 +22,7 @@ export class ModifierDefinition extends SlangNode {
 
   attributes: ModifierAttributes;
 
-  body: FunctionBody;
+  body: FunctionBody['variant'];
 
   constructor(ast: ast.ModifierDefinition, options: ParserOptions<AstNode>) {
     super(ast);
@@ -31,7 +32,7 @@ export class ModifierDefinition extends SlangNode {
       this.parameters = new ParametersDeclaration(ast.parameters, options);
     }
     this.attributes = new ModifierAttributes(ast.attributes);
-    this.body = new FunctionBody(ast.body, options);
+    this.body = extractVariant(new FunctionBody(ast.body, options));
 
     this.updateMetadata(this.parameters, this.attributes, this.body);
 
diff --git a/src/slang-nodes/NewExpression.ts b/src/slang-nodes/NewExpression.ts
index 972606fa..e022c17f 100644
--- a/src/slang-nodes/NewExpression.ts
+++ b/src/slang-nodes/NewExpression.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 { TypeName } from './TypeName.js';
 
@@ -11,17 +11,17 @@ import type { AstNode } from './types.d.ts';
 export class NewExpression extends SlangNode {
   readonly kind = NonterminalKind.NewExpression;
 
-  typeName: TypeName;
+  typeName: TypeName['variant'];
 
   constructor(ast: ast.NewExpression, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.typeName = new TypeName(ast.typeName, options);
+    this.typeName = extractVariant(new TypeName(ast.typeName, options));
 
     this.updateMetadata(this.typeName);
   }
 
   print(path: AstPath<NewExpression>, print: PrintFunction): Doc {
-    return ['new ', path.call(printVariant(print), 'typeName')];
+    return ['new ', path.call(print, 'typeName')];
   }
 }
diff --git a/src/slang-nodes/Parameter.ts b/src/slang-nodes/Parameter.ts
index 0f371faa..f2a6c3b9 100644
--- a/src/slang-nodes/Parameter.ts
+++ b/src/slang-nodes/Parameter.ts
@@ -1,7 +1,7 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { doc } from 'prettier';
 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 { StorageLocation } from './StorageLocation.js';
@@ -17,7 +17,7 @@ const { group } = doc.builders;
 export class Parameter extends SlangNode {
   readonly kind = NonterminalKind.Parameter;
 
-  typeName: TypeName;
+  typeName: TypeName['variant'];
 
   storageLocation?: StorageLocation;
 
@@ -26,7 +26,7 @@ export class Parameter extends SlangNode {
   constructor(ast: ast.Parameter, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.typeName = new TypeName(ast.typeName, options);
+    this.typeName = extractVariant(new TypeName(ast.typeName, options));
     if (ast.storageLocation) {
       this.storageLocation = new StorageLocation(ast.storageLocation);
     }
@@ -40,7 +40,7 @@ export class Parameter extends SlangNode {
   print(path: AstPath<Parameter>, print: PrintFunction): Doc {
     return group(
       joinExisting(' ', [
-        path.call(printVariant(print), 'typeName'),
+        path.call(print, 'typeName'),
         path.call(print, 'storageLocation'),
         path.call(print, 'name')
       ])
diff --git a/src/slang-nodes/PolymorphicNode.ts b/src/slang-nodes/PolymorphicNode.ts
deleted file mode 100644
index 2ff2cbbc..00000000
--- a/src/slang-nodes/PolymorphicNode.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { SlangNode } from './SlangNode.js';
-
-import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction, SlangAstNode } from '../types.d.ts';
-import type { StrictPolymorphicNode } from './types.d.ts';
-
-export abstract class PolymorphicNode extends SlangNode {
-  abstract variant: StrictPolymorphicNode['variant'];
-
-  constructor(ast: SlangAstNode) {
-    super(ast);
-  }
-
-  print(path: AstPath<PolymorphicNode>, print: PrintFunction): Doc {
-    return path.call(print, 'variant');
-  }
-}
diff --git a/src/slang-nodes/Pragma.ts b/src/slang-nodes/Pragma.ts
index 1206e2bb..9d06b2a4 100644
--- a/src/slang-nodes/Pragma.ts
+++ b/src/slang-nodes/Pragma.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 { AbicoderPragma } from './AbicoderPragma.js';
 import { ExperimentalPragma } from './ExperimentalPragma.js';
 import { VersionPragma } from './VersionPragma.js';
@@ -25,7 +25,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class Pragma extends PolymorphicNode {
+export class Pragma extends SlangNode {
   readonly kind = NonterminalKind.Pragma;
 
   variant: AbicoderPragma | ExperimentalPragma | VersionPragma;
diff --git a/src/slang-nodes/PragmaDirective.ts b/src/slang-nodes/PragmaDirective.ts
index 1f1666b1..3a928e7f 100644
--- a/src/slang-nodes/PragmaDirective.ts
+++ b/src/slang-nodes/PragmaDirective.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 { Pragma } from './Pragma.js';
 
@@ -11,17 +11,17 @@ import type { AstNode } from './types.d.ts';
 export class PragmaDirective extends SlangNode {
   readonly kind = NonterminalKind.PragmaDirective;
 
-  pragma: Pragma;
+  pragma: Pragma['variant'];
 
   constructor(ast: ast.PragmaDirective, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.pragma = new Pragma(ast.pragma, options);
+    this.pragma = extractVariant(new Pragma(ast.pragma, options));
 
     this.updateMetadata(this.pragma);
   }
 
   print(path: AstPath<PragmaDirective>, print: PrintFunction): Doc {
-    return ['pragma ', path.call(printVariant(print), 'pragma'), ';'];
+    return ['pragma ', path.call(print, 'pragma'), ';'];
   }
 }
diff --git a/src/slang-nodes/ReceiveFunctionDefinition.ts b/src/slang-nodes/ReceiveFunctionDefinition.ts
index bd21f024..27aa5469 100644
--- a/src/slang-nodes/ReceiveFunctionDefinition.ts
+++ b/src/slang-nodes/ReceiveFunctionDefinition.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 { ReceiveFunctionAttributes } from './ReceiveFunctionAttributes.js';
@@ -17,7 +18,7 @@ export class ReceiveFunctionDefinition extends SlangNode {
 
   attributes: ReceiveFunctionAttributes;
 
-  body: FunctionBody;
+  body: FunctionBody['variant'];
 
   constructor(
     ast: ast.ReceiveFunctionDefinition,
@@ -27,7 +28,7 @@ export class ReceiveFunctionDefinition extends SlangNode {
 
     this.parameters = new ParametersDeclaration(ast.parameters, options);
     this.attributes = new ReceiveFunctionAttributes(ast.attributes, options);
-    this.body = new FunctionBody(ast.body, options);
+    this.body = extractVariant(new FunctionBody(ast.body, options));
 
     this.updateMetadata(this.parameters, this.attributes, this.body);
 
diff --git a/src/slang-nodes/StateVariableDefinition.ts b/src/slang-nodes/StateVariableDefinition.ts
index 1d7bdd83..a4f5d34f 100644
--- a/src/slang-nodes/StateVariableDefinition.ts
+++ b/src/slang-nodes/StateVariableDefinition.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 { TypeName } from './TypeName.js';
 import { StateVariableAttributes } from './StateVariableAttributes.js';
@@ -18,7 +18,7 @@ const { indent } = doc.builders;
 export class StateVariableDefinition extends SlangNode {
   readonly kind = NonterminalKind.StateVariableDefinition;
 
-  typeName: TypeName;
+  typeName: TypeName['variant'];
 
   attributes: StateVariableAttributes;
 
@@ -32,7 +32,7 @@ export class StateVariableDefinition extends SlangNode {
   ) {
     super(ast);
 
-    this.typeName = new TypeName(ast.typeName, options);
+    this.typeName = extractVariant(new TypeName(ast.typeName, options));
     this.attributes = new StateVariableAttributes(ast.attributes);
     this.name = new TerminalNode(ast.name);
     if (ast.value) {
@@ -45,7 +45,7 @@ export class StateVariableDefinition extends SlangNode {
   print(path: AstPath<StateVariableDefinition>, print: PrintFunction): Doc {
     return printGroupAndIndentIfBreakPair(
       [
-        path.call(printVariant(print), 'typeName'),
+        path.call(print, 'typeName'),
         indent(path.call(print, 'attributes')),
         ' ',
         path.call(print, 'name')
diff --git a/src/slang-nodes/StringExpression.ts b/src/slang-nodes/StringExpression.ts
index 5b074af5..7dac815d 100644
--- a/src/slang-nodes/StringExpression.ts
+++ b/src/slang-nodes/StringExpression.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 { StringLiteral } from './StringLiteral.js';
 import { StringLiterals } from './StringLiterals.js';
 import { HexStringLiteral } from './HexStringLiteral.js';
@@ -33,7 +33,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class StringExpression extends PolymorphicNode {
+export class StringExpression extends SlangNode {
   readonly kind = NonterminalKind.StringExpression;
 
   variant:
diff --git a/src/slang-nodes/StructMember.ts b/src/slang-nodes/StructMember.ts
index 581a4965..bfc8fa75 100644
--- a/src/slang-nodes/StructMember.ts
+++ b/src/slang-nodes/StructMember.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 { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
@@ -12,25 +12,20 @@ import type { AstNode } from './types.d.ts';
 export class StructMember extends SlangNode {
   readonly kind = NonterminalKind.StructMember;
 
-  typeName: TypeName;
+  typeName: TypeName['variant'];
 
   name: TerminalNode;
 
   constructor(ast: ast.StructMember, 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.updateMetadata(this.typeName);
   }
 
   print(path: AstPath<StructMember>, print: PrintFunction): Doc {
-    return [
-      path.call(printVariant(print), 'typeName'),
-      ' ',
-      path.call(print, 'name'),
-      ';'
-    ];
+    return [path.call(print, 'typeName'), ' ', path.call(print, 'name'), ';'];
   }
 }
diff --git a/src/slang-nodes/TupleDeconstructionElement.ts b/src/slang-nodes/TupleDeconstructionElement.ts
index 8c7c27d7..4a6c0493 100644
--- a/src/slang-nodes/TupleDeconstructionElement.ts
+++ b/src/slang-nodes/TupleDeconstructionElement.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 { TupleMember } from './TupleMember.js';
 
@@ -11,7 +11,7 @@ import type { AstNode } from './types.d.ts';
 export class TupleDeconstructionElement extends SlangNode {
   readonly kind = NonterminalKind.TupleDeconstructionElement;
 
-  member?: TupleMember;
+  member?: TupleMember['variant'];
 
   constructor(
     ast: ast.TupleDeconstructionElement,
@@ -20,13 +20,13 @@ export class TupleDeconstructionElement extends SlangNode {
     super(ast);
 
     if (ast.member) {
-      this.member = new TupleMember(ast.member, options);
+      this.member = extractVariant(new TupleMember(ast.member, options));
     }
 
     this.updateMetadata(this.member);
   }
 
   print(path: AstPath<TupleDeconstructionElement>, print: PrintFunction): Doc {
-    return path.call(printVariant(print), 'member');
+    return path.call(print, 'member');
   }
 }
diff --git a/src/slang-nodes/TupleMember.ts b/src/slang-nodes/TupleMember.ts
index 19b3b378..4eb3bbe0 100644
--- a/src/slang-nodes/TupleMember.ts
+++ b/src/slang-nodes/TupleMember.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 { TypedTupleMember } from './TypedTupleMember.js';
 import { UntypedTupleMember } from './UntypedTupleMember.js';
 
@@ -21,7 +21,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class TupleMember extends PolymorphicNode {
+export class TupleMember extends SlangNode {
   readonly kind = NonterminalKind.TupleMember;
 
   variant: TypedTupleMember | UntypedTupleMember;
diff --git a/src/slang-nodes/TypeExpression.ts b/src/slang-nodes/TypeExpression.ts
index dc1fe0f5..14d87f05 100644
--- a/src/slang-nodes/TypeExpression.ts
+++ b/src/slang-nodes/TypeExpression.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 { TypeName } from './TypeName.js';
 
@@ -11,17 +11,17 @@ import type { AstNode } from './types.d.ts';
 export class TypeExpression extends SlangNode {
   readonly kind = NonterminalKind.TypeExpression;
 
-  typeName: TypeName;
+  typeName: TypeName['variant'];
 
   constructor(ast: ast.TypeExpression, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.typeName = new TypeName(ast.typeName, options);
+    this.typeName = extractVariant(new TypeName(ast.typeName, options));
 
     this.updateMetadata(this.typeName);
   }
 
   print(path: AstPath<TypeExpression>, print: PrintFunction): Doc {
-    return ['type(', path.call(printVariant(print), 'typeName'), ')'];
+    return ['type(', path.call(print, 'typeName'), ')'];
   }
 }
diff --git a/src/slang-nodes/TypeName.ts b/src/slang-nodes/TypeName.ts
index 341a1e7a..e4868c37 100644
--- a/src/slang-nodes/TypeName.ts
+++ b/src/slang-nodes/TypeName.ts
@@ -1,7 +1,7 @@
 import * as ast from '@nomicfoundation/slang/ast';
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { extractVariant } from '../slang-utils/extract-variant.js';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { SlangNode } from './SlangNode.js';
 import { ArrayTypeName } from './ArrayTypeName.js';
 import { FunctionType } from './FunctionType.js';
 import { MappingType } from './MappingType.js';
@@ -34,7 +34,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class TypeName extends PolymorphicNode {
+export class TypeName extends SlangNode {
   readonly kind = NonterminalKind.TypeName;
 
   variant:
diff --git a/src/slang-nodes/TypedTupleMember.ts b/src/slang-nodes/TypedTupleMember.ts
index 700ed2ce..2cf82bd7 100644
--- a/src/slang-nodes/TypedTupleMember.ts
+++ b/src/slang-nodes/TypedTupleMember.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 { StorageLocation } from './StorageLocation.js';
@@ -14,7 +14,7 @@ import type { AstNode } from './types.d.ts';
 export class TypedTupleMember extends SlangNode {
   readonly kind = NonterminalKind.TypedTupleMember;
 
-  typeName: TypeName;
+  typeName: TypeName['variant'];
 
   storageLocation?: StorageLocation;
 
@@ -23,7 +23,7 @@ export class TypedTupleMember extends SlangNode {
   constructor(ast: ast.TypedTupleMember, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.typeName = new TypeName(ast.typeName, options);
+    this.typeName = extractVariant(new TypeName(ast.typeName, options));
     if (ast.storageLocation) {
       this.storageLocation = new StorageLocation(ast.storageLocation);
     }
@@ -34,7 +34,7 @@ export class TypedTupleMember extends SlangNode {
 
   print(path: AstPath<TypedTupleMember>, print: PrintFunction): Doc {
     return joinExisting(' ', [
-      path.call(printVariant(print), 'typeName'),
+      path.call(print, 'typeName'),
       path.call(print, 'storageLocation'),
       path.call(print, 'name')
     ]);
diff --git a/src/slang-nodes/UnnamedFunctionDefinition.ts b/src/slang-nodes/UnnamedFunctionDefinition.ts
index f2251440..71a0c841 100644
--- a/src/slang-nodes/UnnamedFunctionDefinition.ts
+++ b/src/slang-nodes/UnnamedFunctionDefinition.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 { UnnamedFunctionAttributes } from './UnnamedFunctionAttributes.js';
@@ -17,7 +18,7 @@ export class UnnamedFunctionDefinition extends SlangNode {
 
   attributes: UnnamedFunctionAttributes;
 
-  body: FunctionBody;
+  body: FunctionBody['variant'];
 
   constructor(
     ast: ast.UnnamedFunctionDefinition,
@@ -27,7 +28,7 @@ export class UnnamedFunctionDefinition extends SlangNode {
 
     this.parameters = new ParametersDeclaration(ast.parameters, options);
     this.attributes = new UnnamedFunctionAttributes(ast.attributes, options);
-    this.body = new FunctionBody(ast.body, options);
+    this.body = extractVariant(new FunctionBody(ast.body, options));
 
     this.updateMetadata(this.parameters, this.attributes, this.body);
 
diff --git a/src/slang-nodes/UsingClause.ts b/src/slang-nodes/UsingClause.ts
index a1f8f821..e619b60c 100644
--- a/src/slang-nodes/UsingClause.ts
+++ b/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;
diff --git a/src/slang-nodes/UsingDirective.ts b/src/slang-nodes/UsingDirective.ts
index 8383f758..10f1789a 100644
--- a/src/slang-nodes/UsingDirective.ts
+++ b/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;' : ';'
     ];
   }
diff --git a/src/slang-nodes/UsingTarget.ts b/src/slang-nodes/UsingTarget.ts
index 8eaeb149..74d07e77 100644
--- a/src/slang-nodes/UsingTarget.ts
+++ b/src/slang-nodes/UsingTarget.ts
@@ -2,7 +2,8 @@ import {
   NonterminalKind,
   TerminalNode as SlangTerminalNode
 } from '@nomicfoundation/slang/cst';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
+import { SlangNode } from './SlangNode.js';
 import { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
 
@@ -10,10 +11,10 @@ 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 | TerminalNode;
+  variant: TypeName['variant'] | TerminalNode;
 
   constructor(ast: ast.UsingTarget, options: ParserOptions<AstNode>) {
     super(ast);
@@ -23,7 +24,7 @@ export class UsingTarget extends PolymorphicNode {
       this.variant = new TerminalNode(variant);
       return;
     }
-    this.variant = new TypeName(variant, options);
+    this.variant = extractVariant(new TypeName(variant, options));
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/VariableDeclarationStatement.ts b/src/slang-nodes/VariableDeclarationStatement.ts
index ee5d1fad..b777d637 100644
--- a/src/slang-nodes/VariableDeclarationStatement.ts
+++ b/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')])
           : '',
diff --git a/src/slang-nodes/VariableDeclarationType.ts b/src/slang-nodes/VariableDeclarationType.ts
index d1731222..99bfff66 100644
--- a/src/slang-nodes/VariableDeclarationType.ts
+++ b/src/slang-nodes/VariableDeclarationType.ts
@@ -2,7 +2,8 @@ import {
   NonterminalKind,
   TerminalNode as SlangTerminalNode
 } from '@nomicfoundation/slang/cst';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
+import { SlangNode } from './SlangNode.js';
 import { TypeName } from './TypeName.js';
 import { TerminalNode } from './TerminalNode.js';
 
@@ -10,10 +11,10 @@ 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 | TerminalNode;
+  variant: TypeName['variant'] | TerminalNode;
 
   constructor(
     ast: ast.VariableDeclarationType,
@@ -26,7 +27,7 @@ export class VariableDeclarationType extends PolymorphicNode {
       this.variant = new TerminalNode(variant);
       return;
     }
-    this.variant = new TypeName(variant, options);
+    this.variant = extractVariant(new TypeName(variant, options));
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/VersionExpression.ts b/src/slang-nodes/VersionExpression.ts
index abb1cb85..1385e3ee 100644
--- a/src/slang-nodes/VersionExpression.ts
+++ b/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;
diff --git a/src/slang-nodes/VersionExpressionSet.ts b/src/slang-nodes/VersionExpressionSet.ts
index 1cbf99ed..25d58d6c 100644
--- a/src/slang-nodes/VersionExpressionSet.ts
+++ b/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'));
   }
 }
diff --git a/src/slang-nodes/VersionLiteral.ts b/src/slang-nodes/VersionLiteral.ts
index fa809017..6d13cfb2 100644
--- a/src/slang-nodes/VersionLiteral.ts
+++ b/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;
diff --git a/src/slang-nodes/VersionRange.ts b/src/slang-nodes/VersionRange.ts
index f4cd5da4..9da999c9 100644
--- a/src/slang-nodes/VersionRange.ts
+++ b/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')];
   }
 }
diff --git a/src/slang-nodes/VersionTerm.ts b/src/slang-nodes/VersionTerm.ts
index 201064e6..e4a2dfc0 100644
--- a/src/slang-nodes/VersionTerm.ts
+++ b/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,7 +13,7 @@ export class VersionTerm extends SlangNode {
 
   operator?: VersionOperator;
 
-  literal: VersionLiteral;
+  literal: VersionLiteral['variant'];
 
   constructor(ast: ast.VersionTerm) {
     super(ast);
@@ -21,15 +21,12 @@ export class VersionTerm extends SlangNode {
     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')];
   }
 }
diff --git a/src/slang-nodes/YulArguments.ts b/src/slang-nodes/YulArguments.ts
index 20e701a2..1309f3f1 100644
--- a/src/slang-nodes/YulArguments.ts
+++ b/src/slang-nodes/YulArguments.ts
@@ -1,6 +1,6 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printSeparatedList } from '../slang-printers/print-separated-list.js';
-import { printVariant } from '../slang-printers/print-variant.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { YulExpression } from './YulExpression.js';
 
@@ -12,15 +12,17 @@ import type { AstNode } from './types.d.ts';
 export class YulArguments extends SlangNode {
   readonly kind = NonterminalKind.YulArguments;
 
-  items: YulExpression[];
+  items: YulExpression['variant'][];
 
   constructor(ast: ast.YulArguments, options: ParserOptions<AstNode>) {
     super(ast, true);
 
-    this.items = ast.items.map((item) => new YulExpression(item, options));
+    this.items = ast.items.map((item) =>
+      extractVariant(new YulExpression(item, options))
+    );
   }
 
   print(path: AstPath<YulArguments>, print: PrintFunction): Doc {
-    return printSeparatedList(path.map(printVariant(print), 'items'));
+    return printSeparatedList(path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/YulAssignmentOperator.ts b/src/slang-nodes/YulAssignmentOperator.ts
index c8453b73..e23ebed1 100644
--- a/src/slang-nodes/YulAssignmentOperator.ts
+++ b/src/slang-nodes/YulAssignmentOperator.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 { YulColonAndEqual } from './YulColonAndEqual.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 
-export class YulAssignmentOperator extends PolymorphicNode {
+export class YulAssignmentOperator extends SlangNode {
   readonly kind = NonterminalKind.YulAssignmentOperator;
 
   variant: YulColonAndEqual | TerminalNode;
diff --git a/src/slang-nodes/YulExpression.ts b/src/slang-nodes/YulExpression.ts
index 6afa8526..66de092b 100644
--- a/src/slang-nodes/YulExpression.ts
+++ b/src/slang-nodes/YulExpression.ts
@@ -1,6 +1,7 @@
 import * as ast from '@nomicfoundation/slang/ast';
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { PolymorphicNode } from './PolymorphicNode.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
+import { SlangNode } from './SlangNode.js';
 import { YulFunctionCallExpression } from './YulFunctionCallExpression.js';
 import { YulLiteral } from './YulLiteral.js';
 import { YulPath } from './YulPath.js';
@@ -16,7 +17,7 @@ function createNonterminalVariant(
     return new YulFunctionCallExpression(variant, options);
   }
   if (variant instanceof ast.YulLiteral) {
-    return new YulLiteral(variant, options);
+    return extractVariant(new YulLiteral(variant, options));
   }
   if (variant instanceof ast.YulPath) {
     return new YulPath(variant);
@@ -25,10 +26,10 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class YulExpression extends PolymorphicNode {
+export class YulExpression extends SlangNode {
   readonly kind = NonterminalKind.YulExpression;
 
-  variant: YulFunctionCallExpression | YulLiteral | YulPath;
+  variant: YulFunctionCallExpression | YulLiteral['variant'] | YulPath;
 
   constructor(ast: ast.YulExpression, options: ParserOptions<AstNode>) {
     super(ast);
diff --git a/src/slang-nodes/YulForStatement.ts b/src/slang-nodes/YulForStatement.ts
index c77d88e1..1fdeb2b8 100644
--- a/src/slang-nodes/YulForStatement.ts
+++ b/src/slang-nodes/YulForStatement.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 { YulBlock } from './YulBlock.js';
 import { YulExpression } from './YulExpression.js';
@@ -17,7 +17,7 @@ export class YulForStatement extends SlangNode {
 
   initialization: YulBlock;
 
-  condition: YulExpression;
+  condition: YulExpression['variant'];
 
   iterator: YulBlock;
 
@@ -27,7 +27,7 @@ export class YulForStatement extends SlangNode {
     super(ast);
 
     this.initialization = new YulBlock(ast.initialization, options);
-    this.condition = new YulExpression(ast.condition, options);
+    this.condition = extractVariant(new YulExpression(ast.condition, options));
     this.iterator = new YulBlock(ast.iterator, options);
     this.body = new YulBlock(ast.body, options);
 
@@ -43,7 +43,7 @@ export class YulForStatement extends SlangNode {
     return join(' ', [
       'for',
       path.call(print, 'initialization'),
-      path.call(printVariant(print), 'condition'),
+      path.call(print, 'condition'),
       path.call(print, 'iterator'),
       path.call(print, 'body')
     ]);
diff --git a/src/slang-nodes/YulFunctionCallExpression.ts b/src/slang-nodes/YulFunctionCallExpression.ts
index 799d791a..6b5f5bc4 100644
--- a/src/slang-nodes/YulFunctionCallExpression.ts
+++ b/src/slang-nodes/YulFunctionCallExpression.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 { YulExpression } from './YulExpression.js';
 import { YulArguments } from './YulArguments.js';
@@ -12,7 +12,7 @@ import type { AstNode } from './types.d.ts';
 export class YulFunctionCallExpression extends SlangNode {
   readonly kind = NonterminalKind.YulFunctionCallExpression;
 
-  operand: YulExpression;
+  operand: YulExpression['variant'];
 
   arguments: YulArguments;
 
@@ -22,7 +22,7 @@ export class YulFunctionCallExpression extends SlangNode {
   ) {
     super(ast);
 
-    this.operand = new YulExpression(ast.operand, options);
+    this.operand = extractVariant(new YulExpression(ast.operand, options));
     this.arguments = new YulArguments(ast.arguments, options);
 
     this.updateMetadata(this.operand, this.arguments);
@@ -30,7 +30,7 @@ export class YulFunctionCallExpression extends SlangNode {
 
   print(path: AstPath<YulFunctionCallExpression>, print: PrintFunction): Doc {
     return [
-      path.call(printVariant(print), 'operand'),
+      path.call(print, 'operand'),
       '(',
       path.call(print, 'arguments'),
       ')'
diff --git a/src/slang-nodes/YulIfStatement.ts b/src/slang-nodes/YulIfStatement.ts
index 8298ea65..5be71f59 100644
--- a/src/slang-nodes/YulIfStatement.ts
+++ b/src/slang-nodes/YulIfStatement.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 { YulExpression } from './YulExpression.js';
 import { YulBlock } from './YulBlock.js';
@@ -12,14 +12,14 @@ import type { AstNode } from './types.d.ts';
 export class YulIfStatement extends SlangNode {
   readonly kind = NonterminalKind.YulIfStatement;
 
-  condition: YulExpression;
+  condition: YulExpression['variant'];
 
   body: YulBlock;
 
   constructor(ast: ast.YulIfStatement, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.condition = new YulExpression(ast.condition, options);
+    this.condition = extractVariant(new YulExpression(ast.condition, options));
     this.body = new YulBlock(ast.body, options);
 
     this.updateMetadata(this.condition, this.body);
@@ -28,7 +28,7 @@ export class YulIfStatement extends SlangNode {
   print(path: AstPath<YulIfStatement>, print: PrintFunction): Doc {
     return [
       'if ',
-      path.call(printVariant(print), 'condition'),
+      path.call(print, 'condition'),
       ' ',
       path.call(print, 'body')
     ];
diff --git a/src/slang-nodes/YulLiteral.ts b/src/slang-nodes/YulLiteral.ts
index e79a7c97..72ef7485 100644
--- a/src/slang-nodes/YulLiteral.ts
+++ b/src/slang-nodes/YulLiteral.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 { HexStringLiteral } from './HexStringLiteral.js';
 import { StringLiteral } from './StringLiteral.js';
 import { TerminalNode } from './TerminalNode.js';
@@ -25,7 +25,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class YulLiteral extends PolymorphicNode {
+export class YulLiteral extends SlangNode {
   readonly kind = NonterminalKind.YulLiteral;
 
   variant: HexStringLiteral | StringLiteral | TerminalNode;
diff --git a/src/slang-nodes/YulStackAssignmentOperator.ts b/src/slang-nodes/YulStackAssignmentOperator.ts
index 9bcf338b..0318ae8b 100644
--- a/src/slang-nodes/YulStackAssignmentOperator.ts
+++ b/src/slang-nodes/YulStackAssignmentOperator.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 { YulEqualAndColon } from './YulEqualAndColon.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 
-export class YulStackAssignmentOperator extends PolymorphicNode {
+export class YulStackAssignmentOperator extends SlangNode {
   readonly kind = NonterminalKind.YulStackAssignmentOperator;
 
   variant: YulEqualAndColon | TerminalNode;
diff --git a/src/slang-nodes/YulStackAssignmentStatement.ts b/src/slang-nodes/YulStackAssignmentStatement.ts
index f8723b72..e2bd9998 100644
--- a/src/slang-nodes/YulStackAssignmentStatement.ts
+++ b/src/slang-nodes/YulStackAssignmentStatement.ts
@@ -1,7 +1,7 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { doc } from 'prettier';
 import { printSeparatedItem } from '../slang-printers/print-separated-item.js';
-import { printVariant } from '../slang-printers/print-variant.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { YulStackAssignmentOperator } from './YulStackAssignmentOperator.js';
 import { TerminalNode } from './TerminalNode.js';
@@ -15,14 +15,16 @@ const { line } = doc.builders;
 export class YulStackAssignmentStatement extends SlangNode {
   readonly kind = NonterminalKind.YulStackAssignmentStatement;
 
-  assignment: YulStackAssignmentOperator;
+  assignment: YulStackAssignmentOperator['variant'];
 
   variable: TerminalNode;
 
   constructor(ast: ast.YulStackAssignmentStatement) {
     super(ast);
 
-    this.assignment = new YulStackAssignmentOperator(ast.assignment);
+    this.assignment = extractVariant(
+      new YulStackAssignmentOperator(ast.assignment)
+    );
     this.variable = new TerminalNode(ast.variable);
 
     this.updateMetadata(this.assignment);
@@ -30,7 +32,7 @@ export class YulStackAssignmentStatement extends SlangNode {
 
   print(path: AstPath<YulStackAssignmentStatement>, print: PrintFunction): Doc {
     return [
-      path.call(printVariant(print), 'assignment'),
+      path.call(print, 'assignment'),
       printSeparatedItem(path.call(print, 'variable'), {
         firstSeparator: line,
         lastSeparator: ''
diff --git a/src/slang-nodes/YulStatement.ts b/src/slang-nodes/YulStatement.ts
index efe91c78..6d711899 100644
--- a/src/slang-nodes/YulStatement.ts
+++ b/src/slang-nodes/YulStatement.ts
@@ -1,5 +1,6 @@
 import * as ast from '@nomicfoundation/slang/ast';
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { YulBlock } from './YulBlock.js';
 import { YulFunctionDefinition } from './YulFunctionDefinition.js';
@@ -59,7 +60,7 @@ function createNonterminalVariant(
     return new YulLabel(variant);
   }
   if (variant instanceof ast.YulExpression) {
-    return new YulExpression(variant, options);
+    return extractVariant(new YulExpression(variant, options));
   }
   const exhaustiveCheck: never = variant;
   return exhaustiveCheck;
@@ -81,7 +82,7 @@ export class YulStatement extends SlangNode {
     | YulBreakStatement
     | YulContinueStatement
     | YulLabel
-    | YulExpression;
+    | YulExpression['variant'];
 
   constructor(ast: ast.YulStatement, options: ParserOptions<AstNode>) {
     super(ast);
diff --git a/src/slang-nodes/YulSwitchCase.ts b/src/slang-nodes/YulSwitchCase.ts
index 12fedd3f..3c629e55 100644
--- a/src/slang-nodes/YulSwitchCase.ts
+++ b/src/slang-nodes/YulSwitchCase.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 { YulDefaultCase } from './YulDefaultCase.js';
 import { YulValueCase } from './YulValueCase.js';
 
@@ -21,7 +21,7 @@ function createNonterminalVariant(
   return exhaustiveCheck;
 }
 
-export class YulSwitchCase extends PolymorphicNode {
+export class YulSwitchCase extends SlangNode {
   readonly kind = NonterminalKind.YulSwitchCase;
 
   variant: YulDefaultCase | YulValueCase;
diff --git a/src/slang-nodes/YulSwitchCases.ts b/src/slang-nodes/YulSwitchCases.ts
index 841efb11..0b0d672b 100644
--- a/src/slang-nodes/YulSwitchCases.ts
+++ b/src/slang-nodes/YulSwitchCases.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 { YulSwitchCase } from './YulSwitchCase.js';
 
@@ -14,15 +14,17 @@ const { hardline, join } = doc.builders;
 export class YulSwitchCases extends SlangNode {
   readonly kind = NonterminalKind.YulSwitchCases;
 
-  items: YulSwitchCase[];
+  items: YulSwitchCase['variant'][];
 
   constructor(ast: ast.YulSwitchCases, options: ParserOptions<AstNode>) {
     super(ast, true);
 
-    this.items = ast.items.map((item) => new YulSwitchCase(item, options));
+    this.items = ast.items.map((item) =>
+      extractVariant(new YulSwitchCase(item, options))
+    );
   }
 
   print(path: AstPath<YulSwitchCases>, print: PrintFunction): Doc {
-    return join(hardline, path.map(printVariant(print), 'items'));
+    return join(hardline, path.map(print, 'items'));
   }
 }
diff --git a/src/slang-nodes/YulSwitchStatement.ts b/src/slang-nodes/YulSwitchStatement.ts
index f131eb55..319fa26b 100644
--- a/src/slang-nodes/YulSwitchStatement.ts
+++ b/src/slang-nodes/YulSwitchStatement.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 { YulExpression } from './YulExpression.js';
 import { YulSwitchCases } from './YulSwitchCases.js';
@@ -15,14 +15,16 @@ const { hardline } = doc.builders;
 export class YulSwitchStatement extends SlangNode {
   readonly kind = NonterminalKind.YulSwitchStatement;
 
-  expression: YulExpression;
+  expression: YulExpression['variant'];
 
   cases: YulSwitchCases;
 
   constructor(ast: ast.YulSwitchStatement, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.expression = new YulExpression(ast.expression, options);
+    this.expression = extractVariant(
+      new YulExpression(ast.expression, options)
+    );
     this.cases = new YulSwitchCases(ast.cases, options);
 
     this.updateMetadata(this.expression, this.cases);
@@ -31,7 +33,7 @@ export class YulSwitchStatement extends SlangNode {
   print(path: AstPath<YulSwitchStatement>, print: PrintFunction): Doc {
     return [
       'switch ',
-      path.call(printVariant(print), 'expression'),
+      path.call(print, 'expression'),
       hardline,
       path.call(print, 'cases')
     ];
diff --git a/src/slang-nodes/YulValueCase.ts b/src/slang-nodes/YulValueCase.ts
index 76ed8165..7a8c43c1 100644
--- a/src/slang-nodes/YulValueCase.ts
+++ b/src/slang-nodes/YulValueCase.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 { YulLiteral } from './YulLiteral.js';
 import { YulBlock } from './YulBlock.js';
@@ -12,25 +12,20 @@ import type { AstNode } from './types.d.ts';
 export class YulValueCase extends SlangNode {
   readonly kind = NonterminalKind.YulValueCase;
 
-  value: YulLiteral;
+  value: YulLiteral['variant'];
 
   body: YulBlock;
 
   constructor(ast: ast.YulValueCase, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.value = new YulLiteral(ast.value, options);
+    this.value = extractVariant(new YulLiteral(ast.value, options));
     this.body = new YulBlock(ast.body, options);
 
     this.updateMetadata(this.value, this.body);
   }
 
   print(path: AstPath<YulValueCase>, print: PrintFunction): Doc {
-    return [
-      'case ',
-      path.call(printVariant(print), 'value'),
-      ' ',
-      path.call(print, 'body')
-    ];
+    return ['case ', path.call(print, 'value'), ' ', path.call(print, 'body')];
   }
 }
diff --git a/src/slang-nodes/YulVariableAssignmentStatement.ts b/src/slang-nodes/YulVariableAssignmentStatement.ts
index 55551bc6..df314159 100644
--- a/src/slang-nodes/YulVariableAssignmentStatement.ts
+++ b/src/slang-nodes/YulVariableAssignmentStatement.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 { YulPaths } from './YulPaths.js';
 import { YulAssignmentOperator } from './YulAssignmentOperator.js';
@@ -18,9 +18,9 @@ export class YulVariableAssignmentStatement extends SlangNode {
 
   variables: YulPaths;
 
-  assignment: YulAssignmentOperator;
+  assignment: YulAssignmentOperator['variant'];
 
-  expression: YulExpression;
+  expression: YulExpression['variant'];
 
   constructor(
     ast: ast.YulVariableAssignmentStatement,
@@ -29,8 +29,10 @@ export class YulVariableAssignmentStatement extends SlangNode {
     super(ast);
 
     this.variables = new YulPaths(ast.variables);
-    this.assignment = new YulAssignmentOperator(ast.assignment);
-    this.expression = new YulExpression(ast.expression, options);
+    this.assignment = extractVariant(new YulAssignmentOperator(ast.assignment));
+    this.expression = extractVariant(
+      new YulExpression(ast.expression, options)
+    );
 
     this.updateMetadata(this.variables, this.assignment, this.expression);
   }
@@ -41,8 +43,8 @@ export class YulVariableAssignmentStatement extends SlangNode {
   ): Doc {
     return join(' ', [
       path.call(print, 'variables'),
-      path.call(printVariant(print), 'assignment'),
-      path.call(printVariant(print), 'expression')
+      path.call(print, 'assignment'),
+      path.call(print, 'expression')
     ]);
   }
 }
diff --git a/src/slang-nodes/YulVariableDeclarationValue.ts b/src/slang-nodes/YulVariableDeclarationValue.ts
index e6bffbfe..9a249df2 100644
--- a/src/slang-nodes/YulVariableDeclarationValue.ts
+++ b/src/slang-nodes/YulVariableDeclarationValue.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 { YulAssignmentOperator } from './YulAssignmentOperator.js';
 import { YulExpression } from './YulExpression.js';
@@ -12,9 +12,9 @@ import type { AstNode } from './types.d.ts';
 export class YulVariableDeclarationValue extends SlangNode {
   readonly kind = NonterminalKind.YulVariableDeclarationValue;
 
-  assignment: YulAssignmentOperator;
+  assignment: YulAssignmentOperator['variant'];
 
-  expression: YulExpression;
+  expression: YulExpression['variant'];
 
   constructor(
     ast: ast.YulVariableDeclarationValue,
@@ -22,17 +22,19 @@ export class YulVariableDeclarationValue extends SlangNode {
   ) {
     super(ast);
 
-    this.assignment = new YulAssignmentOperator(ast.assignment);
-    this.expression = new YulExpression(ast.expression, options);
+    this.assignment = extractVariant(new YulAssignmentOperator(ast.assignment));
+    this.expression = extractVariant(
+      new YulExpression(ast.expression, options)
+    );
 
     this.updateMetadata(this.assignment, this.expression);
   }
 
   print(path: AstPath<YulVariableDeclarationValue>, print: PrintFunction): Doc {
     return [
-      path.call(printVariant(print), 'assignment'),
+      path.call(print, 'assignment'),
       ' ',
-      path.call(printVariant(print), 'expression')
+      path.call(print, 'expression')
     ];
   }
 }
diff --git a/src/slang-printers/print-binary-operation.ts b/src/slang-printers/print-binary-operation.ts
index 21361ea4..b0feabe9 100644
--- a/src/slang-printers/print-binary-operation.ts
+++ b/src/slang-printers/print-binary-operation.ts
@@ -38,7 +38,7 @@ export const shouldNotIndent = (
   isStatementWithoutIndentedOperation(node) ||
   (node.kind === NonterminalKind.ExpressionStatement &&
     (path.getNode(index + 1) as StrictAstNode).kind ===
-      NonterminalKind.ForStatementCondition);
+      NonterminalKind.ForStatement);
 
 export const binaryIndentRulesBuilder =
   (shouldIndent: (node: BinaryOperation) => boolean) =>
diff --git a/src/slang-printers/print-function.ts b/src/slang-printers/print-function.ts
index b727cf4c..024eb111 100644
--- a/src/slang-printers/print-function.ts
+++ b/src/slang-printers/print-function.ts
@@ -1,13 +1,9 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { doc } from 'prettier';
 import { joinExisting } from '../slang-utils/join-existing.js';
-import { printVariant } from './print-variant.js';
 
 import type { AstPath, Doc } from 'prettier';
-import type {
-  FunctionLike,
-  StrictPolymorphicNode
-} from '../slang-nodes/types.d.ts';
+import type { FunctionLike } from '../slang-nodes/types.d.ts';
 import type { PrintFunction } from '../types.d.ts';
 import type { FunctionBody } from '../slang-nodes/FunctionBody.js';
 
@@ -19,7 +15,9 @@ export function printFunction(
   path: AstPath<FunctionLike>,
   print: PrintFunction
 ): Doc {
-  const body = (node as Extract<FunctionLike, { body: FunctionBody }>).body;
+  const body = (
+    node as Extract<FunctionLike, { body: FunctionBody['variant'] }>
+  ).body;
 
   return group([
     functionName,
@@ -30,9 +28,7 @@ export function printFunction(
           path.call(print, 'attributes'),
           path.call(print, 'returns')
         ]),
-        body && (!body.variant || body.variant.kind === NonterminalKind.Block)
-          ? dedent(line)
-          : ''
+        body && body.kind === NonterminalKind.Block ? dedent(line) : ''
       ])
     )
   ]);
@@ -46,12 +42,6 @@ export function printFunctionWithBody(
 ): Doc {
   return [
     printFunction(functionName, node, path, print),
-    node.kind !== NonterminalKind.ConstructorDefinition
-      ? (
-          path as AstPath<
-            Extract<FunctionLike, { body: StrictPolymorphicNode }>
-          >
-        ).call(printVariant(print), 'body')
-      : path.call(print, 'body')
+    path.call(print, 'body')
   ];
 }
diff --git a/src/slang-printers/print-variant.ts b/src/slang-printers/print-variant.ts
deleted file mode 100644
index 9499147b..00000000
--- a/src/slang-printers/print-variant.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
-import type { StrictPolymorphicNode } from '../slang-nodes/types.d.ts';
-
-export const printVariant =
-  (print: PrintFunction) =>
-  (path: AstPath<StrictPolymorphicNode | undefined>): Doc => {
-    const node = path.node;
-    if (!node) return '';
-    return node.comments && node.comments.length > 0
-      ? print(path)
-      : path.call(print, 'variant');
-  };
diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts
index 4e4ab9ff..295d9a07 100644
--- a/src/slangPrinter.ts
+++ b/src/slangPrinter.ts
@@ -2,25 +2,12 @@ import { isBlockComment } from './slang-utils/is-comment.js';
 import { locEnd, locStart } from './slang-utils/loc.js';
 
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { AstNode, StrictAstNode } from './slang-nodes/types.d.ts';
+import type {
+  AstNode,
+  StrictAstNode,
+  StrictPolymorphicNode
+} from './slang-nodes/types.d.ts';
 import type { PrintFunction } from './types.d.ts';
-import type { ArgumentsDeclaration } from './slang-nodes/ArgumentsDeclaration.js';
-import type { ConstructorAttribute } from './slang-nodes/ConstructorAttribute.js';
-import type { FallbackFunctionAttribute } from './slang-nodes/FallbackFunctionAttribute.js';
-import type { FunctionAttribute } from './slang-nodes/FunctionAttribute.js';
-import type { FunctionTypeAttribute } from './slang-nodes/FunctionTypeAttribute.js';
-import type { ModifierAttribute } from './slang-nodes/ModifierAttribute.js';
-import type { ReceiveFunctionAttribute } from './slang-nodes/ReceiveFunctionAttribute.js';
-import type { StateVariableAttribute } from './slang-nodes/StateVariableAttribute.js';
-import type { UnnamedFunctionAttribute } from './slang-nodes/UnnamedFunctionAttribute.js';
-import type { ContractMember } from './slang-nodes/ContractMember.js';
-import type { SourceUnitMember } from './slang-nodes/SourceUnitMember.js';
-import type { Statement } from './slang-nodes/Statement.js';
-import type { YulStatement } from './slang-nodes/YulStatement.js';
-import type { ContractSpecifier } from './slang-nodes/ContractSpecifier.js';
-import type { ElementaryType } from './slang-nodes/ElementaryType.js';
-import type { ExperimentalFeature } from './slang-nodes/ExperimentalFeature.js';
-import type { Expression } from './slang-nodes/Expression.js';
 
 function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean {
   // Prettier sets SourceUnit's comments to undefined after assigning comments
@@ -70,28 +57,7 @@ function ignoreComments(path: AstPath<AstNode>): void {
 // Nodes take care of undefined and string properties so we can restrict path
 // to AstPath<StrictAstNode>
 function genericPrint(
-  path: AstPath<
-    Exclude<
-      StrictAstNode,
-      | ArgumentsDeclaration
-      | ConstructorAttribute
-      | FallbackFunctionAttribute
-      | FunctionAttribute
-      | FunctionTypeAttribute
-      | ModifierAttribute
-      | ReceiveFunctionAttribute
-      | StateVariableAttribute
-      | UnnamedFunctionAttribute
-      | ContractMember
-      | SourceUnitMember
-      | Statement
-      | YulStatement
-      | ContractSpecifier
-      | ElementaryType
-      | ExperimentalFeature
-      | Expression
-    >
-  >,
+  path: AstPath<Exclude<StrictAstNode, StrictPolymorphicNode>>,
   options: ParserOptions<AstNode>,
   print: PrintFunction
 ): Doc {