diff --git a/src/slang-nodes/AbicoderPragma.ts b/src/slang-nodes/AbicoderPragma.ts
index 4bb8bfb36..249fee73a 100644
--- a/src/slang-nodes/AbicoderPragma.ts
+++ b/src/slang-nodes/AbicoderPragma.ts
@@ -4,17 +4,17 @@ import { AbicoderVersion } from './AbicoderVersion.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class AbicoderPragma extends SlangNode {
   readonly kind = NonterminalKind.AbicoderPragma;
 
   version: AbicoderVersion;
 
-  constructor(ast: ast.AbicoderPragma) {
-    super(ast);
+  constructor(ast: ast.AbicoderPragma, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.version = new AbicoderVersion(ast.version);
+    this.version = new AbicoderVersion(ast.version, collected);
   }
 
   print(path: AstPath<AbicoderPragma>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/AbicoderVersion.ts b/src/slang-nodes/AbicoderVersion.ts
index 3e12c13e8..d3926932b 100644
--- a/src/slang-nodes/AbicoderVersion.ts
+++ b/src/slang-nodes/AbicoderVersion.ts
@@ -3,14 +3,15 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class AbicoderVersion extends SlangNode {
   readonly kind = NonterminalKind.AbicoderVersion;
 
   variant: string;
 
-  constructor(ast: ast.AbicoderVersion) {
-    super(ast);
+  constructor(ast: ast.AbicoderVersion, collected: CollectedMetadata) {
+    super(ast, collected);
 
     this.variant = ast.variant.unparse();
   }
diff --git a/src/slang-nodes/AdditiveExpression.ts b/src/slang-nodes/AdditiveExpression.ts
index e11e235b9..f288bf0e4 100644
--- a/src/slang-nodes/AdditiveExpression.ts
+++ b/src/slang-nodes/AdditiveExpression.ts
@@ -8,7 +8,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const tryToHug = createHugFunction(['%']);
@@ -35,13 +35,19 @@ export class AdditiveExpression extends SlangNode {
 
   rightOperand: Expression['variant'];
 
-  constructor(ast: ast.AdditiveExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.AdditiveExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/AddressType.ts b/src/slang-nodes/AddressType.ts
index 86862359a..a3f1bea4e 100644
--- a/src/slang-nodes/AddressType.ts
+++ b/src/slang-nodes/AddressType.ts
@@ -3,14 +3,15 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class AddressType extends SlangNode {
   readonly kind = NonterminalKind.AddressType;
 
   payableKeyword?: string;
 
-  constructor(ast: ast.AddressType) {
-    super(ast);
+  constructor(ast: ast.AddressType, collected: CollectedMetadata) {
+    super(ast, collected);
 
     this.payableKeyword = ast.payableKeyword?.unparse();
   }
diff --git a/src/slang-nodes/AndExpression.ts b/src/slang-nodes/AndExpression.ts
index 20b9e79bc..6d8d6f955 100644
--- a/src/slang-nodes/AndExpression.ts
+++ b/src/slang-nodes/AndExpression.ts
@@ -6,7 +6,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class AndExpression extends SlangNode {
@@ -18,13 +18,19 @@ export class AndExpression extends SlangNode {
 
   rightOperand: Expression['variant'];
 
-  constructor(ast: ast.AndExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.AndExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/ArgumentsDeclaration.ts b/src/slang-nodes/ArgumentsDeclaration.ts
index a6b8f0988..5af16a582 100644
--- a/src/slang-nodes/ArgumentsDeclaration.ts
+++ b/src/slang-nodes/ArgumentsDeclaration.ts
@@ -5,17 +5,19 @@ import { PositionalArgumentsDeclaration } from './PositionalArgumentsDeclaration
 import { NamedArgumentsDeclaration } from './NamedArgumentsDeclaration.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.ArgumentsDeclaration['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): ArgumentsDeclaration['variant'] {
   if (variant instanceof ast.PositionalArgumentsDeclaration) {
-    return new PositionalArgumentsDeclaration(variant, options);
+    return new PositionalArgumentsDeclaration(variant, collected, options);
   }
   if (variant instanceof ast.NamedArgumentsDeclaration) {
-    return new NamedArgumentsDeclaration(variant, options);
+    return new NamedArgumentsDeclaration(variant, collected, options);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -26,10 +28,14 @@ export class ArgumentsDeclaration extends SlangNode {
 
   variant: PositionalArgumentsDeclaration | NamedArgumentsDeclaration;
 
-  constructor(ast: ast.ArgumentsDeclaration, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ArgumentsDeclaration,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ArrayExpression.ts b/src/slang-nodes/ArrayExpression.ts
index 4d9155cba..caef74b2b 100644
--- a/src/slang-nodes/ArrayExpression.ts
+++ b/src/slang-nodes/ArrayExpression.ts
@@ -4,7 +4,7 @@ import { ArrayValues } from './ArrayValues.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ArrayExpression extends SlangNode {
@@ -12,10 +12,14 @@ export class ArrayExpression extends SlangNode {
 
   items: ArrayValues;
 
-  constructor(ast: ast.ArrayExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ArrayExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.items = new ArrayValues(ast.items, options);
+    this.items = new ArrayValues(ast.items, collected, options);
   }
 
   print(path: AstPath<ArrayExpression>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/ArrayTypeName.ts b/src/slang-nodes/ArrayTypeName.ts
index eea23eb13..84411c91d 100644
--- a/src/slang-nodes/ArrayTypeName.ts
+++ b/src/slang-nodes/ArrayTypeName.ts
@@ -6,7 +6,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ArrayTypeName extends SlangNode {
@@ -16,12 +16,20 @@ export class ArrayTypeName extends SlangNode {
 
   index?: Expression['variant'];
 
-  constructor(ast: ast.ArrayTypeName, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ArrayTypeName,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.operand = extractVariant(new TypeName(ast.operand, options));
+    this.operand = extractVariant(
+      new TypeName(ast.operand, collected, options)
+    );
     if (ast.index) {
-      this.index = extractVariant(new Expression(ast.index, options));
+      this.index = extractVariant(
+        new Expression(ast.index, collected, options)
+      );
     }
 
     this.updateMetadata(this.operand, this.index);
diff --git a/src/slang-nodes/ArrayValues.ts b/src/slang-nodes/ArrayValues.ts
index 4d896e3b6..3a468d74b 100644
--- a/src/slang-nodes/ArrayValues.ts
+++ b/src/slang-nodes/ArrayValues.ts
@@ -6,7 +6,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ArrayValues extends SlangNode {
@@ -14,11 +14,15 @@ export class ArrayValues extends SlangNode {
 
   items: Expression['variant'][];
 
-  constructor(ast: ast.ArrayValues, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.ArrayValues,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new Expression(item, options))
+      extractVariant(new Expression(item, collected, options))
     );
   }
 
diff --git a/src/slang-nodes/AssemblyFlags.ts b/src/slang-nodes/AssemblyFlags.ts
index e5f54c8f2..ad883fcb5 100644
--- a/src/slang-nodes/AssemblyFlags.ts
+++ b/src/slang-nodes/AssemblyFlags.ts
@@ -5,7 +5,7 @@ import { StringLiteral } from './StringLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class AssemblyFlags extends SlangNode {
@@ -13,10 +13,16 @@ export class AssemblyFlags extends SlangNode {
 
   items: StringLiteral[];
 
-  constructor(ast: ast.AssemblyFlags, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.AssemblyFlags,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new StringLiteral(item, options));
+    this.items = ast.items.map(
+      (item) => new StringLiteral(item, collected, options)
+    );
   }
 
   print(path: AstPath<AssemblyFlags>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/AssemblyFlagsDeclaration.ts b/src/slang-nodes/AssemblyFlagsDeclaration.ts
index 8a827182a..22079d925 100644
--- a/src/slang-nodes/AssemblyFlagsDeclaration.ts
+++ b/src/slang-nodes/AssemblyFlagsDeclaration.ts
@@ -4,7 +4,7 @@ import { AssemblyFlags } from './AssemblyFlags.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class AssemblyFlagsDeclaration extends SlangNode {
@@ -14,11 +14,12 @@ export class AssemblyFlagsDeclaration extends SlangNode {
 
   constructor(
     ast: ast.AssemblyFlagsDeclaration,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.flags = new AssemblyFlags(ast.flags, options);
+    this.flags = new AssemblyFlags(ast.flags, collected, options);
 
     this.updateMetadata(this.flags);
   }
diff --git a/src/slang-nodes/AssemblyStatement.ts b/src/slang-nodes/AssemblyStatement.ts
index 9c4a1d366..9173b8e8b 100644
--- a/src/slang-nodes/AssemblyStatement.ts
+++ b/src/slang-nodes/AssemblyStatement.ts
@@ -7,7 +7,7 @@ import { YulBlock } from './YulBlock.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class AssemblyStatement extends SlangNode {
@@ -19,16 +19,20 @@ export class AssemblyStatement extends SlangNode {
 
   body: YulBlock;
 
-  constructor(ast: ast.AssemblyStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.AssemblyStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     if (ast.label) {
-      this.label = new StringLiteral(ast.label, options);
+      this.label = new StringLiteral(ast.label, collected, options);
     }
     if (ast.flags) {
-      this.flags = new AssemblyFlagsDeclaration(ast.flags, options);
+      this.flags = new AssemblyFlagsDeclaration(ast.flags, collected, options);
     }
-    this.body = new YulBlock(ast.body, options);
+    this.body = new YulBlock(ast.body, collected, options);
 
     this.updateMetadata(this.label, this.flags, this.body);
   }
diff --git a/src/slang-nodes/AssignmentExpression.ts b/src/slang-nodes/AssignmentExpression.ts
index f1963330b..180948948 100644
--- a/src/slang-nodes/AssignmentExpression.ts
+++ b/src/slang-nodes/AssignmentExpression.ts
@@ -8,7 +8,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class AssignmentExpression extends SlangNode {
@@ -20,13 +20,19 @@ export class AssignmentExpression extends SlangNode {
 
   rightOperand: Expression['variant'];
 
-  constructor(ast: ast.AssignmentExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.AssignmentExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/BitwiseAndExpression.ts b/src/slang-nodes/BitwiseAndExpression.ts
index 88547f1d4..641cd00a5 100644
--- a/src/slang-nodes/BitwiseAndExpression.ts
+++ b/src/slang-nodes/BitwiseAndExpression.ts
@@ -8,7 +8,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const tryToHug = createHugFunction(['+', '-', '*', '/', '**', '<<', '>>']);
@@ -31,13 +31,19 @@ export class BitwiseAndExpression extends SlangNode {
 
   rightOperand: Expression['variant'];
 
-  constructor(ast: ast.BitwiseAndExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.BitwiseAndExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/BitwiseOrExpression.ts b/src/slang-nodes/BitwiseOrExpression.ts
index c2daaa349..e8c929cce 100644
--- a/src/slang-nodes/BitwiseOrExpression.ts
+++ b/src/slang-nodes/BitwiseOrExpression.ts
@@ -8,7 +8,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const tryToHug = createHugFunction([
@@ -41,13 +41,19 @@ export class BitwiseOrExpression extends SlangNode {
 
   rightOperand: Expression['variant'];
 
-  constructor(ast: ast.BitwiseOrExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.BitwiseOrExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/BitwiseXorExpression.ts b/src/slang-nodes/BitwiseXorExpression.ts
index 9c9adfe84..f05908eaf 100644
--- a/src/slang-nodes/BitwiseXorExpression.ts
+++ b/src/slang-nodes/BitwiseXorExpression.ts
@@ -8,7 +8,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const tryToHug = createHugFunction(['+', '-', '*', '/', '**', '<<', '>>', '&']);
@@ -31,13 +31,19 @@ export class BitwiseXorExpression extends SlangNode {
 
   rightOperand: Expression['variant'];
 
-  constructor(ast: ast.BitwiseXorExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.BitwiseXorExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/Block.ts b/src/slang-nodes/Block.ts
index 8b441b877..4bdb7b109 100644
--- a/src/slang-nodes/Block.ts
+++ b/src/slang-nodes/Block.ts
@@ -4,7 +4,7 @@ import { Statements } from './Statements.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class Block extends SlangNode {
@@ -12,10 +12,14 @@ export class Block extends SlangNode {
 
   statements: Statements;
 
-  constructor(ast: ast.Block, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.Block,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.statements = new Statements(ast.statements, options);
+    this.statements = new Statements(ast.statements, collected, options);
 
     this.updateMetadata(this.statements);
   }
diff --git a/src/slang-nodes/BreakStatement.ts b/src/slang-nodes/BreakStatement.ts
index 2e8eb523d..e8a2d0719 100644
--- a/src/slang-nodes/BreakStatement.ts
+++ b/src/slang-nodes/BreakStatement.ts
@@ -3,12 +3,13 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class BreakStatement extends SlangNode {
   readonly kind = NonterminalKind.BreakStatement;
 
-  constructor(ast: ast.BreakStatement) {
-    super(ast);
+  constructor(ast: ast.BreakStatement, collected: CollectedMetadata) {
+    super(ast, collected);
   }
 
   print(): Doc {
diff --git a/src/slang-nodes/CallOptions.ts b/src/slang-nodes/CallOptions.ts
index 4092d5d6a..34a302b43 100644
--- a/src/slang-nodes/CallOptions.ts
+++ b/src/slang-nodes/CallOptions.ts
@@ -6,7 +6,7 @@ import { NamedArgument } from './NamedArgument.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line, softline } = doc.builders;
@@ -16,10 +16,16 @@ export class CallOptions extends SlangNode {
 
   items: NamedArgument[];
 
-  constructor(ast: ast.CallOptions, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.CallOptions,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new NamedArgument(item, options));
+    this.items = ast.items.map(
+      (item) => new NamedArgument(item, collected, options)
+    );
   }
 
   print(
diff --git a/src/slang-nodes/CallOptionsExpression.ts b/src/slang-nodes/CallOptionsExpression.ts
index 77bcccb24..7f96a37bf 100644
--- a/src/slang-nodes/CallOptionsExpression.ts
+++ b/src/slang-nodes/CallOptionsExpression.ts
@@ -6,7 +6,7 @@ import { CallOptions } from './CallOptions.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class CallOptionsExpression extends SlangNode {
@@ -16,11 +16,17 @@ export class CallOptionsExpression extends SlangNode {
 
   options: CallOptions;
 
-  constructor(ast: ast.CallOptionsExpression, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.operand = extractVariant(new Expression(ast.operand, options));
-    this.options = new CallOptions(ast.options, options);
+  constructor(
+    ast: ast.CallOptionsExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.operand = extractVariant(
+      new Expression(ast.operand, collected, options)
+    );
+    this.options = new CallOptions(ast.options, collected, options);
 
     this.updateMetadata(this.operand, this.options);
   }
diff --git a/src/slang-nodes/CatchClause.ts b/src/slang-nodes/CatchClause.ts
index 620df53f4..1c0afcdb5 100644
--- a/src/slang-nodes/CatchClause.ts
+++ b/src/slang-nodes/CatchClause.ts
@@ -5,7 +5,7 @@ import { Block } from './Block.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class CatchClause extends SlangNode {
@@ -15,13 +15,17 @@ export class CatchClause extends SlangNode {
 
   body: Block;
 
-  constructor(ast: ast.CatchClause, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.CatchClause,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     if (ast.error) {
-      this.error = new CatchClauseError(ast.error, options);
+      this.error = new CatchClauseError(ast.error, collected, options);
     }
-    this.body = new Block(ast.body, options);
+    this.body = new Block(ast.body, collected, options);
 
     this.updateMetadata(this.error, this.body);
   }
diff --git a/src/slang-nodes/CatchClauseError.ts b/src/slang-nodes/CatchClauseError.ts
index 04f651c65..4c0241842 100644
--- a/src/slang-nodes/CatchClauseError.ts
+++ b/src/slang-nodes/CatchClauseError.ts
@@ -6,7 +6,7 @@ import { ParametersDeclaration } from './ParametersDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { group } = doc.builders;
@@ -18,13 +18,21 @@ export class CatchClauseError extends SlangNode {
 
   parameters: ParametersDeclaration;
 
-  constructor(ast: ast.CatchClauseError, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.CatchClauseError,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     if (ast.name) {
-      this.name = new TerminalNode(ast.name);
+      this.name = new TerminalNode(ast.name, collected);
     }
-    this.parameters = new ParametersDeclaration(ast.parameters, options);
+    this.parameters = new ParametersDeclaration(
+      ast.parameters,
+      collected,
+      options
+    );
 
     this.updateMetadata(this.parameters);
   }
diff --git a/src/slang-nodes/CatchClauses.ts b/src/slang-nodes/CatchClauses.ts
index 5106e0411..5514ad28f 100644
--- a/src/slang-nodes/CatchClauses.ts
+++ b/src/slang-nodes/CatchClauses.ts
@@ -5,7 +5,7 @@ import { CatchClause } from './CatchClause.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { join } = doc.builders;
@@ -15,10 +15,16 @@ export class CatchClauses extends SlangNode {
 
   items: CatchClause[];
 
-  constructor(ast: ast.CatchClauses, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.CatchClauses,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new CatchClause(item, options));
+    this.items = ast.items.map(
+      (item) => new CatchClause(item, collected, options)
+    );
 
     this.updateMetadata(...this.items);
   }
diff --git a/src/slang-nodes/ConditionalExpression.ts b/src/slang-nodes/ConditionalExpression.ts
index 5e06c8a78..4a23b97d3 100644
--- a/src/slang-nodes/ConditionalExpression.ts
+++ b/src/slang-nodes/ConditionalExpression.ts
@@ -7,7 +7,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode, StrictAstNode } from './types.d.ts';
 
 const { group, hardline, ifBreak, indent, line, softline } = doc.builders;
@@ -119,15 +119,21 @@ export class ConditionalExpression extends SlangNode {
 
   falseExpression: Expression['variant'];
 
-  constructor(ast: ast.ConditionalExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ConditionalExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.operand = extractVariant(new Expression(ast.operand, options));
+    this.operand = extractVariant(
+      new Expression(ast.operand, collected, options)
+    );
     this.trueExpression = extractVariant(
-      new Expression(ast.trueExpression, options)
+      new Expression(ast.trueExpression, collected, options)
     );
     this.falseExpression = extractVariant(
-      new Expression(ast.falseExpression, options)
+      new Expression(ast.falseExpression, collected, options)
     );
 
     this.updateMetadata(
diff --git a/src/slang-nodes/ConstantDefinition.ts b/src/slang-nodes/ConstantDefinition.ts
index 0c898b8e4..e4a72bfe7 100644
--- a/src/slang-nodes/ConstantDefinition.ts
+++ b/src/slang-nodes/ConstantDefinition.ts
@@ -7,7 +7,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ConstantDefinition extends SlangNode {
@@ -19,12 +19,18 @@ export class ConstantDefinition extends SlangNode {
 
   value: Expression['variant'];
 
-  constructor(ast: ast.ConstantDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.typeName = extractVariant(new TypeName(ast.typeName, options));
-    this.name = new TerminalNode(ast.name);
-    this.value = extractVariant(new Expression(ast.value, options));
+  constructor(
+    ast: ast.ConstantDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.typeName = extractVariant(
+      new TypeName(ast.typeName, collected, options)
+    );
+    this.name = new TerminalNode(ast.name, collected);
+    this.value = extractVariant(new Expression(ast.value, collected, options));
 
     this.updateMetadata(this.typeName, this.value);
   }
diff --git a/src/slang-nodes/ConstructorAttribute.ts b/src/slang-nodes/ConstructorAttribute.ts
index 5414d6d5c..c672a4f1b 100644
--- a/src/slang-nodes/ConstructorAttribute.ts
+++ b/src/slang-nodes/ConstructorAttribute.ts
@@ -8,6 +8,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ConstructorAttribute extends SlangNode {
@@ -15,15 +16,19 @@ export class ConstructorAttribute extends SlangNode {
 
   variant: ModifierInvocation | TerminalNode;
 
-  constructor(ast: ast.ConstructorAttribute, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ConstructorAttribute,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new ModifierInvocation(variant, options);
+    this.variant = new ModifierInvocation(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ConstructorAttributes.ts b/src/slang-nodes/ConstructorAttributes.ts
index 7c72b9264..0c333d67c 100644
--- a/src/slang-nodes/ConstructorAttributes.ts
+++ b/src/slang-nodes/ConstructorAttributes.ts
@@ -7,7 +7,7 @@ import { ConstructorAttribute } from './ConstructorAttribute.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -17,11 +17,15 @@ export class ConstructorAttributes extends SlangNode {
 
   items: ConstructorAttribute['variant'][];
 
-  constructor(ast: ast.ConstructorAttributes, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.ConstructorAttributes,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new ConstructorAttribute(item, options))
+      extractVariant(new ConstructorAttribute(item, collected, options))
     );
 
     this.items.sort(sortFunctionAttributes);
diff --git a/src/slang-nodes/ConstructorDefinition.ts b/src/slang-nodes/ConstructorDefinition.ts
index 384ff41f5..43fab99ec 100644
--- a/src/slang-nodes/ConstructorDefinition.ts
+++ b/src/slang-nodes/ConstructorDefinition.ts
@@ -7,7 +7,7 @@ import { Block } from './Block.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ConstructorDefinition extends SlangNode {
@@ -19,12 +19,24 @@ export class ConstructorDefinition extends SlangNode {
 
   body: Block;
 
-  constructor(ast: ast.ConstructorDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.parameters = new ParametersDeclaration(ast.parameters, options);
-    this.attributes = new ConstructorAttributes(ast.attributes, options);
-    this.body = new Block(ast.body, options);
+  constructor(
+    ast: ast.ConstructorDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.parameters = new ParametersDeclaration(
+      ast.parameters,
+      collected,
+      options
+    );
+    this.attributes = new ConstructorAttributes(
+      ast.attributes,
+      collected,
+      options
+    );
+    this.body = new Block(ast.body, collected, options);
 
     this.updateMetadata(this.parameters, this.attributes, this.body);
   }
diff --git a/src/slang-nodes/ContinueStatement.ts b/src/slang-nodes/ContinueStatement.ts
index 5e856cb49..6d609e0e1 100644
--- a/src/slang-nodes/ContinueStatement.ts
+++ b/src/slang-nodes/ContinueStatement.ts
@@ -3,12 +3,13 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class ContinueStatement extends SlangNode {
   readonly kind = NonterminalKind.ContinueStatement;
 
-  constructor(ast: ast.ContinueStatement) {
-    super(ast);
+  constructor(ast: ast.ContinueStatement, collected: CollectedMetadata) {
+    super(ast, collected);
   }
 
   print(): Doc {
diff --git a/src/slang-nodes/ContractDefinition.ts b/src/slang-nodes/ContractDefinition.ts
index 41c24bd5a..55e0c479f 100644
--- a/src/slang-nodes/ContractDefinition.ts
+++ b/src/slang-nodes/ContractDefinition.ts
@@ -8,7 +8,7 @@ import { ContractMembers } from './ContractMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { group, line } = doc.builders;
@@ -24,13 +24,21 @@ export class ContractDefinition extends SlangNode {
 
   members: ContractMembers;
 
-  constructor(ast: ast.ContractDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ContractDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     this.abstractKeyword = ast.abstractKeyword?.unparse();
-    this.name = new TerminalNode(ast.name);
-    this.specifiers = new ContractSpecifiers(ast.specifiers, options);
-    this.members = new ContractMembers(ast.members, options);
+    this.name = new TerminalNode(ast.name, collected);
+    this.specifiers = new ContractSpecifiers(
+      ast.specifiers,
+      collected,
+      options
+    );
+    this.members = new ContractMembers(ast.members, collected, options);
 
     this.updateMetadata(this.specifiers, this.members);
 
diff --git a/src/slang-nodes/ContractMember.ts b/src/slang-nodes/ContractMember.ts
index 2a109000b..c6ec4fa9a 100644
--- a/src/slang-nodes/ContractMember.ts
+++ b/src/slang-nodes/ContractMember.ts
@@ -16,50 +16,52 @@ import { ErrorDefinition } from './ErrorDefinition.js';
 import { UserDefinedValueTypeDefinition } from './UserDefinedValueTypeDefinition.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.ContractMember['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): ContractMember['variant'] {
   if (variant instanceof ast.UsingDirective) {
-    return new UsingDirective(variant, options);
+    return new UsingDirective(variant, collected, options);
   }
   if (variant instanceof ast.FunctionDefinition) {
-    return new FunctionDefinition(variant, options);
+    return new FunctionDefinition(variant, collected, options);
   }
   if (variant instanceof ast.ConstructorDefinition) {
-    return new ConstructorDefinition(variant, options);
+    return new ConstructorDefinition(variant, collected, options);
   }
   if (variant instanceof ast.ReceiveFunctionDefinition) {
-    return new ReceiveFunctionDefinition(variant, options);
+    return new ReceiveFunctionDefinition(variant, collected, options);
   }
   if (variant instanceof ast.FallbackFunctionDefinition) {
-    return new FallbackFunctionDefinition(variant, options);
+    return new FallbackFunctionDefinition(variant, collected, options);
   }
   if (variant instanceof ast.UnnamedFunctionDefinition) {
-    return new UnnamedFunctionDefinition(variant, options);
+    return new UnnamedFunctionDefinition(variant, collected, options);
   }
   if (variant instanceof ast.ModifierDefinition) {
-    return new ModifierDefinition(variant, options);
+    return new ModifierDefinition(variant, collected, options);
   }
   if (variant instanceof ast.StructDefinition) {
-    return new StructDefinition(variant, options);
+    return new StructDefinition(variant, collected, options);
   }
   if (variant instanceof ast.EnumDefinition) {
-    return new EnumDefinition(variant);
+    return new EnumDefinition(variant, collected);
   }
   if (variant instanceof ast.EventDefinition) {
-    return new EventDefinition(variant, options);
+    return new EventDefinition(variant, collected, options);
   }
   if (variant instanceof ast.StateVariableDefinition) {
-    return new StateVariableDefinition(variant, options);
+    return new StateVariableDefinition(variant, collected, options);
   }
   if (variant instanceof ast.ErrorDefinition) {
-    return new ErrorDefinition(variant, options);
+    return new ErrorDefinition(variant, collected, options);
   }
   if (variant instanceof ast.UserDefinedValueTypeDefinition) {
-    return new UserDefinedValueTypeDefinition(variant);
+    return new UserDefinedValueTypeDefinition(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -83,10 +85,14 @@ export class ContractMember extends SlangNode {
     | ErrorDefinition
     | UserDefinedValueTypeDefinition;
 
-  constructor(ast: ast.ContractMember, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ContractMember,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ContractMembers.ts b/src/slang-nodes/ContractMembers.ts
index 884421a9b..d993ae306 100644
--- a/src/slang-nodes/ContractMembers.ts
+++ b/src/slang-nodes/ContractMembers.ts
@@ -8,7 +8,7 @@ import { ContractMember } from './ContractMember.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { hardline } = doc.builders;
@@ -18,11 +18,15 @@ export class ContractMembers extends SlangNode {
 
   items: ContractMember['variant'][];
 
-  constructor(ast: ast.ContractMembers, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.ContractMembers,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new ContractMember(item, options))
+      extractVariant(new ContractMember(item, collected, options))
     );
   }
 
diff --git a/src/slang-nodes/ContractSpecifier.ts b/src/slang-nodes/ContractSpecifier.ts
index aa55bb401..6f75ef231 100644
--- a/src/slang-nodes/ContractSpecifier.ts
+++ b/src/slang-nodes/ContractSpecifier.ts
@@ -5,17 +5,19 @@ import { InheritanceSpecifier } from './InheritanceSpecifier.js';
 import { StorageLayoutSpecifier } from './StorageLayoutSpecifier.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.ContractSpecifier['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): ContractSpecifier['variant'] {
   if (variant instanceof ast.InheritanceSpecifier) {
-    return new InheritanceSpecifier(variant, options);
+    return new InheritanceSpecifier(variant, collected, options);
   }
   if (variant instanceof ast.StorageLayoutSpecifier) {
-    return new StorageLayoutSpecifier(variant, options);
+    return new StorageLayoutSpecifier(variant, collected, options);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -26,10 +28,14 @@ export class ContractSpecifier extends SlangNode {
 
   variant: InheritanceSpecifier | StorageLayoutSpecifier;
 
-  constructor(ast: ast.ContractSpecifier, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ContractSpecifier,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ContractSpecifiers.ts b/src/slang-nodes/ContractSpecifiers.ts
index e5cea806a..16a8e7293 100644
--- a/src/slang-nodes/ContractSpecifiers.ts
+++ b/src/slang-nodes/ContractSpecifiers.ts
@@ -8,7 +8,7 @@ import { ContractSpecifier } from './ContractSpecifier.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { group, ifBreak, line, softline } = doc.builders;
@@ -18,11 +18,15 @@ export class ContractSpecifiers extends SlangNode {
 
   items: ContractSpecifier['variant'][];
 
-  constructor(ast: ast.ContractSpecifiers, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.ContractSpecifiers,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new ContractSpecifier(item, options))
+      extractVariant(new ContractSpecifier(item, collected, options))
     );
 
     this.items.sort(sortContractSpecifiers);
diff --git a/src/slang-nodes/DecimalNumberExpression.ts b/src/slang-nodes/DecimalNumberExpression.ts
index 211fb2bee..2ab65cde6 100644
--- a/src/slang-nodes/DecimalNumberExpression.ts
+++ b/src/slang-nodes/DecimalNumberExpression.ts
@@ -5,7 +5,7 @@ import { NumberUnit } from './NumberUnit.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class DecimalNumberExpression extends SlangNode {
   readonly kind = NonterminalKind.DecimalNumberExpression;
@@ -14,12 +14,12 @@ export class DecimalNumberExpression extends SlangNode {
 
   unit?: NumberUnit;
 
-  constructor(ast: ast.DecimalNumberExpression) {
-    super(ast);
+  constructor(ast: ast.DecimalNumberExpression, collected: CollectedMetadata) {
+    super(ast, collected);
 
     this.literal = ast.literal.unparse();
     if (ast.unit) {
-      this.unit = new NumberUnit(ast.unit);
+      this.unit = new NumberUnit(ast.unit, collected);
     }
 
     this.updateMetadata(this.unit);
diff --git a/src/slang-nodes/DoWhileStatement.ts b/src/slang-nodes/DoWhileStatement.ts
index 00cea0967..74c5a8fca 100644
--- a/src/slang-nodes/DoWhileStatement.ts
+++ b/src/slang-nodes/DoWhileStatement.ts
@@ -8,7 +8,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -20,11 +20,17 @@ export class DoWhileStatement extends SlangNode {
 
   condition: Expression['variant'];
 
-  constructor(ast: ast.DoWhileStatement, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.body = extractVariant(new Statement(ast.body, options));
-    this.condition = extractVariant(new Expression(ast.condition, options));
+  constructor(
+    ast: ast.DoWhileStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.body = extractVariant(new Statement(ast.body, collected, options));
+    this.condition = extractVariant(
+      new Expression(ast.condition, collected, options)
+    );
 
     this.updateMetadata(this.body, this.condition);
   }
diff --git a/src/slang-nodes/ElementaryType.ts b/src/slang-nodes/ElementaryType.ts
index 5f958e5b3..487366eeb 100644
--- a/src/slang-nodes/ElementaryType.ts
+++ b/src/slang-nodes/ElementaryType.ts
@@ -7,21 +7,22 @@ import { AddressType } from './AddressType.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class ElementaryType extends SlangNode {
   readonly kind = NonterminalKind.ElementaryType;
 
   variant: AddressType | TerminalNode;
 
-  constructor(ast: ast.ElementaryType) {
-    super(ast);
+  constructor(ast: ast.ElementaryType, collected: CollectedMetadata) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new AddressType(variant);
+    this.variant = new AddressType(variant, collected);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ElseBranch.ts b/src/slang-nodes/ElseBranch.ts
index e7d3f4fcf..397046a8f 100644
--- a/src/slang-nodes/ElseBranch.ts
+++ b/src/slang-nodes/ElseBranch.ts
@@ -7,7 +7,7 @@ import { Statement } from './Statement.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const isIfStatementOrBlock = createKindCheckFunction([
@@ -20,10 +20,14 @@ export class ElseBranch extends SlangNode {
 
   body: Statement['variant'];
 
-  constructor(ast: ast.ElseBranch, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ElseBranch,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.body = extractVariant(new Statement(ast.body, options));
+    this.body = extractVariant(new Statement(ast.body, collected, options));
 
     this.updateMetadata(this.body);
   }
diff --git a/src/slang-nodes/EmitStatement.ts b/src/slang-nodes/EmitStatement.ts
index 42e7166ec..81c950f9d 100644
--- a/src/slang-nodes/EmitStatement.ts
+++ b/src/slang-nodes/EmitStatement.ts
@@ -6,7 +6,7 @@ import { ArgumentsDeclaration } from './ArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class EmitStatement extends SlangNode {
@@ -16,12 +16,16 @@ export class EmitStatement extends SlangNode {
 
   arguments: ArgumentsDeclaration['variant'];
 
-  constructor(ast: ast.EmitStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.EmitStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.event = new IdentifierPath(ast.event);
+    this.event = new IdentifierPath(ast.event, collected);
     this.arguments = extractVariant(
-      new ArgumentsDeclaration(ast.arguments, options)
+      new ArgumentsDeclaration(ast.arguments, collected, options)
     );
 
     this.updateMetadata(this.event, this.arguments);
diff --git a/src/slang-nodes/EnumDefinition.ts b/src/slang-nodes/EnumDefinition.ts
index a0b287b23..986493b5e 100644
--- a/src/slang-nodes/EnumDefinition.ts
+++ b/src/slang-nodes/EnumDefinition.ts
@@ -5,7 +5,7 @@ import { EnumMembers } from './EnumMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class EnumDefinition extends SlangNode {
   readonly kind = NonterminalKind.EnumDefinition;
@@ -14,11 +14,11 @@ export class EnumDefinition extends SlangNode {
 
   members: EnumMembers;
 
-  constructor(ast: ast.EnumDefinition) {
-    super(ast);
+  constructor(ast: ast.EnumDefinition, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.name = new TerminalNode(ast.name);
-    this.members = new EnumMembers(ast.members);
+    this.name = new TerminalNode(ast.name, collected);
+    this.members = new EnumMembers(ast.members, collected);
 
     this.updateMetadata(this.members);
   }
diff --git a/src/slang-nodes/EnumMembers.ts b/src/slang-nodes/EnumMembers.ts
index bb4058e73..4aee04ef7 100644
--- a/src/slang-nodes/EnumMembers.ts
+++ b/src/slang-nodes/EnumMembers.ts
@@ -6,7 +6,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { hardline } = doc.builders;
 
@@ -15,10 +15,10 @@ export class EnumMembers extends SlangNode {
 
   items: TerminalNode[];
 
-  constructor(ast: ast.EnumMembers) {
-    super(ast, true);
+  constructor(ast: ast.EnumMembers, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new TerminalNode(item));
+    this.items = ast.items.map((item) => new TerminalNode(item, collected));
   }
 
   print(path: AstPath<EnumMembers>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/EqualityExpression.ts b/src/slang-nodes/EqualityExpression.ts
index 81727e9f1..4c2bca5f5 100644
--- a/src/slang-nodes/EqualityExpression.ts
+++ b/src/slang-nodes/EqualityExpression.ts
@@ -8,7 +8,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const tryToHug = createHugFunction(['==', '!=']);
@@ -29,13 +29,19 @@ export class EqualityExpression extends SlangNode {
 
   rightOperand: Expression['variant'];
 
-  constructor(ast: ast.EqualityExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.EqualityExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/ErrorDefinition.ts b/src/slang-nodes/ErrorDefinition.ts
index 64e0fa45f..34e4b8d6b 100644
--- a/src/slang-nodes/ErrorDefinition.ts
+++ b/src/slang-nodes/ErrorDefinition.ts
@@ -5,7 +5,7 @@ import { ErrorParametersDeclaration } from './ErrorParametersDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ErrorDefinition extends SlangNode {
@@ -15,11 +15,19 @@ export class ErrorDefinition extends SlangNode {
 
   members: ErrorParametersDeclaration;
 
-  constructor(ast: ast.ErrorDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.name = new TerminalNode(ast.name);
-    this.members = new ErrorParametersDeclaration(ast.members, options);
+  constructor(
+    ast: ast.ErrorDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.name = new TerminalNode(ast.name, collected);
+    this.members = new ErrorParametersDeclaration(
+      ast.members,
+      collected,
+      options
+    );
 
     this.updateMetadata(this.members);
   }
diff --git a/src/slang-nodes/ErrorParameter.ts b/src/slang-nodes/ErrorParameter.ts
index bca479f2e..a3f8dd77e 100644
--- a/src/slang-nodes/ErrorParameter.ts
+++ b/src/slang-nodes/ErrorParameter.ts
@@ -7,7 +7,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ErrorParameter extends SlangNode {
@@ -17,12 +17,18 @@ export class ErrorParameter extends SlangNode {
 
   name?: TerminalNode;
 
-  constructor(ast: ast.ErrorParameter, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ErrorParameter,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.typeName = extractVariant(new TypeName(ast.typeName, options));
+    this.typeName = extractVariant(
+      new TypeName(ast.typeName, collected, options)
+    );
     if (ast.name) {
-      this.name = new TerminalNode(ast.name);
+      this.name = new TerminalNode(ast.name, collected);
     }
 
     this.updateMetadata(this.typeName);
diff --git a/src/slang-nodes/ErrorParameters.ts b/src/slang-nodes/ErrorParameters.ts
index 2db19415d..15d64316d 100644
--- a/src/slang-nodes/ErrorParameters.ts
+++ b/src/slang-nodes/ErrorParameters.ts
@@ -5,7 +5,7 @@ import { ErrorParameter } from './ErrorParameter.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ErrorParameters extends SlangNode {
@@ -13,10 +13,16 @@ export class ErrorParameters extends SlangNode {
 
   items: ErrorParameter[];
 
-  constructor(ast: ast.ErrorParameters, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.ErrorParameters,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new ErrorParameter(item, options));
+    this.items = ast.items.map(
+      (item) => new ErrorParameter(item, collected, options)
+    );
   }
 
   print(path: AstPath<ErrorParameters>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/ErrorParametersDeclaration.ts b/src/slang-nodes/ErrorParametersDeclaration.ts
index 36f7cbd61..9bcc0545d 100644
--- a/src/slang-nodes/ErrorParametersDeclaration.ts
+++ b/src/slang-nodes/ErrorParametersDeclaration.ts
@@ -4,7 +4,7 @@ import { ErrorParameters } from './ErrorParameters.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ErrorParametersDeclaration extends SlangNode {
@@ -14,11 +14,12 @@ export class ErrorParametersDeclaration extends SlangNode {
 
   constructor(
     ast: ast.ErrorParametersDeclaration,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.parameters = new ErrorParameters(ast.parameters, options);
+    this.parameters = new ErrorParameters(ast.parameters, collected, options);
 
     this.updateMetadata(this.parameters);
   }
diff --git a/src/slang-nodes/EventDefinition.ts b/src/slang-nodes/EventDefinition.ts
index 3d3368ed3..94c9636aa 100644
--- a/src/slang-nodes/EventDefinition.ts
+++ b/src/slang-nodes/EventDefinition.ts
@@ -5,7 +5,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class EventDefinition extends SlangNode {
@@ -17,11 +17,19 @@ export class EventDefinition extends SlangNode {
 
   anonymousKeyword?: string;
 
-  constructor(ast: ast.EventDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.name = new TerminalNode(ast.name);
-    this.parameters = new EventParametersDeclaration(ast.parameters, options);
+  constructor(
+    ast: ast.EventDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.name = new TerminalNode(ast.name, collected);
+    this.parameters = new EventParametersDeclaration(
+      ast.parameters,
+      collected,
+      options
+    );
     this.anonymousKeyword = ast.anonymousKeyword?.unparse();
 
     this.updateMetadata(this.parameters);
diff --git a/src/slang-nodes/EventParameter.ts b/src/slang-nodes/EventParameter.ts
index 4e49d652b..5a76c8539 100644
--- a/src/slang-nodes/EventParameter.ts
+++ b/src/slang-nodes/EventParameter.ts
@@ -7,7 +7,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class EventParameter extends SlangNode {
@@ -19,13 +19,19 @@ export class EventParameter extends SlangNode {
 
   name?: TerminalNode;
 
-  constructor(ast: ast.EventParameter, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.EventParameter,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.typeName = extractVariant(new TypeName(ast.typeName, options));
+    this.typeName = extractVariant(
+      new TypeName(ast.typeName, collected, options)
+    );
     this.indexedKeyword = ast.indexedKeyword?.unparse();
     if (ast.name) {
-      this.name = new TerminalNode(ast.name);
+      this.name = new TerminalNode(ast.name, collected);
     }
 
     this.updateMetadata(this.typeName);
diff --git a/src/slang-nodes/EventParameters.ts b/src/slang-nodes/EventParameters.ts
index f546f9282..da166becc 100644
--- a/src/slang-nodes/EventParameters.ts
+++ b/src/slang-nodes/EventParameters.ts
@@ -5,7 +5,7 @@ import { EventParameter } from './EventParameter.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class EventParameters extends SlangNode {
@@ -13,10 +13,16 @@ export class EventParameters extends SlangNode {
 
   items: EventParameter[];
 
-  constructor(ast: ast.EventParameters, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.EventParameters,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new EventParameter(item, options));
+    this.items = ast.items.map(
+      (item) => new EventParameter(item, collected, options)
+    );
   }
 
   print(path: AstPath<EventParameters>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/EventParametersDeclaration.ts b/src/slang-nodes/EventParametersDeclaration.ts
index f8f055bef..28df8dca3 100644
--- a/src/slang-nodes/EventParametersDeclaration.ts
+++ b/src/slang-nodes/EventParametersDeclaration.ts
@@ -4,7 +4,7 @@ import { EventParameters } from './EventParameters.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class EventParametersDeclaration extends SlangNode {
@@ -14,11 +14,12 @@ export class EventParametersDeclaration extends SlangNode {
 
   constructor(
     ast: ast.EventParametersDeclaration,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.parameters = new EventParameters(ast.parameters, options);
+    this.parameters = new EventParameters(ast.parameters, collected, options);
 
     this.updateMetadata(this.parameters);
   }
diff --git a/src/slang-nodes/ExperimentalFeature.ts b/src/slang-nodes/ExperimentalFeature.ts
index b07563fa2..eaafa1096 100644
--- a/src/slang-nodes/ExperimentalFeature.ts
+++ b/src/slang-nodes/ExperimentalFeature.ts
@@ -8,6 +8,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ExperimentalFeature extends SlangNode {
@@ -15,15 +16,19 @@ export class ExperimentalFeature extends SlangNode {
 
   variant: StringLiteral | TerminalNode;
 
-  constructor(ast: ast.ExperimentalFeature, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ExperimentalFeature,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new StringLiteral(variant, options);
+    this.variant = new StringLiteral(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ExperimentalPragma.ts b/src/slang-nodes/ExperimentalPragma.ts
index 513996419..0a28156d8 100644
--- a/src/slang-nodes/ExperimentalPragma.ts
+++ b/src/slang-nodes/ExperimentalPragma.ts
@@ -5,7 +5,7 @@ import { ExperimentalFeature } from './ExperimentalFeature.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ExperimentalPragma extends SlangNode {
@@ -13,11 +13,15 @@ export class ExperimentalPragma extends SlangNode {
 
   feature: ExperimentalFeature['variant'];
 
-  constructor(ast: ast.ExperimentalPragma, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ExperimentalPragma,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     this.feature = extractVariant(
-      new ExperimentalFeature(ast.feature, options)
+      new ExperimentalFeature(ast.feature, collected, options)
     );
 
     this.updateMetadata(this.feature);
diff --git a/src/slang-nodes/ExponentiationExpression.ts b/src/slang-nodes/ExponentiationExpression.ts
index b0f862c77..b696d546f 100644
--- a/src/slang-nodes/ExponentiationExpression.ts
+++ b/src/slang-nodes/ExponentiationExpression.ts
@@ -10,7 +10,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { group } = doc.builders;
@@ -48,14 +48,17 @@ export class ExponentiationExpression extends SlangNode {
 
   constructor(
     ast: ast.ExponentiationExpression,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/Expression.ts b/src/slang-nodes/Expression.ts
index 7d9468628..dea0bf1c0 100644
--- a/src/slang-nodes/Expression.ts
+++ b/src/slang-nodes/Expression.ts
@@ -35,92 +35,94 @@ import { ElementaryType } from './ElementaryType.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: Exclude<ast.Expression['variant'], SlangTerminalNode>,
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Expression['variant'] {
   if (variant instanceof ast.AssignmentExpression) {
-    return new AssignmentExpression(variant, options);
+    return new AssignmentExpression(variant, collected, options);
   }
   if (variant instanceof ast.ConditionalExpression) {
-    return new ConditionalExpression(variant, options);
+    return new ConditionalExpression(variant, collected, options);
   }
   if (variant instanceof ast.OrExpression) {
-    return new OrExpression(variant, options);
+    return new OrExpression(variant, collected, options);
   }
   if (variant instanceof ast.AndExpression) {
-    return new AndExpression(variant, options);
+    return new AndExpression(variant, collected, options);
   }
   if (variant instanceof ast.EqualityExpression) {
-    return new EqualityExpression(variant, options);
+    return new EqualityExpression(variant, collected, options);
   }
   if (variant instanceof ast.InequalityExpression) {
-    return new InequalityExpression(variant, options);
+    return new InequalityExpression(variant, collected, options);
   }
   if (variant instanceof ast.BitwiseOrExpression) {
-    return new BitwiseOrExpression(variant, options);
+    return new BitwiseOrExpression(variant, collected, options);
   }
   if (variant instanceof ast.BitwiseXorExpression) {
-    return new BitwiseXorExpression(variant, options);
+    return new BitwiseXorExpression(variant, collected, options);
   }
   if (variant instanceof ast.BitwiseAndExpression) {
-    return new BitwiseAndExpression(variant, options);
+    return new BitwiseAndExpression(variant, collected, options);
   }
   if (variant instanceof ast.ShiftExpression) {
-    return new ShiftExpression(variant, options);
+    return new ShiftExpression(variant, collected, options);
   }
   if (variant instanceof ast.AdditiveExpression) {
-    return new AdditiveExpression(variant, options);
+    return new AdditiveExpression(variant, collected, options);
   }
   if (variant instanceof ast.MultiplicativeExpression) {
-    return new MultiplicativeExpression(variant, options);
+    return new MultiplicativeExpression(variant, collected, options);
   }
   if (variant instanceof ast.ExponentiationExpression) {
-    return new ExponentiationExpression(variant, options);
+    return new ExponentiationExpression(variant, collected, options);
   }
   if (variant instanceof ast.PostfixExpression) {
-    return new PostfixExpression(variant, options);
+    return new PostfixExpression(variant, collected, options);
   }
   if (variant instanceof ast.PrefixExpression) {
-    return new PrefixExpression(variant, options);
+    return new PrefixExpression(variant, collected, options);
   }
   if (variant instanceof ast.FunctionCallExpression) {
-    return new FunctionCallExpression(variant, options);
+    return new FunctionCallExpression(variant, collected, options);
   }
   if (variant instanceof ast.CallOptionsExpression) {
-    return new CallOptionsExpression(variant, options);
+    return new CallOptionsExpression(variant, collected, options);
   }
   if (variant instanceof ast.MemberAccessExpression) {
-    return new MemberAccessExpression(variant, options);
+    return new MemberAccessExpression(variant, collected, options);
   }
   if (variant instanceof ast.IndexAccessExpression) {
-    return new IndexAccessExpression(variant, options);
+    return new IndexAccessExpression(variant, collected, options);
   }
   if (variant instanceof ast.NewExpression) {
-    return new NewExpression(variant, options);
+    return new NewExpression(variant, collected, options);
   }
   if (variant instanceof ast.TupleExpression) {
-    return new TupleExpression(variant, options);
+    return new TupleExpression(variant, collected, options);
   }
   if (variant instanceof ast.TypeExpression) {
-    return new TypeExpression(variant, options);
+    return new TypeExpression(variant, collected, options);
   }
   if (variant instanceof ast.ArrayExpression) {
-    return new ArrayExpression(variant, options);
+    return new ArrayExpression(variant, collected, options);
   }
   if (variant instanceof ast.HexNumberExpression) {
-    return new HexNumberExpression(variant);
+    return new HexNumberExpression(variant, collected);
   }
   if (variant instanceof ast.DecimalNumberExpression) {
-    return new DecimalNumberExpression(variant);
+    return new DecimalNumberExpression(variant, collected);
   }
   if (variant instanceof ast.StringExpression) {
-    return extractVariant(new StringExpression(variant, options));
+    return extractVariant(new StringExpression(variant, collected, options));
   }
   if (variant instanceof ast.ElementaryType) {
-    return extractVariant(new ElementaryType(variant));
+    return extractVariant(new ElementaryType(variant, collected));
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -159,15 +161,19 @@ export class Expression extends SlangNode {
     | ElementaryType['variant']
     | TerminalNode;
 
-  constructor(ast: ast.Expression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.Expression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = createNonterminalVariant(variant, options);
+    this.variant = createNonterminalVariant(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ExpressionStatement.ts b/src/slang-nodes/ExpressionStatement.ts
index 021a399d8..b89e71bc1 100644
--- a/src/slang-nodes/ExpressionStatement.ts
+++ b/src/slang-nodes/ExpressionStatement.ts
@@ -5,7 +5,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ExpressionStatement extends SlangNode {
@@ -13,10 +13,16 @@ export class ExpressionStatement extends SlangNode {
 
   expression: Expression['variant'];
 
-  constructor(ast: ast.ExpressionStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ExpressionStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.expression = extractVariant(new Expression(ast.expression, options));
+    this.expression = extractVariant(
+      new Expression(ast.expression, collected, options)
+    );
 
     this.updateMetadata(this.expression);
   }
diff --git a/src/slang-nodes/FallbackFunctionAttribute.ts b/src/slang-nodes/FallbackFunctionAttribute.ts
index 735d47ab8..9af79da6e 100644
--- a/src/slang-nodes/FallbackFunctionAttribute.ts
+++ b/src/slang-nodes/FallbackFunctionAttribute.ts
@@ -9,17 +9,19 @@ import { OverrideSpecifier } from './OverrideSpecifier.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: Exclude<ast.FallbackFunctionAttribute['variant'], SlangTerminalNode>,
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Exclude<FallbackFunctionAttribute['variant'], TerminalNode> {
   if (variant instanceof ast.ModifierInvocation) {
-    return new ModifierInvocation(variant, options);
+    return new ModifierInvocation(variant, collected, options);
   }
   if (variant instanceof ast.OverrideSpecifier) {
-    return new OverrideSpecifier(variant);
+    return new OverrideSpecifier(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -32,16 +34,17 @@ export class FallbackFunctionAttribute extends SlangNode {
 
   constructor(
     ast: ast.FallbackFunctionAttribute,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = createNonterminalVariant(variant, options);
+    this.variant = createNonterminalVariant(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/FallbackFunctionAttributes.ts b/src/slang-nodes/FallbackFunctionAttributes.ts
index c603b6ab0..ce77ce759 100644
--- a/src/slang-nodes/FallbackFunctionAttributes.ts
+++ b/src/slang-nodes/FallbackFunctionAttributes.ts
@@ -7,7 +7,7 @@ import { FallbackFunctionAttribute } from './FallbackFunctionAttribute.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -19,12 +19,13 @@ export class FallbackFunctionAttributes extends SlangNode {
 
   constructor(
     ast: ast.FallbackFunctionAttributes,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast, true);
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new FallbackFunctionAttribute(item, options))
+      extractVariant(new FallbackFunctionAttribute(item, collected, options))
     );
 
     this.items.sort(sortFunctionAttributes);
diff --git a/src/slang-nodes/FallbackFunctionDefinition.ts b/src/slang-nodes/FallbackFunctionDefinition.ts
index 500171d27..537a16a8b 100644
--- a/src/slang-nodes/FallbackFunctionDefinition.ts
+++ b/src/slang-nodes/FallbackFunctionDefinition.ts
@@ -9,7 +9,7 @@ import { FunctionBody } from './FunctionBody.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class FallbackFunctionDefinition extends SlangNode {
@@ -25,16 +25,25 @@ export class FallbackFunctionDefinition extends SlangNode {
 
   constructor(
     ast: ast.FallbackFunctionDefinition,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.parameters = new ParametersDeclaration(ast.parameters, options);
-    this.attributes = new FallbackFunctionAttributes(ast.attributes, options);
+    this.parameters = new ParametersDeclaration(
+      ast.parameters,
+      collected,
+      options
+    );
+    this.attributes = new FallbackFunctionAttributes(
+      ast.attributes,
+      collected,
+      options
+    );
     if (ast.returns) {
-      this.returns = new ReturnsDeclaration(ast.returns, options);
+      this.returns = new ReturnsDeclaration(ast.returns, collected, options);
     }
-    this.body = extractVariant(new FunctionBody(ast.body, options));
+    this.body = extractVariant(new FunctionBody(ast.body, collected, options));
 
     this.updateMetadata(
       this.parameters,
diff --git a/src/slang-nodes/ForStatement.ts b/src/slang-nodes/ForStatement.ts
index 4dc772089..5f1f33606 100644
--- a/src/slang-nodes/ForStatement.ts
+++ b/src/slang-nodes/ForStatement.ts
@@ -11,7 +11,7 @@ import { Statement } from './Statement.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -27,19 +27,25 @@ export class ForStatement extends SlangNode {
 
   body: Statement['variant'];
 
-  constructor(ast: ast.ForStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ForStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     this.initialization = extractVariant(
-      new ForStatementInitialization(ast.initialization, options)
+      new ForStatementInitialization(ast.initialization, collected, options)
     );
     this.condition = extractVariant(
-      new ForStatementCondition(ast.condition, options)
+      new ForStatementCondition(ast.condition, collected, options)
     );
     if (ast.iterator) {
-      this.iterator = extractVariant(new Expression(ast.iterator, options));
+      this.iterator = extractVariant(
+        new Expression(ast.iterator, collected, options)
+      );
     }
-    this.body = extractVariant(new Statement(ast.body, options));
+    this.body = extractVariant(new Statement(ast.body, collected, options));
 
     this.updateMetadata(
       this.initialization,
diff --git a/src/slang-nodes/ForStatementCondition.ts b/src/slang-nodes/ForStatementCondition.ts
index 0c75d9c94..582b7c19f 100644
--- a/src/slang-nodes/ForStatementCondition.ts
+++ b/src/slang-nodes/ForStatementCondition.ts
@@ -8,6 +8,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ForStatementCondition extends SlangNode {
@@ -15,15 +16,19 @@ export class ForStatementCondition extends SlangNode {
 
   variant: ExpressionStatement | TerminalNode;
 
-  constructor(ast: ast.ForStatementCondition, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ForStatementCondition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new ExpressionStatement(variant, options);
+    this.variant = new ExpressionStatement(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ForStatementInitialization.ts b/src/slang-nodes/ForStatementInitialization.ts
index 94174c051..bb7adadf5 100644
--- a/src/slang-nodes/ForStatementInitialization.ts
+++ b/src/slang-nodes/ForStatementInitialization.ts
@@ -10,6 +10,7 @@ import { TupleDeconstructionStatement } from './TupleDeconstructionStatement.js'
 import { TerminalNode } from './TerminalNode.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
@@ -17,16 +18,17 @@ function createNonterminalVariant(
     ast.ForStatementInitialization['variant'],
     SlangTerminalNode
   >,
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Exclude<ForStatementInitialization['variant'], TerminalNode> {
   if (variant instanceof ast.ExpressionStatement) {
-    return new ExpressionStatement(variant, options);
+    return new ExpressionStatement(variant, collected, options);
   }
   if (variant instanceof ast.VariableDeclarationStatement) {
-    return new VariableDeclarationStatement(variant, options);
+    return new VariableDeclarationStatement(variant, collected, options);
   }
   if (variant instanceof ast.TupleDeconstructionStatement) {
-    return new TupleDeconstructionStatement(variant, options);
+    return new TupleDeconstructionStatement(variant, collected, options);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -43,16 +45,17 @@ export class ForStatementInitialization extends SlangNode {
 
   constructor(
     ast: ast.ForStatementInitialization,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = createNonterminalVariant(variant, options);
+    this.variant = createNonterminalVariant(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/FunctionAttribute.ts b/src/slang-nodes/FunctionAttribute.ts
index 689dd070a..fe4b041d9 100644
--- a/src/slang-nodes/FunctionAttribute.ts
+++ b/src/slang-nodes/FunctionAttribute.ts
@@ -9,17 +9,19 @@ import { OverrideSpecifier } from './OverrideSpecifier.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: Exclude<ast.FunctionAttribute['variant'], SlangTerminalNode>,
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Exclude<FunctionAttribute['variant'], TerminalNode> {
   if (variant instanceof ast.ModifierInvocation) {
-    return new ModifierInvocation(variant, options);
+    return new ModifierInvocation(variant, collected, options);
   }
   if (variant instanceof ast.OverrideSpecifier) {
-    return new OverrideSpecifier(variant);
+    return new OverrideSpecifier(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -30,15 +32,19 @@ export class FunctionAttribute extends SlangNode {
 
   variant: ModifierInvocation | OverrideSpecifier | TerminalNode;
 
-  constructor(ast: ast.FunctionAttribute, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.FunctionAttribute,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = createNonterminalVariant(variant, options);
+    this.variant = createNonterminalVariant(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/FunctionAttributes.ts b/src/slang-nodes/FunctionAttributes.ts
index 61eb54bdb..58a063e69 100644
--- a/src/slang-nodes/FunctionAttributes.ts
+++ b/src/slang-nodes/FunctionAttributes.ts
@@ -7,7 +7,7 @@ import { FunctionAttribute } from './FunctionAttribute.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -17,11 +17,15 @@ export class FunctionAttributes extends SlangNode {
 
   items: FunctionAttribute['variant'][];
 
-  constructor(ast: ast.FunctionAttributes, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.FunctionAttributes,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new FunctionAttribute(item, options))
+      extractVariant(new FunctionAttribute(item, collected, options))
     );
 
     this.items.sort(sortFunctionAttributes);
diff --git a/src/slang-nodes/FunctionBody.ts b/src/slang-nodes/FunctionBody.ts
index 364a0923f..be392c6f7 100644
--- a/src/slang-nodes/FunctionBody.ts
+++ b/src/slang-nodes/FunctionBody.ts
@@ -8,6 +8,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class FunctionBody extends SlangNode {
@@ -15,15 +16,19 @@ export class FunctionBody extends SlangNode {
 
   variant: Block | TerminalNode;
 
-  constructor(ast: ast.FunctionBody, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.FunctionBody,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new Block(variant, options);
+    this.variant = new Block(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/FunctionCallExpression.ts b/src/slang-nodes/FunctionCallExpression.ts
index 4152289b6..edee9045b 100644
--- a/src/slang-nodes/FunctionCallExpression.ts
+++ b/src/slang-nodes/FunctionCallExpression.ts
@@ -9,7 +9,7 @@ import { ArgumentsDeclaration } from './ArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { label } = doc.builders;
@@ -23,13 +23,16 @@ export class FunctionCallExpression extends SlangNode {
 
   constructor(
     ast: ast.FunctionCallExpression,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.operand = extractVariant(new Expression(ast.operand, options));
+    this.operand = extractVariant(
+      new Expression(ast.operand, collected, options)
+    );
     this.arguments = extractVariant(
-      new ArgumentsDeclaration(ast.arguments, options)
+      new ArgumentsDeclaration(ast.arguments, collected, options)
     );
 
     this.updateMetadata(this.operand, this.arguments);
diff --git a/src/slang-nodes/FunctionDefinition.ts b/src/slang-nodes/FunctionDefinition.ts
index a59d7afb9..d30e270bf 100644
--- a/src/slang-nodes/FunctionDefinition.ts
+++ b/src/slang-nodes/FunctionDefinition.ts
@@ -11,7 +11,7 @@ import { FunctionBody } from './FunctionBody.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class FunctionDefinition extends SlangNode {
@@ -27,16 +27,28 @@ export class FunctionDefinition extends SlangNode {
 
   body: FunctionBody['variant'];
 
-  constructor(ast: ast.FunctionDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.FunctionDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.name = extractVariant(new FunctionName(ast.name));
-    this.parameters = new ParametersDeclaration(ast.parameters, options);
-    this.attributes = new FunctionAttributes(ast.attributes, options);
+    this.name = extractVariant(new FunctionName(ast.name, collected));
+    this.parameters = new ParametersDeclaration(
+      ast.parameters,
+      collected,
+      options
+    );
+    this.attributes = new FunctionAttributes(
+      ast.attributes,
+      collected,
+      options
+    );
     if (ast.returns) {
-      this.returns = new ReturnsDeclaration(ast.returns, options);
+      this.returns = new ReturnsDeclaration(ast.returns, collected, options);
     }
-    this.body = extractVariant(new FunctionBody(ast.body, options));
+    this.body = extractVariant(new FunctionBody(ast.body, collected, options));
 
     this.updateMetadata(
       this.name,
diff --git a/src/slang-nodes/FunctionName.ts b/src/slang-nodes/FunctionName.ts
index 59cd6325d..3b0dc275a 100644
--- a/src/slang-nodes/FunctionName.ts
+++ b/src/slang-nodes/FunctionName.ts
@@ -3,15 +3,16 @@ import { SlangNode } from './SlangNode.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class FunctionName extends SlangNode {
   readonly kind = NonterminalKind.FunctionName;
 
   variant: TerminalNode;
 
-  constructor(ast: ast.FunctionName) {
-    super(ast);
+  constructor(ast: ast.FunctionName, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.variant = new TerminalNode(ast.variant);
+    this.variant = new TerminalNode(ast.variant, collected);
   }
 }
diff --git a/src/slang-nodes/FunctionType.ts b/src/slang-nodes/FunctionType.ts
index b384c7692..072296797 100644
--- a/src/slang-nodes/FunctionType.ts
+++ b/src/slang-nodes/FunctionType.ts
@@ -7,7 +7,7 @@ import { ReturnsDeclaration } from './ReturnsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class FunctionType extends SlangNode {
@@ -19,13 +19,21 @@ export class FunctionType extends SlangNode {
 
   returns?: ReturnsDeclaration;
 
-  constructor(ast: ast.FunctionType, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.parameters = new ParametersDeclaration(ast.parameters, options);
-    this.attributes = new FunctionTypeAttributes(ast.attributes);
+  constructor(
+    ast: ast.FunctionType,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.parameters = new ParametersDeclaration(
+      ast.parameters,
+      collected,
+      options
+    );
+    this.attributes = new FunctionTypeAttributes(ast.attributes, collected);
     if (ast.returns) {
-      this.returns = new ReturnsDeclaration(ast.returns, options);
+      this.returns = new ReturnsDeclaration(ast.returns, collected, options);
     }
 
     this.updateMetadata(this.parameters, this.attributes, this.returns);
diff --git a/src/slang-nodes/FunctionTypeAttribute.ts b/src/slang-nodes/FunctionTypeAttribute.ts
index 5e0b2d18d..38a1c2b36 100644
--- a/src/slang-nodes/FunctionTypeAttribute.ts
+++ b/src/slang-nodes/FunctionTypeAttribute.ts
@@ -3,15 +3,16 @@ import { SlangNode } from './SlangNode.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class FunctionTypeAttribute extends SlangNode {
   readonly kind = NonterminalKind.FunctionTypeAttribute;
 
   variant: TerminalNode;
 
-  constructor(ast: ast.FunctionTypeAttribute) {
-    super(ast);
+  constructor(ast: ast.FunctionTypeAttribute, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.variant = new TerminalNode(ast.variant);
+    this.variant = new TerminalNode(ast.variant, collected);
   }
 }
diff --git a/src/slang-nodes/FunctionTypeAttributes.ts b/src/slang-nodes/FunctionTypeAttributes.ts
index aa31d9ac4..32281c8d2 100644
--- a/src/slang-nodes/FunctionTypeAttributes.ts
+++ b/src/slang-nodes/FunctionTypeAttributes.ts
@@ -7,7 +7,7 @@ import { FunctionTypeAttribute } from './FunctionTypeAttribute.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { line } = doc.builders;
 
@@ -16,11 +16,11 @@ export class FunctionTypeAttributes extends SlangNode {
 
   items: FunctionTypeAttribute['variant'][];
 
-  constructor(ast: ast.FunctionTypeAttributes) {
-    super(ast, true);
+  constructor(ast: ast.FunctionTypeAttributes, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new FunctionTypeAttribute(item))
+      extractVariant(new FunctionTypeAttribute(item, collected))
     );
 
     this.items.sort(sortFunctionAttributes);
diff --git a/src/slang-nodes/HexNumberExpression.ts b/src/slang-nodes/HexNumberExpression.ts
index 1308f9c5f..c55869834 100644
--- a/src/slang-nodes/HexNumberExpression.ts
+++ b/src/slang-nodes/HexNumberExpression.ts
@@ -5,7 +5,7 @@ import { NumberUnit } from './NumberUnit.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class HexNumberExpression extends SlangNode {
   readonly kind = NonterminalKind.HexNumberExpression;
@@ -14,12 +14,12 @@ export class HexNumberExpression extends SlangNode {
 
   unit?: NumberUnit;
 
-  constructor(ast: ast.HexNumberExpression) {
-    super(ast);
+  constructor(ast: ast.HexNumberExpression, collected: CollectedMetadata) {
+    super(ast, collected);
 
     this.literal = ast.literal.unparse();
     if (ast.unit) {
-      this.unit = new NumberUnit(ast.unit);
+      this.unit = new NumberUnit(ast.unit, collected);
     }
 
     this.updateMetadata(this.unit);
diff --git a/src/slang-nodes/HexStringLiteral.ts b/src/slang-nodes/HexStringLiteral.ts
index d2f0b767c..e80da405c 100644
--- a/src/slang-nodes/HexStringLiteral.ts
+++ b/src/slang-nodes/HexStringLiteral.ts
@@ -4,6 +4,7 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc, ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class HexStringLiteral extends SlangNode {
@@ -11,8 +12,12 @@ export class HexStringLiteral extends SlangNode {
 
   variant: string;
 
-  constructor(ast: ast.HexStringLiteral, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.HexStringLiteral,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     this.variant = ast.variant.unparse();
 
diff --git a/src/slang-nodes/HexStringLiterals.ts b/src/slang-nodes/HexStringLiterals.ts
index f5ba16031..9557a96ab 100644
--- a/src/slang-nodes/HexStringLiterals.ts
+++ b/src/slang-nodes/HexStringLiterals.ts
@@ -5,7 +5,7 @@ import { HexStringLiteral } from './HexStringLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { join, hardline } = doc.builders;
@@ -15,10 +15,16 @@ export class HexStringLiterals extends SlangNode {
 
   items: HexStringLiteral[];
 
-  constructor(ast: ast.HexStringLiterals, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.HexStringLiterals,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new HexStringLiteral(item, options));
+    this.items = ast.items.map(
+      (item) => new HexStringLiteral(item, collected, options)
+    );
   }
 
   print(path: AstPath<HexStringLiterals>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/IdentifierPath.ts b/src/slang-nodes/IdentifierPath.ts
index 603341e41..453159fa9 100644
--- a/src/slang-nodes/IdentifierPath.ts
+++ b/src/slang-nodes/IdentifierPath.ts
@@ -5,7 +5,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { join } = doc.builders;
 
@@ -14,10 +14,10 @@ export class IdentifierPath extends SlangNode {
 
   items: TerminalNode[];
 
-  constructor(ast: ast.IdentifierPath) {
-    super(ast);
+  constructor(ast: ast.IdentifierPath, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.items = ast.items.map((item) => new TerminalNode(item));
+    this.items = ast.items.map((item) => new TerminalNode(item, collected));
   }
 
   print(path: AstPath<IdentifierPath>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/IfStatement.ts b/src/slang-nodes/IfStatement.ts
index 7c68d1175..3e77d160c 100644
--- a/src/slang-nodes/IfStatement.ts
+++ b/src/slang-nodes/IfStatement.ts
@@ -11,7 +11,7 @@ import { ElseBranch } from './ElseBranch.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { hardline } = doc.builders;
@@ -25,13 +25,19 @@ export class IfStatement extends SlangNode {
 
   elseBranch?: ElseBranch;
 
-  constructor(ast: ast.IfStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.IfStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.condition = extractVariant(new Expression(ast.condition, options));
-    this.body = extractVariant(new Statement(ast.body, options));
+    this.condition = extractVariant(
+      new Expression(ast.condition, collected, options)
+    );
+    this.body = extractVariant(new Statement(ast.body, collected, options));
     if (ast.elseBranch) {
-      this.elseBranch = new ElseBranch(ast.elseBranch, options);
+      this.elseBranch = new ElseBranch(ast.elseBranch, collected, options);
     }
 
     this.updateMetadata(this.condition, this.body, this.elseBranch);
diff --git a/src/slang-nodes/ImportAlias.ts b/src/slang-nodes/ImportAlias.ts
index 41784d029..39dd337d8 100644
--- a/src/slang-nodes/ImportAlias.ts
+++ b/src/slang-nodes/ImportAlias.ts
@@ -4,17 +4,17 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class ImportAlias extends SlangNode {
   readonly kind = NonterminalKind.ImportAlias;
 
   identifier: TerminalNode;
 
-  constructor(ast: ast.ImportAlias) {
-    super(ast);
+  constructor(ast: ast.ImportAlias, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.identifier = new TerminalNode(ast.identifier);
+    this.identifier = new TerminalNode(ast.identifier, collected);
   }
 
   print(path: AstPath<ImportAlias>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/ImportClause.ts b/src/slang-nodes/ImportClause.ts
index fb5ff8a92..73015ba8d 100644
--- a/src/slang-nodes/ImportClause.ts
+++ b/src/slang-nodes/ImportClause.ts
@@ -6,20 +6,22 @@ import { NamedImport } from './NamedImport.js';
 import { ImportDeconstruction } from './ImportDeconstruction.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.ImportClause['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): ImportClause['variant'] {
   if (variant instanceof ast.PathImport) {
-    return new PathImport(variant, options);
+    return new PathImport(variant, collected, options);
   }
   if (variant instanceof ast.NamedImport) {
-    return new NamedImport(variant, options);
+    return new NamedImport(variant, collected, options);
   }
   if (variant instanceof ast.ImportDeconstruction) {
-    return new ImportDeconstruction(variant, options);
+    return new ImportDeconstruction(variant, collected, options);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -30,10 +32,14 @@ export class ImportClause extends SlangNode {
 
   variant: PathImport | NamedImport | ImportDeconstruction;
 
-  constructor(ast: ast.ImportClause, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ImportClause,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ImportDeconstruction.ts b/src/slang-nodes/ImportDeconstruction.ts
index f72fb2d70..89fe16d19 100644
--- a/src/slang-nodes/ImportDeconstruction.ts
+++ b/src/slang-nodes/ImportDeconstruction.ts
@@ -5,7 +5,7 @@ import { StringLiteral } from './StringLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ImportDeconstruction extends SlangNode {
@@ -15,11 +15,15 @@ export class ImportDeconstruction extends SlangNode {
 
   path: StringLiteral;
 
-  constructor(ast: ast.ImportDeconstruction, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ImportDeconstruction,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.symbols = new ImportDeconstructionSymbols(ast.symbols);
-    this.path = new StringLiteral(ast.path, options);
+    this.symbols = new ImportDeconstructionSymbols(ast.symbols, collected);
+    this.path = new StringLiteral(ast.path, collected, options);
 
     this.updateMetadata(this.symbols, this.path);
   }
diff --git a/src/slang-nodes/ImportDeconstructionSymbol.ts b/src/slang-nodes/ImportDeconstructionSymbol.ts
index a2764196e..8c15c05f6 100644
--- a/src/slang-nodes/ImportDeconstructionSymbol.ts
+++ b/src/slang-nodes/ImportDeconstructionSymbol.ts
@@ -5,7 +5,7 @@ import { ImportAlias } from './ImportAlias.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class ImportDeconstructionSymbol extends SlangNode {
   readonly kind = NonterminalKind.ImportDeconstructionSymbol;
@@ -14,12 +14,15 @@ export class ImportDeconstructionSymbol extends SlangNode {
 
   alias?: ImportAlias;
 
-  constructor(ast: ast.ImportDeconstructionSymbol) {
-    super(ast);
+  constructor(
+    ast: ast.ImportDeconstructionSymbol,
+    collected: CollectedMetadata
+  ) {
+    super(ast, collected);
 
-    this.name = new TerminalNode(ast.name);
+    this.name = new TerminalNode(ast.name, collected);
     if (ast.alias) {
-      this.alias = new ImportAlias(ast.alias);
+      this.alias = new ImportAlias(ast.alias, collected);
     }
 
     this.updateMetadata(this.alias);
diff --git a/src/slang-nodes/ImportDeconstructionSymbols.ts b/src/slang-nodes/ImportDeconstructionSymbols.ts
index d80b0a1e9..a8de1f972 100644
--- a/src/slang-nodes/ImportDeconstructionSymbols.ts
+++ b/src/slang-nodes/ImportDeconstructionSymbols.ts
@@ -7,7 +7,7 @@ import { ImportDeconstructionSymbol } from './ImportDeconstructionSymbol.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line, softline } = doc.builders;
@@ -17,10 +17,15 @@ export class ImportDeconstructionSymbols extends SlangNode {
 
   items: ImportDeconstructionSymbol[];
 
-  constructor(ast: ast.ImportDeconstructionSymbols) {
-    super(ast, true);
+  constructor(
+    ast: ast.ImportDeconstructionSymbols,
+    collected: CollectedMetadata
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new ImportDeconstructionSymbol(item));
+    this.items = ast.items.map(
+      (item) => new ImportDeconstructionSymbol(item, collected)
+    );
   }
 
   print(
diff --git a/src/slang-nodes/ImportDirective.ts b/src/slang-nodes/ImportDirective.ts
index 0f89c1600..3b8c6be11 100644
--- a/src/slang-nodes/ImportDirective.ts
+++ b/src/slang-nodes/ImportDirective.ts
@@ -5,7 +5,7 @@ import { ImportClause } from './ImportClause.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ImportDirective extends SlangNode {
@@ -13,10 +13,16 @@ export class ImportDirective extends SlangNode {
 
   clause: ImportClause['variant'];
 
-  constructor(ast: ast.ImportDirective, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ImportDirective,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.clause = extractVariant(new ImportClause(ast.clause, options));
+    this.clause = extractVariant(
+      new ImportClause(ast.clause, collected, options)
+    );
 
     this.updateMetadata(this.clause);
   }
diff --git a/src/slang-nodes/IndexAccessEnd.ts b/src/slang-nodes/IndexAccessEnd.ts
index 59dcedf69..e9b8ee3b6 100644
--- a/src/slang-nodes/IndexAccessEnd.ts
+++ b/src/slang-nodes/IndexAccessEnd.ts
@@ -5,7 +5,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class IndexAccessEnd extends SlangNode {
@@ -13,11 +13,15 @@ export class IndexAccessEnd extends SlangNode {
 
   end?: Expression['variant'];
 
-  constructor(ast: ast.IndexAccessEnd, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.IndexAccessEnd,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     if (ast.end) {
-      this.end = extractVariant(new Expression(ast.end, options));
+      this.end = extractVariant(new Expression(ast.end, collected, options));
     }
 
     this.updateMetadata(this.end);
diff --git a/src/slang-nodes/IndexAccessExpression.ts b/src/slang-nodes/IndexAccessExpression.ts
index aa8f04086..065a00649 100644
--- a/src/slang-nodes/IndexAccessExpression.ts
+++ b/src/slang-nodes/IndexAccessExpression.ts
@@ -10,7 +10,7 @@ import { IndexAccessEnd } from './IndexAccessEnd.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { label } = doc.builders;
@@ -24,15 +24,23 @@ export class IndexAccessExpression extends SlangNode {
 
   end?: IndexAccessEnd;
 
-  constructor(ast: ast.IndexAccessExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.IndexAccessExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.operand = extractVariant(new Expression(ast.operand, options));
+    this.operand = extractVariant(
+      new Expression(ast.operand, collected, options)
+    );
     if (ast.start) {
-      this.start = extractVariant(new Expression(ast.start, options));
+      this.start = extractVariant(
+        new Expression(ast.start, collected, options)
+      );
     }
     if (ast.end) {
-      this.end = new IndexAccessEnd(ast.end, options);
+      this.end = new IndexAccessEnd(ast.end, collected, options);
     }
 
     this.updateMetadata(this.operand, this.start, this.end);
diff --git a/src/slang-nodes/InequalityExpression.ts b/src/slang-nodes/InequalityExpression.ts
index a24b02886..5f136d206 100644
--- a/src/slang-nodes/InequalityExpression.ts
+++ b/src/slang-nodes/InequalityExpression.ts
@@ -7,7 +7,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const printComparisonExpression = printBinaryOperation(
@@ -27,13 +27,19 @@ export class InequalityExpression extends SlangNode {
 
   rightOperand: Expression['variant'];
 
-  constructor(ast: ast.InequalityExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.InequalityExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/InheritanceSpecifier.ts b/src/slang-nodes/InheritanceSpecifier.ts
index 9adc27e23..5b3ecd5c0 100644
--- a/src/slang-nodes/InheritanceSpecifier.ts
+++ b/src/slang-nodes/InheritanceSpecifier.ts
@@ -4,7 +4,7 @@ import { InheritanceTypes } from './InheritanceTypes.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class InheritanceSpecifier extends SlangNode {
@@ -12,10 +12,14 @@ export class InheritanceSpecifier extends SlangNode {
 
   types: InheritanceTypes;
 
-  constructor(ast: ast.InheritanceSpecifier, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.InheritanceSpecifier,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.types = new InheritanceTypes(ast.types, options);
+    this.types = new InheritanceTypes(ast.types, collected, options);
 
     this.updateMetadata(this.types);
   }
diff --git a/src/slang-nodes/InheritanceType.ts b/src/slang-nodes/InheritanceType.ts
index 55510600e..821c255b8 100644
--- a/src/slang-nodes/InheritanceType.ts
+++ b/src/slang-nodes/InheritanceType.ts
@@ -6,7 +6,7 @@ import { ArgumentsDeclaration } from './ArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class InheritanceType extends SlangNode {
@@ -16,13 +16,17 @@ export class InheritanceType extends SlangNode {
 
   arguments?: ArgumentsDeclaration['variant'];
 
-  constructor(ast: ast.InheritanceType, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.InheritanceType,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.typeName = new IdentifierPath(ast.typeName);
+    this.typeName = new IdentifierPath(ast.typeName, collected);
     if (ast.arguments) {
       this.arguments = extractVariant(
-        new ArgumentsDeclaration(ast.arguments, options)
+        new ArgumentsDeclaration(ast.arguments, collected, options)
       );
     }
 
diff --git a/src/slang-nodes/InheritanceTypes.ts b/src/slang-nodes/InheritanceTypes.ts
index 82bddaf8d..cceec9603 100644
--- a/src/slang-nodes/InheritanceTypes.ts
+++ b/src/slang-nodes/InheritanceTypes.ts
@@ -6,7 +6,7 @@ import { InheritanceType } from './InheritanceType.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -16,10 +16,16 @@ export class InheritanceTypes extends SlangNode {
 
   items: InheritanceType[];
 
-  constructor(ast: ast.InheritanceTypes, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.InheritanceTypes,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new InheritanceType(item, options));
+    this.items = ast.items.map(
+      (item) => new InheritanceType(item, collected, options)
+    );
   }
 
   print(path: AstPath<InheritanceTypes>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/InterfaceDefinition.ts b/src/slang-nodes/InterfaceDefinition.ts
index 5b7a9fb4b..9b55e9498 100644
--- a/src/slang-nodes/InterfaceDefinition.ts
+++ b/src/slang-nodes/InterfaceDefinition.ts
@@ -7,7 +7,7 @@ import { InterfaceMembers } from './InterfaceMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { group, line } = doc.builders;
@@ -21,14 +21,22 @@ export class InterfaceDefinition extends SlangNode {
 
   members: InterfaceMembers;
 
-  constructor(ast: ast.InterfaceDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.InterfaceDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.name = new TerminalNode(ast.name);
+    this.name = new TerminalNode(ast.name, collected);
     if (ast.inheritance) {
-      this.inheritance = new InheritanceSpecifier(ast.inheritance, options);
+      this.inheritance = new InheritanceSpecifier(
+        ast.inheritance,
+        collected,
+        options
+      );
     }
-    this.members = new InterfaceMembers(ast.members, options);
+    this.members = new InterfaceMembers(ast.members, collected, options);
 
     this.updateMetadata(this.inheritance, this.members);
   }
diff --git a/src/slang-nodes/InterfaceMembers.ts b/src/slang-nodes/InterfaceMembers.ts
index d05d42f93..fa73a9d72 100644
--- a/src/slang-nodes/InterfaceMembers.ts
+++ b/src/slang-nodes/InterfaceMembers.ts
@@ -8,7 +8,7 @@ import { ContractMember } from './ContractMember.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { hardline } = doc.builders;
@@ -18,11 +18,15 @@ export class InterfaceMembers extends SlangNode {
 
   items: ContractMember['variant'][];
 
-  constructor(ast: ast.InterfaceMembers, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.InterfaceMembers,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new ContractMember(item, options))
+      extractVariant(new ContractMember(item, collected, options))
     );
   }
 
diff --git a/src/slang-nodes/LibraryDefinition.ts b/src/slang-nodes/LibraryDefinition.ts
index 8590c355f..d563d3fe6 100644
--- a/src/slang-nodes/LibraryDefinition.ts
+++ b/src/slang-nodes/LibraryDefinition.ts
@@ -6,7 +6,7 @@ import { LibraryMembers } from './LibraryMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { group, line } = doc.builders;
@@ -18,11 +18,15 @@ export class LibraryDefinition extends SlangNode {
 
   members: LibraryMembers;
 
-  constructor(ast: ast.LibraryDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.LibraryDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.name = new TerminalNode(ast.name);
-    this.members = new LibraryMembers(ast.members, options);
+    this.name = new TerminalNode(ast.name, collected);
+    this.members = new LibraryMembers(ast.members, collected, options);
 
     this.updateMetadata(this.members);
   }
diff --git a/src/slang-nodes/LibraryMembers.ts b/src/slang-nodes/LibraryMembers.ts
index 7b61ea783..90300bc5c 100644
--- a/src/slang-nodes/LibraryMembers.ts
+++ b/src/slang-nodes/LibraryMembers.ts
@@ -8,7 +8,7 @@ import { ContractMember } from './ContractMember.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { hardline } = doc.builders;
@@ -18,11 +18,15 @@ export class LibraryMembers extends SlangNode {
 
   items: ContractMember['variant'][];
 
-  constructor(ast: ast.LibraryMembers, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.LibraryMembers,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new ContractMember(item, options))
+      extractVariant(new ContractMember(item, collected, options))
     );
   }
 
diff --git a/src/slang-nodes/MappingKey.ts b/src/slang-nodes/MappingKey.ts
index 9c8248159..ab2ebb515 100644
--- a/src/slang-nodes/MappingKey.ts
+++ b/src/slang-nodes/MappingKey.ts
@@ -7,7 +7,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class MappingKey extends SlangNode {
   readonly kind = NonterminalKind.MappingKey;
@@ -16,12 +16,12 @@ export class MappingKey extends SlangNode {
 
   name?: TerminalNode;
 
-  constructor(ast: ast.MappingKey) {
-    super(ast);
+  constructor(ast: ast.MappingKey, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.keyType = extractVariant(new MappingKeyType(ast.keyType));
+    this.keyType = extractVariant(new MappingKeyType(ast.keyType, collected));
     if (ast.name) {
-      this.name = new TerminalNode(ast.name);
+      this.name = new TerminalNode(ast.name, collected);
     }
 
     this.updateMetadata(this.keyType);
diff --git a/src/slang-nodes/MappingKeyType.ts b/src/slang-nodes/MappingKeyType.ts
index 06f1087e5..e14a4d56a 100644
--- a/src/slang-nodes/MappingKeyType.ts
+++ b/src/slang-nodes/MappingKeyType.ts
@@ -5,14 +5,17 @@ import { SlangNode } from './SlangNode.js';
 import { ElementaryType } from './ElementaryType.js';
 import { IdentifierPath } from './IdentifierPath.js';
 
+import type { CollectedMetadata } from '../types.d.ts';
+
 function createNonterminalVariant(
-  variant: ast.MappingKeyType['variant']
+  variant: ast.MappingKeyType['variant'],
+  collected: CollectedMetadata
 ): MappingKeyType['variant'] {
   if (variant instanceof ast.ElementaryType) {
-    return extractVariant(new ElementaryType(variant));
+    return extractVariant(new ElementaryType(variant, collected));
   }
   if (variant instanceof ast.IdentifierPath) {
-    return new IdentifierPath(variant);
+    return new IdentifierPath(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -23,10 +26,10 @@ export class MappingKeyType extends SlangNode {
 
   variant: ElementaryType['variant'] | IdentifierPath;
 
-  constructor(ast: ast.MappingKeyType) {
-    super(ast);
+  constructor(ast: ast.MappingKeyType, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant);
+    this.variant = createNonterminalVariant(ast.variant, collected);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/MappingType.ts b/src/slang-nodes/MappingType.ts
index ba5fa8a87..a556aefc4 100644
--- a/src/slang-nodes/MappingType.ts
+++ b/src/slang-nodes/MappingType.ts
@@ -5,7 +5,7 @@ import { MappingValue } from './MappingValue.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class MappingType extends SlangNode {
@@ -15,11 +15,15 @@ export class MappingType extends SlangNode {
 
   valueType: MappingValue;
 
-  constructor(ast: ast.MappingType, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.MappingType,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.keyType = new MappingKey(ast.keyType);
-    this.valueType = new MappingValue(ast.valueType, options);
+    this.keyType = new MappingKey(ast.keyType, collected);
+    this.valueType = new MappingValue(ast.valueType, collected, options);
 
     this.updateMetadata(this.keyType, this.valueType);
   }
diff --git a/src/slang-nodes/MappingValue.ts b/src/slang-nodes/MappingValue.ts
index e22917a21..0898271ee 100644
--- a/src/slang-nodes/MappingValue.ts
+++ b/src/slang-nodes/MappingValue.ts
@@ -7,7 +7,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class MappingValue extends SlangNode {
@@ -17,12 +17,18 @@ export class MappingValue extends SlangNode {
 
   name?: TerminalNode;
 
-  constructor(ast: ast.MappingValue, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.MappingValue,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.typeName = extractVariant(new TypeName(ast.typeName, options));
+    this.typeName = extractVariant(
+      new TypeName(ast.typeName, collected, options)
+    );
     if (ast.name) {
-      this.name = new TerminalNode(ast.name);
+      this.name = new TerminalNode(ast.name, collected);
     }
 
     this.updateMetadata(this.typeName);
diff --git a/src/slang-nodes/MemberAccessExpression.ts b/src/slang-nodes/MemberAccessExpression.ts
index 42bd7eb38..ec49a37bd 100644
--- a/src/slang-nodes/MemberAccessExpression.ts
+++ b/src/slang-nodes/MemberAccessExpression.ts
@@ -9,7 +9,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode, StrictAstNode } from './types.d.ts';
 
 const { group, indent, label, softline } = doc.builders;
@@ -121,12 +121,15 @@ export class MemberAccessExpression extends SlangNode {
 
   constructor(
     ast: ast.MemberAccessExpression,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.operand = extractVariant(new Expression(ast.operand, options));
-    this.member = new TerminalNode(ast.member);
+    this.operand = extractVariant(
+      new Expression(ast.operand, collected, options)
+    );
+    this.member = new TerminalNode(ast.member, collected);
 
     this.updateMetadata(this.operand);
   }
diff --git a/src/slang-nodes/ModifierAttribute.ts b/src/slang-nodes/ModifierAttribute.ts
index bc4310c34..d40de8c87 100644
--- a/src/slang-nodes/ModifierAttribute.ts
+++ b/src/slang-nodes/ModifierAttribute.ts
@@ -7,21 +7,22 @@ import { OverrideSpecifier } from './OverrideSpecifier.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class ModifierAttribute extends SlangNode {
   readonly kind = NonterminalKind.ModifierAttribute;
 
   variant: OverrideSpecifier | TerminalNode;
 
-  constructor(ast: ast.ModifierAttribute) {
-    super(ast);
+  constructor(ast: ast.ModifierAttribute, collected: CollectedMetadata) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new OverrideSpecifier(variant);
+    this.variant = new OverrideSpecifier(variant, collected);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ModifierAttributes.ts b/src/slang-nodes/ModifierAttributes.ts
index aa8f565c2..314a195b4 100644
--- a/src/slang-nodes/ModifierAttributes.ts
+++ b/src/slang-nodes/ModifierAttributes.ts
@@ -7,7 +7,7 @@ import { ModifierAttribute } from './ModifierAttribute.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { line } = doc.builders;
 
@@ -16,11 +16,11 @@ export class ModifierAttributes extends SlangNode {
 
   items: ModifierAttribute['variant'][];
 
-  constructor(ast: ast.ModifierAttributes) {
-    super(ast, true);
+  constructor(ast: ast.ModifierAttributes, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new ModifierAttribute(item))
+      extractVariant(new ModifierAttribute(item, collected))
     );
 
     this.items.sort(sortFunctionAttributes);
diff --git a/src/slang-nodes/ModifierDefinition.ts b/src/slang-nodes/ModifierDefinition.ts
index d668f397c..2cf0f70b5 100644
--- a/src/slang-nodes/ModifierDefinition.ts
+++ b/src/slang-nodes/ModifierDefinition.ts
@@ -10,7 +10,7 @@ import { FunctionBody } from './FunctionBody.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ModifierDefinition extends SlangNode {
@@ -24,15 +24,23 @@ export class ModifierDefinition extends SlangNode {
 
   body: FunctionBody['variant'];
 
-  constructor(ast: ast.ModifierDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ModifierDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.name = new TerminalNode(ast.name);
+    this.name = new TerminalNode(ast.name, collected);
     if (ast.parameters) {
-      this.parameters = new ParametersDeclaration(ast.parameters, options);
+      this.parameters = new ParametersDeclaration(
+        ast.parameters,
+        collected,
+        options
+      );
     }
-    this.attributes = new ModifierAttributes(ast.attributes);
-    this.body = extractVariant(new FunctionBody(ast.body, options));
+    this.attributes = new ModifierAttributes(ast.attributes, collected);
+    this.body = extractVariant(new FunctionBody(ast.body, collected, options));
 
     this.updateMetadata(this.parameters, this.attributes, this.body);
 
diff --git a/src/slang-nodes/ModifierInvocation.ts b/src/slang-nodes/ModifierInvocation.ts
index 378a43e34..7f7bc2a96 100644
--- a/src/slang-nodes/ModifierInvocation.ts
+++ b/src/slang-nodes/ModifierInvocation.ts
@@ -6,7 +6,7 @@ import { ArgumentsDeclaration } from './ArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ModifierInvocation extends SlangNode {
@@ -16,13 +16,17 @@ export class ModifierInvocation extends SlangNode {
 
   arguments?: ArgumentsDeclaration['variant'];
 
-  constructor(ast: ast.ModifierInvocation, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ModifierInvocation,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.name = new IdentifierPath(ast.name);
+    this.name = new IdentifierPath(ast.name, collected);
     if (ast.arguments) {
       this.arguments = extractVariant(
-        new ArgumentsDeclaration(ast.arguments, options)
+        new ArgumentsDeclaration(ast.arguments, collected, options)
       );
     }
 
diff --git a/src/slang-nodes/MultiplicativeExpression.ts b/src/slang-nodes/MultiplicativeExpression.ts
index 551f4fcd4..7e4b1d792 100644
--- a/src/slang-nodes/MultiplicativeExpression.ts
+++ b/src/slang-nodes/MultiplicativeExpression.ts
@@ -8,7 +8,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const multiplicationTryToHug = createHugFunction(['/', '%']);
@@ -40,14 +40,17 @@ export class MultiplicativeExpression extends SlangNode {
 
   constructor(
     ast: ast.MultiplicativeExpression,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/NamedArgument.ts b/src/slang-nodes/NamedArgument.ts
index 70e030578..34a7a0b95 100644
--- a/src/slang-nodes/NamedArgument.ts
+++ b/src/slang-nodes/NamedArgument.ts
@@ -6,7 +6,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class NamedArgument extends SlangNode {
@@ -16,11 +16,15 @@ export class NamedArgument extends SlangNode {
 
   value: Expression['variant'];
 
-  constructor(ast: ast.NamedArgument, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.NamedArgument,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.name = new TerminalNode(ast.name);
-    this.value = extractVariant(new Expression(ast.value, options));
+    this.name = new TerminalNode(ast.name, collected);
+    this.value = extractVariant(new Expression(ast.value, collected, options));
 
     this.updateMetadata(this.value);
   }
diff --git a/src/slang-nodes/NamedArgumentGroup.ts b/src/slang-nodes/NamedArgumentGroup.ts
index 1441edc2f..b18205923 100644
--- a/src/slang-nodes/NamedArgumentGroup.ts
+++ b/src/slang-nodes/NamedArgumentGroup.ts
@@ -4,7 +4,7 @@ import { NamedArguments } from './NamedArguments.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class NamedArgumentGroup extends SlangNode {
@@ -12,10 +12,14 @@ export class NamedArgumentGroup extends SlangNode {
 
   arguments: NamedArguments;
 
-  constructor(ast: ast.NamedArgumentGroup, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.NamedArgumentGroup,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.arguments = new NamedArguments(ast.arguments, options);
+    this.arguments = new NamedArguments(ast.arguments, collected, options);
 
     this.updateMetadata(this.arguments);
   }
diff --git a/src/slang-nodes/NamedArguments.ts b/src/slang-nodes/NamedArguments.ts
index 316ce49a1..fb16e08e9 100644
--- a/src/slang-nodes/NamedArguments.ts
+++ b/src/slang-nodes/NamedArguments.ts
@@ -6,7 +6,7 @@ import { NamedArgument } from './NamedArgument.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line, softline } = doc.builders;
@@ -16,10 +16,16 @@ export class NamedArguments extends SlangNode {
 
   items: NamedArgument[];
 
-  constructor(ast: ast.NamedArguments, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.NamedArguments,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new NamedArgument(item, options));
+    this.items = ast.items.map(
+      (item) => new NamedArgument(item, collected, options)
+    );
   }
 
   print(
diff --git a/src/slang-nodes/NamedArgumentsDeclaration.ts b/src/slang-nodes/NamedArgumentsDeclaration.ts
index be06eb4c7..0f77517e0 100644
--- a/src/slang-nodes/NamedArgumentsDeclaration.ts
+++ b/src/slang-nodes/NamedArgumentsDeclaration.ts
@@ -4,7 +4,7 @@ import { NamedArgumentGroup } from './NamedArgumentGroup.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class NamedArgumentsDeclaration extends SlangNode {
@@ -14,12 +14,17 @@ export class NamedArgumentsDeclaration extends SlangNode {
 
   constructor(
     ast: ast.NamedArgumentsDeclaration,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
     if (ast.arguments) {
-      this.arguments = new NamedArgumentGroup(ast.arguments, options);
+      this.arguments = new NamedArgumentGroup(
+        ast.arguments,
+        collected,
+        options
+      );
     }
 
     this.updateMetadata(this.arguments);
diff --git a/src/slang-nodes/NamedImport.ts b/src/slang-nodes/NamedImport.ts
index d03a3f47f..e53b9c19d 100644
--- a/src/slang-nodes/NamedImport.ts
+++ b/src/slang-nodes/NamedImport.ts
@@ -5,7 +5,7 @@ import { StringLiteral } from './StringLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class NamedImport extends SlangNode {
@@ -15,11 +15,15 @@ export class NamedImport extends SlangNode {
 
   path: StringLiteral;
 
-  constructor(ast: ast.NamedImport, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.NamedImport,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.alias = new ImportAlias(ast.alias);
-    this.path = new StringLiteral(ast.path, options);
+    this.alias = new ImportAlias(ast.alias, collected);
+    this.path = new StringLiteral(ast.path, collected, options);
 
     this.updateMetadata(this.alias, this.path);
   }
diff --git a/src/slang-nodes/NewExpression.ts b/src/slang-nodes/NewExpression.ts
index e022c17fd..34ec80ddc 100644
--- a/src/slang-nodes/NewExpression.ts
+++ b/src/slang-nodes/NewExpression.ts
@@ -5,7 +5,7 @@ import { TypeName } from './TypeName.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class NewExpression extends SlangNode {
@@ -13,10 +13,16 @@ export class NewExpression extends SlangNode {
 
   typeName: TypeName['variant'];
 
-  constructor(ast: ast.NewExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.NewExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.typeName = extractVariant(new TypeName(ast.typeName, options));
+    this.typeName = extractVariant(
+      new TypeName(ast.typeName, collected, options)
+    );
 
     this.updateMetadata(this.typeName);
   }
diff --git a/src/slang-nodes/NumberUnit.ts b/src/slang-nodes/NumberUnit.ts
index 6bfb73f81..f19f22984 100644
--- a/src/slang-nodes/NumberUnit.ts
+++ b/src/slang-nodes/NumberUnit.ts
@@ -3,14 +3,15 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class NumberUnit extends SlangNode {
   readonly kind = NonterminalKind.NumberUnit;
 
   variant: string;
 
-  constructor(ast: ast.NumberUnit) {
-    super(ast);
+  constructor(ast: ast.NumberUnit, collected: CollectedMetadata) {
+    super(ast, collected);
 
     this.variant = ast.variant.unparse();
   }
diff --git a/src/slang-nodes/OrExpression.ts b/src/slang-nodes/OrExpression.ts
index a47872e92..69c9a022f 100644
--- a/src/slang-nodes/OrExpression.ts
+++ b/src/slang-nodes/OrExpression.ts
@@ -7,7 +7,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const tryToHug = createHugFunction(['&&']);
@@ -21,13 +21,19 @@ export class OrExpression extends SlangNode {
 
   rightOperand: Expression['variant'];
 
-  constructor(ast: ast.OrExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.OrExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/OverridePaths.ts b/src/slang-nodes/OverridePaths.ts
index 6f8e328b0..5496b0e10 100644
--- a/src/slang-nodes/OverridePaths.ts
+++ b/src/slang-nodes/OverridePaths.ts
@@ -5,17 +5,17 @@ import { IdentifierPath } from './IdentifierPath.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class OverridePaths extends SlangNode {
   readonly kind = NonterminalKind.OverridePaths;
 
   items: IdentifierPath[];
 
-  constructor(ast: ast.OverridePaths) {
-    super(ast, true);
+  constructor(ast: ast.OverridePaths, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new IdentifierPath(item));
+    this.items = ast.items.map((item) => new IdentifierPath(item, collected));
   }
 
   print(path: AstPath<OverridePaths>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/OverridePathsDeclaration.ts b/src/slang-nodes/OverridePathsDeclaration.ts
index 8335f117f..8fdefa2bd 100644
--- a/src/slang-nodes/OverridePathsDeclaration.ts
+++ b/src/slang-nodes/OverridePathsDeclaration.ts
@@ -4,17 +4,17 @@ import { OverridePaths } from './OverridePaths.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class OverridePathsDeclaration extends SlangNode {
   readonly kind = NonterminalKind.OverridePathsDeclaration;
 
   paths: OverridePaths;
 
-  constructor(ast: ast.OverridePathsDeclaration) {
-    super(ast);
+  constructor(ast: ast.OverridePathsDeclaration, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.paths = new OverridePaths(ast.paths);
+    this.paths = new OverridePaths(ast.paths, collected);
 
     this.updateMetadata(this.paths);
   }
diff --git a/src/slang-nodes/OverrideSpecifier.ts b/src/slang-nodes/OverrideSpecifier.ts
index fe6971762..3b354575e 100644
--- a/src/slang-nodes/OverrideSpecifier.ts
+++ b/src/slang-nodes/OverrideSpecifier.ts
@@ -4,18 +4,18 @@ import { OverridePathsDeclaration } from './OverridePathsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class OverrideSpecifier extends SlangNode {
   readonly kind = NonterminalKind.OverrideSpecifier;
 
   overridden?: OverridePathsDeclaration;
 
-  constructor(ast: ast.OverrideSpecifier) {
-    super(ast);
+  constructor(ast: ast.OverrideSpecifier, collected: CollectedMetadata) {
+    super(ast, collected);
 
     if (ast.overridden) {
-      this.overridden = new OverridePathsDeclaration(ast.overridden);
+      this.overridden = new OverridePathsDeclaration(ast.overridden, collected);
     }
 
     this.updateMetadata(this.overridden);
diff --git a/src/slang-nodes/Parameter.ts b/src/slang-nodes/Parameter.ts
index f2a6c3b9a..207ba7154 100644
--- a/src/slang-nodes/Parameter.ts
+++ b/src/slang-nodes/Parameter.ts
@@ -9,7 +9,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { group } = doc.builders;
@@ -23,15 +23,24 @@ export class Parameter extends SlangNode {
 
   name?: TerminalNode;
 
-  constructor(ast: ast.Parameter, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.Parameter,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.typeName = extractVariant(new TypeName(ast.typeName, options));
+    this.typeName = extractVariant(
+      new TypeName(ast.typeName, collected, options)
+    );
     if (ast.storageLocation) {
-      this.storageLocation = new StorageLocation(ast.storageLocation);
+      this.storageLocation = new StorageLocation(
+        ast.storageLocation,
+        collected
+      );
     }
     if (ast.name) {
-      this.name = new TerminalNode(ast.name);
+      this.name = new TerminalNode(ast.name, collected);
     }
 
     this.updateMetadata(this.typeName, this.storageLocation);
diff --git a/src/slang-nodes/Parameters.ts b/src/slang-nodes/Parameters.ts
index 186899fc5..52aab3e4f 100644
--- a/src/slang-nodes/Parameters.ts
+++ b/src/slang-nodes/Parameters.ts
@@ -7,7 +7,7 @@ import { Parameter } from './Parameter.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class Parameters extends SlangNode {
@@ -15,10 +15,16 @@ export class Parameters extends SlangNode {
 
   items: Parameter[];
 
-  constructor(ast: ast.Parameters, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.Parameters,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new Parameter(item, options));
+    this.items = ast.items.map(
+      (item) => new Parameter(item, collected, options)
+    );
   }
 
   print(
diff --git a/src/slang-nodes/ParametersDeclaration.ts b/src/slang-nodes/ParametersDeclaration.ts
index e5ad58c55..b0ee602c0 100644
--- a/src/slang-nodes/ParametersDeclaration.ts
+++ b/src/slang-nodes/ParametersDeclaration.ts
@@ -4,7 +4,7 @@ import { Parameters } from './Parameters.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ParametersDeclaration extends SlangNode {
@@ -12,10 +12,14 @@ export class ParametersDeclaration extends SlangNode {
 
   parameters: Parameters;
 
-  constructor(ast: ast.ParametersDeclaration, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ParametersDeclaration,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.parameters = new Parameters(ast.parameters, options);
+    this.parameters = new Parameters(ast.parameters, collected, options);
 
     this.updateMetadata(this.parameters);
   }
diff --git a/src/slang-nodes/PathImport.ts b/src/slang-nodes/PathImport.ts
index 83a031a05..7d9654f5f 100644
--- a/src/slang-nodes/PathImport.ts
+++ b/src/slang-nodes/PathImport.ts
@@ -5,7 +5,7 @@ import { ImportAlias } from './ImportAlias.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class PathImport extends SlangNode {
@@ -15,12 +15,16 @@ export class PathImport extends SlangNode {
 
   alias?: ImportAlias;
 
-  constructor(ast: ast.PathImport, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.PathImport,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.path = new StringLiteral(ast.path, options);
+    this.path = new StringLiteral(ast.path, collected, options);
     if (ast.alias) {
-      this.alias = new ImportAlias(ast.alias);
+      this.alias = new ImportAlias(ast.alias, collected);
     }
 
     this.updateMetadata(this.path, this.alias);
diff --git a/src/slang-nodes/PositionalArguments.ts b/src/slang-nodes/PositionalArguments.ts
index 01e1b3374..fe94e257c 100644
--- a/src/slang-nodes/PositionalArguments.ts
+++ b/src/slang-nodes/PositionalArguments.ts
@@ -8,7 +8,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class PositionalArguments extends SlangNode {
@@ -16,11 +16,15 @@ export class PositionalArguments extends SlangNode {
 
   items: Expression['variant'][];
 
-  constructor(ast: ast.PositionalArguments, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.PositionalArguments,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new Expression(item, options))
+      extractVariant(new Expression(item, collected, options))
     );
   }
 
diff --git a/src/slang-nodes/PositionalArgumentsDeclaration.ts b/src/slang-nodes/PositionalArgumentsDeclaration.ts
index 8337c9e21..eb123a1d3 100644
--- a/src/slang-nodes/PositionalArgumentsDeclaration.ts
+++ b/src/slang-nodes/PositionalArgumentsDeclaration.ts
@@ -5,7 +5,7 @@ import { PositionalArguments } from './PositionalArguments.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class PositionalArgumentsDeclaration extends SlangNode {
@@ -17,11 +17,12 @@ export class PositionalArgumentsDeclaration extends SlangNode {
 
   constructor(
     ast: ast.PositionalArgumentsDeclaration,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.arguments = new PositionalArguments(ast.arguments, options);
+    this.arguments = new PositionalArguments(ast.arguments, collected, options);
 
     this.updateMetadata(this.arguments);
 
diff --git a/src/slang-nodes/PostfixExpression.ts b/src/slang-nodes/PostfixExpression.ts
index 4a5060237..7ed2191da 100644
--- a/src/slang-nodes/PostfixExpression.ts
+++ b/src/slang-nodes/PostfixExpression.ts
@@ -5,7 +5,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class PostfixExpression extends SlangNode {
@@ -15,10 +15,16 @@ export class PostfixExpression extends SlangNode {
 
   operator: string;
 
-  constructor(ast: ast.PostfixExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.PostfixExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.operand = extractVariant(new Expression(ast.operand, options));
+    this.operand = extractVariant(
+      new Expression(ast.operand, collected, options)
+    );
     this.operator = ast.operator.unparse();
 
     this.updateMetadata(this.operand);
diff --git a/src/slang-nodes/Pragma.ts b/src/slang-nodes/Pragma.ts
index 276555fe1..fb8f2610e 100644
--- a/src/slang-nodes/Pragma.ts
+++ b/src/slang-nodes/Pragma.ts
@@ -6,20 +6,22 @@ import { ExperimentalPragma } from './ExperimentalPragma.js';
 import { VersionPragma } from './VersionPragma.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.Pragma['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Pragma['variant'] {
   if (variant instanceof ast.AbicoderPragma) {
-    return new AbicoderPragma(variant);
+    return new AbicoderPragma(variant, collected);
   }
   if (variant instanceof ast.ExperimentalPragma) {
-    return new ExperimentalPragma(variant, options);
+    return new ExperimentalPragma(variant, collected, options);
   }
   if (variant instanceof ast.VersionPragma) {
-    return new VersionPragma(variant);
+    return new VersionPragma(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -30,10 +32,14 @@ export class Pragma extends SlangNode {
 
   variant: AbicoderPragma | ExperimentalPragma | VersionPragma;
 
-  constructor(ast: ast.Pragma, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.Pragma,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/PragmaDirective.ts b/src/slang-nodes/PragmaDirective.ts
index 3a928e7f7..d7b63212b 100644
--- a/src/slang-nodes/PragmaDirective.ts
+++ b/src/slang-nodes/PragmaDirective.ts
@@ -5,7 +5,7 @@ import { Pragma } from './Pragma.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class PragmaDirective extends SlangNode {
@@ -13,10 +13,14 @@ export class PragmaDirective extends SlangNode {
 
   pragma: Pragma['variant'];
 
-  constructor(ast: ast.PragmaDirective, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.PragmaDirective,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.pragma = extractVariant(new Pragma(ast.pragma, options));
+    this.pragma = extractVariant(new Pragma(ast.pragma, collected, options));
 
     this.updateMetadata(this.pragma);
   }
diff --git a/src/slang-nodes/PrefixExpression.ts b/src/slang-nodes/PrefixExpression.ts
index ee398b57b..4f8b15860 100644
--- a/src/slang-nodes/PrefixExpression.ts
+++ b/src/slang-nodes/PrefixExpression.ts
@@ -5,7 +5,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class PrefixExpression extends SlangNode {
@@ -15,11 +15,17 @@ export class PrefixExpression extends SlangNode {
 
   operand: Expression['variant'];
 
-  constructor(ast: ast.PrefixExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.PrefixExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     this.operator = ast.operator.unparse();
-    this.operand = extractVariant(new Expression(ast.operand, options));
+    this.operand = extractVariant(
+      new Expression(ast.operand, collected, options)
+    );
 
     this.updateMetadata(this.operand);
 
diff --git a/src/slang-nodes/ReceiveFunctionAttribute.ts b/src/slang-nodes/ReceiveFunctionAttribute.ts
index 608df0894..a99bd7750 100644
--- a/src/slang-nodes/ReceiveFunctionAttribute.ts
+++ b/src/slang-nodes/ReceiveFunctionAttribute.ts
@@ -9,17 +9,19 @@ import { OverrideSpecifier } from './OverrideSpecifier.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: Exclude<ast.ReceiveFunctionAttribute['variant'], SlangTerminalNode>,
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Exclude<ReceiveFunctionAttribute['variant'], TerminalNode> {
   if (variant instanceof ast.ModifierInvocation) {
-    return new ModifierInvocation(variant, options);
+    return new ModifierInvocation(variant, collected, options);
   }
   if (variant instanceof ast.OverrideSpecifier) {
-    return new OverrideSpecifier(variant);
+    return new OverrideSpecifier(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -32,16 +34,17 @@ export class ReceiveFunctionAttribute extends SlangNode {
 
   constructor(
     ast: ast.ReceiveFunctionAttribute,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = createNonterminalVariant(variant, options);
+    this.variant = createNonterminalVariant(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/ReceiveFunctionAttributes.ts b/src/slang-nodes/ReceiveFunctionAttributes.ts
index 75c22e3e1..3d31380f2 100644
--- a/src/slang-nodes/ReceiveFunctionAttributes.ts
+++ b/src/slang-nodes/ReceiveFunctionAttributes.ts
@@ -7,7 +7,7 @@ import { ReceiveFunctionAttribute } from './ReceiveFunctionAttribute.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -19,12 +19,13 @@ export class ReceiveFunctionAttributes extends SlangNode {
 
   constructor(
     ast: ast.ReceiveFunctionAttributes,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast, true);
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new ReceiveFunctionAttribute(item, options))
+      extractVariant(new ReceiveFunctionAttribute(item, collected, options))
     );
 
     this.items.sort(sortFunctionAttributes);
diff --git a/src/slang-nodes/ReceiveFunctionDefinition.ts b/src/slang-nodes/ReceiveFunctionDefinition.ts
index 27aa54698..ddc72c6db 100644
--- a/src/slang-nodes/ReceiveFunctionDefinition.ts
+++ b/src/slang-nodes/ReceiveFunctionDefinition.ts
@@ -8,7 +8,7 @@ import { FunctionBody } from './FunctionBody.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ReceiveFunctionDefinition extends SlangNode {
@@ -22,13 +22,22 @@ export class ReceiveFunctionDefinition extends SlangNode {
 
   constructor(
     ast: ast.ReceiveFunctionDefinition,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
-
-    this.parameters = new ParametersDeclaration(ast.parameters, options);
-    this.attributes = new ReceiveFunctionAttributes(ast.attributes, options);
-    this.body = extractVariant(new FunctionBody(ast.body, options));
+    super(ast, collected);
+
+    this.parameters = new ParametersDeclaration(
+      ast.parameters,
+      collected,
+      options
+    );
+    this.attributes = new ReceiveFunctionAttributes(
+      ast.attributes,
+      collected,
+      options
+    );
+    this.body = extractVariant(new FunctionBody(ast.body, collected, options));
 
     this.updateMetadata(this.parameters, this.attributes, this.body);
 
diff --git a/src/slang-nodes/ReturnStatement.ts b/src/slang-nodes/ReturnStatement.ts
index 655a6f8ac..141fc7d3d 100644
--- a/src/slang-nodes/ReturnStatement.ts
+++ b/src/slang-nodes/ReturnStatement.ts
@@ -6,7 +6,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class ReturnStatement extends SlangNode {
@@ -14,11 +14,17 @@ export class ReturnStatement extends SlangNode {
 
   expression?: Expression['variant'];
 
-  constructor(ast: ast.ReturnStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ReturnStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     if (ast.expression) {
-      this.expression = extractVariant(new Expression(ast.expression, options));
+      this.expression = extractVariant(
+        new Expression(ast.expression, collected, options)
+      );
     }
 
     this.updateMetadata(this.expression);
diff --git a/src/slang-nodes/ReturnsDeclaration.ts b/src/slang-nodes/ReturnsDeclaration.ts
index c95c36be3..8985959dc 100644
--- a/src/slang-nodes/ReturnsDeclaration.ts
+++ b/src/slang-nodes/ReturnsDeclaration.ts
@@ -5,7 +5,7 @@ import { ParametersDeclaration } from './ParametersDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { group } = doc.builders;
@@ -15,10 +15,18 @@ export class ReturnsDeclaration extends SlangNode {
 
   variables: ParametersDeclaration;
 
-  constructor(ast: ast.ReturnsDeclaration, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.variables = new ParametersDeclaration(ast.variables, options);
+  constructor(
+    ast: ast.ReturnsDeclaration,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.variables = new ParametersDeclaration(
+      ast.variables,
+      collected,
+      options
+    );
 
     this.updateMetadata(this.variables);
   }
diff --git a/src/slang-nodes/RevertStatement.ts b/src/slang-nodes/RevertStatement.ts
index cbbf5f010..f423bba70 100644
--- a/src/slang-nodes/RevertStatement.ts
+++ b/src/slang-nodes/RevertStatement.ts
@@ -7,7 +7,7 @@ import { ArgumentsDeclaration } from './ArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class RevertStatement extends SlangNode {
@@ -17,14 +17,18 @@ export class RevertStatement extends SlangNode {
 
   arguments: ArgumentsDeclaration['variant'];
 
-  constructor(ast: ast.RevertStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.RevertStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     if (ast.error) {
-      this.error = new IdentifierPath(ast.error);
+      this.error = new IdentifierPath(ast.error, collected);
     }
     this.arguments = extractVariant(
-      new ArgumentsDeclaration(ast.arguments, options)
+      new ArgumentsDeclaration(ast.arguments, collected, options)
     );
 
     this.updateMetadata(this.error, this.arguments);
diff --git a/src/slang-nodes/ShiftExpression.ts b/src/slang-nodes/ShiftExpression.ts
index d1326f9b2..95c8f9770 100644
--- a/src/slang-nodes/ShiftExpression.ts
+++ b/src/slang-nodes/ShiftExpression.ts
@@ -8,7 +8,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const tryToHugLeftOperand = createHugFunction([
@@ -43,13 +43,19 @@ export class ShiftExpression extends SlangNode {
 
   rightOperand: Expression['variant'];
 
-  constructor(ast: ast.ShiftExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.ShiftExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
+    this.leftOperand = extractVariant(
+      new Expression(ast.leftOperand, collected, options)
+    );
     this.operator = ast.operator.unparse();
     this.rightOperand = extractVariant(
-      new Expression(ast.rightOperand, options)
+      new Expression(ast.rightOperand, collected, options)
     );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
diff --git a/src/slang-nodes/SimpleVersionLiteral.ts b/src/slang-nodes/SimpleVersionLiteral.ts
index 4e65775d0..5c52de71b 100644
--- a/src/slang-nodes/SimpleVersionLiteral.ts
+++ b/src/slang-nodes/SimpleVersionLiteral.ts
@@ -3,14 +3,15 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class SimpleVersionLiteral extends SlangNode {
   readonly kind = NonterminalKind.SimpleVersionLiteral;
 
   items: string[];
 
-  constructor(ast: ast.SimpleVersionLiteral) {
-    super(ast, true);
+  constructor(ast: ast.SimpleVersionLiteral, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) => item.unparse());
   }
diff --git a/src/slang-nodes/SlangNode.ts b/src/slang-nodes/SlangNode.ts
index dee54a031..639a15a67 100644
--- a/src/slang-nodes/SlangNode.ts
+++ b/src/slang-nodes/SlangNode.ts
@@ -3,26 +3,19 @@ import {
   TerminalKind,
   TerminalKindExtensions
 } from '@nomicfoundation/slang/cst';
-import { MultiLineComment } from '../slang-nodes/MultiLineComment.js';
-import { MultiLineNatSpecComment } from '../slang-nodes/MultiLineNatSpecComment.js';
-import { SingleLineComment } from '../slang-nodes/SingleLineComment.js';
-import { SingleLineNatSpecComment } from '../slang-nodes/SingleLineNatSpecComment.js';
-
-import type { Comment, StrictAstNode } from '../slang-nodes/types.d.ts';
-import type { AstLocation, SlangAstNode } from '../types.d.ts';
+import { MultiLineComment } from './MultiLineComment.js';
+import { MultiLineNatSpecComment } from './MultiLineNatSpecComment.js';
+import { SingleLineComment } from './SingleLineComment.js';
+import { SingleLineNatSpecComment } from './SingleLineNatSpecComment.js';
+
+import type {
+  AstLocation,
+  CollectedMetadata,
+  SlangAstNode
+} from '../types.d.ts';
+import type { Comment, StrictAstNode } from './types.d.ts';
 import type { TerminalNode } from './TerminalNode.js';
 
-const offsets = new Map<number, number>();
-const comments: Comment[] = [];
-
-export function clearOffsets(): void {
-  offsets.clear();
-}
-
-export function clearComments(): Comment[] {
-  return comments.splice(0);
-}
-
 function reversedIterator<T>(children: T[]): Iterable<T> {
   return {
     [Symbol.iterator](): Iterator<T> {
@@ -44,10 +37,11 @@ export class SlangNode {
 
   constructor(
     ast: SlangAstNode | SlangTerminalNode,
+    collected: CollectedMetadata,
     enclosePeripheralComments = false
   ) {
     if (ast instanceof SlangTerminalNode) {
-      const offset = offsets.get(ast.id) || 0;
+      const offset = collected.offsets.get(ast.id) || 0;
       this.loc = {
         start: offset,
         end: offset + ast.textLength.utf16,
@@ -58,7 +52,7 @@ export class SlangNode {
     }
     const cst = ast.cst;
 
-    const initialOffset = offsets.get(cst.id) || 0;
+    const initialOffset = collected.offsets.get(cst.id) || 0;
     let offset = initialOffset;
     let triviaLength = 0;
     let leadingOffset;
@@ -78,7 +72,7 @@ export class SlangNode {
       ) {
         // Also tracking TerminalNodes since some variants that were not
         // Identifier or YulIdentifier but were upgraded to TerminalNode
-        offsets.set(node.id, offset);
+        collected.offsets.set(node.id, offset);
         // We assign the `leadingOffset` only once.
         leadingOffset ??= triviaLength;
         // Since this is a non trivia node, we reset the accumulated length
@@ -90,16 +84,16 @@ export class SlangNode {
           // offset, it's hard to separate these responsibilities into different
           // functions without doing the iteration twice.
           case TerminalKind.MultiLineComment:
-            comments.push(new MultiLineComment(node, offset));
+            collected.comments.push(new MultiLineComment(node, offset));
             break;
           case TerminalKind.MultiLineNatSpecComment:
-            comments.push(new MultiLineNatSpecComment(node, offset));
+            collected.comments.push(new MultiLineNatSpecComment(node, offset));
             break;
           case TerminalKind.SingleLineComment:
-            comments.push(new SingleLineComment(node, offset));
+            collected.comments.push(new SingleLineComment(node, offset));
             break;
           case TerminalKind.SingleLineNatSpecComment:
-            comments.push(new SingleLineNatSpecComment(node, offset));
+            collected.comments.push(new SingleLineNatSpecComment(node, offset));
             break;
         }
         // We accumulate the trivia length
diff --git a/src/slang-nodes/SourceUnit.ts b/src/slang-nodes/SourceUnit.ts
index e87006064..279d5698f 100644
--- a/src/slang-nodes/SourceUnit.ts
+++ b/src/slang-nodes/SourceUnit.ts
@@ -5,7 +5,7 @@ import { SourceUnitMembers } from './SourceUnitMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -15,10 +15,14 @@ export class SourceUnit extends SlangNode {
 
   members: SourceUnitMembers;
 
-  constructor(ast: ast.SourceUnit, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.SourceUnit,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.members = new SourceUnitMembers(ast.members, options);
+    this.members = new SourceUnitMembers(ast.members, collected, options);
 
     this.updateMetadata(this.members);
   }
diff --git a/src/slang-nodes/SourceUnitMember.ts b/src/slang-nodes/SourceUnitMember.ts
index aeeb129aa..95ab0c96e 100644
--- a/src/slang-nodes/SourceUnitMember.ts
+++ b/src/slang-nodes/SourceUnitMember.ts
@@ -16,50 +16,52 @@ import { UsingDirective } from './UsingDirective.js';
 import { EventDefinition } from './EventDefinition.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.SourceUnitMember['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): SourceUnitMember['variant'] {
   if (variant instanceof ast.PragmaDirective) {
-    return new PragmaDirective(variant, options);
+    return new PragmaDirective(variant, collected, options);
   }
   if (variant instanceof ast.ImportDirective) {
-    return new ImportDirective(variant, options);
+    return new ImportDirective(variant, collected, options);
   }
   if (variant instanceof ast.ContractDefinition) {
-    return new ContractDefinition(variant, options);
+    return new ContractDefinition(variant, collected, options);
   }
   if (variant instanceof ast.InterfaceDefinition) {
-    return new InterfaceDefinition(variant, options);
+    return new InterfaceDefinition(variant, collected, options);
   }
   if (variant instanceof ast.LibraryDefinition) {
-    return new LibraryDefinition(variant, options);
+    return new LibraryDefinition(variant, collected, options);
   }
   if (variant instanceof ast.StructDefinition) {
-    return new StructDefinition(variant, options);
+    return new StructDefinition(variant, collected, options);
   }
   if (variant instanceof ast.EnumDefinition) {
-    return new EnumDefinition(variant);
+    return new EnumDefinition(variant, collected);
   }
   if (variant instanceof ast.FunctionDefinition) {
-    return new FunctionDefinition(variant, options);
+    return new FunctionDefinition(variant, collected, options);
   }
   if (variant instanceof ast.ConstantDefinition) {
-    return new ConstantDefinition(variant, options);
+    return new ConstantDefinition(variant, collected, options);
   }
   if (variant instanceof ast.ErrorDefinition) {
-    return new ErrorDefinition(variant, options);
+    return new ErrorDefinition(variant, collected, options);
   }
   if (variant instanceof ast.UserDefinedValueTypeDefinition) {
-    return new UserDefinedValueTypeDefinition(variant);
+    return new UserDefinedValueTypeDefinition(variant, collected);
   }
   if (variant instanceof ast.UsingDirective) {
-    return new UsingDirective(variant, options);
+    return new UsingDirective(variant, collected, options);
   }
   if (variant instanceof ast.EventDefinition) {
-    return new EventDefinition(variant, options);
+    return new EventDefinition(variant, collected, options);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -83,10 +85,14 @@ export class SourceUnitMember extends SlangNode {
     | UsingDirective
     | EventDefinition;
 
-  constructor(ast: ast.SourceUnitMember, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.SourceUnitMember,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/SourceUnitMembers.ts b/src/slang-nodes/SourceUnitMembers.ts
index 62347cd32..4adcbeac2 100644
--- a/src/slang-nodes/SourceUnitMembers.ts
+++ b/src/slang-nodes/SourceUnitMembers.ts
@@ -6,7 +6,7 @@ import { SourceUnitMember } from './SourceUnitMember.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class SourceUnitMembers extends SlangNode {
@@ -14,11 +14,15 @@ export class SourceUnitMembers extends SlangNode {
 
   items: SourceUnitMember['variant'][];
 
-  constructor(ast: ast.SourceUnitMembers, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.SourceUnitMembers,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new SourceUnitMember(item, options))
+      extractVariant(new SourceUnitMember(item, collected, options))
     );
   }
 
diff --git a/src/slang-nodes/StateVariableAttribute.ts b/src/slang-nodes/StateVariableAttribute.ts
index 4cfa43602..ee8d40ea3 100644
--- a/src/slang-nodes/StateVariableAttribute.ts
+++ b/src/slang-nodes/StateVariableAttribute.ts
@@ -7,21 +7,22 @@ import { OverrideSpecifier } from './OverrideSpecifier.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class StateVariableAttribute extends SlangNode {
   readonly kind = NonterminalKind.StateVariableAttribute;
 
   variant: OverrideSpecifier | TerminalNode;
 
-  constructor(ast: ast.StateVariableAttribute) {
-    super(ast);
+  constructor(ast: ast.StateVariableAttribute, collected: CollectedMetadata) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new OverrideSpecifier(variant);
+    this.variant = new OverrideSpecifier(variant, collected);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/StateVariableAttributes.ts b/src/slang-nodes/StateVariableAttributes.ts
index 30b596c72..24598a8d2 100644
--- a/src/slang-nodes/StateVariableAttributes.ts
+++ b/src/slang-nodes/StateVariableAttributes.ts
@@ -7,7 +7,7 @@ import { StateVariableAttribute } from './StateVariableAttribute.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { line } = doc.builders;
 
@@ -16,11 +16,11 @@ export class StateVariableAttributes extends SlangNode {
 
   items: StateVariableAttribute['variant'][];
 
-  constructor(ast: ast.StateVariableAttributes) {
-    super(ast, true);
+  constructor(ast: ast.StateVariableAttributes, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new StateVariableAttribute(item))
+      extractVariant(new StateVariableAttribute(item, collected))
     );
 
     this.items.sort(sortFunctionAttributes);
diff --git a/src/slang-nodes/StateVariableDefinition.ts b/src/slang-nodes/StateVariableDefinition.ts
index a4f5d34fd..bcd7e74ed 100644
--- a/src/slang-nodes/StateVariableDefinition.ts
+++ b/src/slang-nodes/StateVariableDefinition.ts
@@ -10,7 +10,7 @@ import { StateVariableDefinitionValue } from './StateVariableDefinitionValue.js'
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { indent } = doc.builders;
@@ -28,15 +28,22 @@ export class StateVariableDefinition extends SlangNode {
 
   constructor(
     ast: ast.StateVariableDefinition,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.typeName = extractVariant(new TypeName(ast.typeName, options));
-    this.attributes = new StateVariableAttributes(ast.attributes);
-    this.name = new TerminalNode(ast.name);
+    this.typeName = extractVariant(
+      new TypeName(ast.typeName, collected, options)
+    );
+    this.attributes = new StateVariableAttributes(ast.attributes, collected);
+    this.name = new TerminalNode(ast.name, collected);
     if (ast.value) {
-      this.value = new StateVariableDefinitionValue(ast.value, options);
+      this.value = new StateVariableDefinitionValue(
+        ast.value,
+        collected,
+        options
+      );
     }
 
     this.updateMetadata(this.typeName, this.attributes, this.value);
diff --git a/src/slang-nodes/StateVariableDefinitionValue.ts b/src/slang-nodes/StateVariableDefinitionValue.ts
index c634956b8..38ed2b9e2 100644
--- a/src/slang-nodes/StateVariableDefinitionValue.ts
+++ b/src/slang-nodes/StateVariableDefinitionValue.ts
@@ -6,7 +6,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class StateVariableDefinitionValue extends SlangNode {
@@ -16,11 +16,12 @@ export class StateVariableDefinitionValue extends SlangNode {
 
   constructor(
     ast: ast.StateVariableDefinitionValue,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.value = extractVariant(new Expression(ast.value, options));
+    this.value = extractVariant(new Expression(ast.value, collected, options));
 
     this.updateMetadata(this.value);
   }
diff --git a/src/slang-nodes/Statement.ts b/src/slang-nodes/Statement.ts
index efc3c95f0..174ec0a2a 100644
--- a/src/slang-nodes/Statement.ts
+++ b/src/slang-nodes/Statement.ts
@@ -20,62 +20,64 @@ import { Block } from './Block.js';
 import { UncheckedBlock } from './UncheckedBlock.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.Statement['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Statement['variant'] {
   if (variant instanceof ast.ExpressionStatement) {
-    return new ExpressionStatement(variant, options);
+    return new ExpressionStatement(variant, collected, options);
   }
   if (variant instanceof ast.VariableDeclarationStatement) {
-    return new VariableDeclarationStatement(variant, options);
+    return new VariableDeclarationStatement(variant, collected, options);
   }
   if (variant instanceof ast.TupleDeconstructionStatement) {
-    return new TupleDeconstructionStatement(variant, options);
+    return new TupleDeconstructionStatement(variant, collected, options);
   }
   if (variant instanceof ast.IfStatement) {
-    return new IfStatement(variant, options);
+    return new IfStatement(variant, collected, options);
   }
   if (variant instanceof ast.ForStatement) {
-    return new ForStatement(variant, options);
+    return new ForStatement(variant, collected, options);
   }
   if (variant instanceof ast.WhileStatement) {
-    return new WhileStatement(variant, options);
+    return new WhileStatement(variant, collected, options);
   }
   if (variant instanceof ast.DoWhileStatement) {
-    return new DoWhileStatement(variant, options);
+    return new DoWhileStatement(variant, collected, options);
   }
   if (variant instanceof ast.ContinueStatement) {
-    return new ContinueStatement(variant);
+    return new ContinueStatement(variant, collected);
   }
   if (variant instanceof ast.BreakStatement) {
-    return new BreakStatement(variant);
+    return new BreakStatement(variant, collected);
   }
   if (variant instanceof ast.ReturnStatement) {
-    return new ReturnStatement(variant, options);
+    return new ReturnStatement(variant, collected, options);
   }
   if (variant instanceof ast.ThrowStatement) {
-    return new ThrowStatement(variant);
+    return new ThrowStatement(variant, collected);
   }
   if (variant instanceof ast.EmitStatement) {
-    return new EmitStatement(variant, options);
+    return new EmitStatement(variant, collected, options);
   }
   if (variant instanceof ast.TryStatement) {
-    return new TryStatement(variant, options);
+    return new TryStatement(variant, collected, options);
   }
   if (variant instanceof ast.RevertStatement) {
-    return new RevertStatement(variant, options);
+    return new RevertStatement(variant, collected, options);
   }
   if (variant instanceof ast.AssemblyStatement) {
-    return new AssemblyStatement(variant, options);
+    return new AssemblyStatement(variant, collected, options);
   }
   if (variant instanceof ast.Block) {
-    return new Block(variant, options);
+    return new Block(variant, collected, options);
   }
   if (variant instanceof ast.UncheckedBlock) {
-    return new UncheckedBlock(variant, options);
+    return new UncheckedBlock(variant, collected, options);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -103,10 +105,14 @@ export class Statement extends SlangNode {
     | Block
     | UncheckedBlock;
 
-  constructor(ast: ast.Statement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.Statement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/Statements.ts b/src/slang-nodes/Statements.ts
index 004822df4..def732d5c 100644
--- a/src/slang-nodes/Statements.ts
+++ b/src/slang-nodes/Statements.ts
@@ -8,7 +8,7 @@ import { Statement } from './Statement.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { hardline } = doc.builders;
@@ -18,11 +18,15 @@ export class Statements extends SlangNode {
 
   items: Statement['variant'][];
 
-  constructor(ast: ast.Statements, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.Statements,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new Statement(item, options))
+      extractVariant(new Statement(item, collected, options))
     );
   }
 
diff --git a/src/slang-nodes/StorageLayoutSpecifier.ts b/src/slang-nodes/StorageLayoutSpecifier.ts
index 8fcce6a07..f5d972a58 100644
--- a/src/slang-nodes/StorageLayoutSpecifier.ts
+++ b/src/slang-nodes/StorageLayoutSpecifier.ts
@@ -7,7 +7,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -19,11 +19,14 @@ export class StorageLayoutSpecifier extends SlangNode {
 
   constructor(
     ast: ast.StorageLayoutSpecifier,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.expression = extractVariant(new Expression(ast.expression, options));
+    this.expression = extractVariant(
+      new Expression(ast.expression, collected, options)
+    );
 
     this.updateMetadata(this.expression);
   }
diff --git a/src/slang-nodes/StorageLocation.ts b/src/slang-nodes/StorageLocation.ts
index 64d048a03..d50c2a636 100644
--- a/src/slang-nodes/StorageLocation.ts
+++ b/src/slang-nodes/StorageLocation.ts
@@ -3,14 +3,15 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class StorageLocation extends SlangNode {
   readonly kind = NonterminalKind.StorageLocation;
 
   variant: string;
 
-  constructor(ast: ast.StorageLocation) {
-    super(ast);
+  constructor(ast: ast.StorageLocation, collected: CollectedMetadata) {
+    super(ast, collected);
 
     this.variant = ast.variant.unparse();
   }
diff --git a/src/slang-nodes/StringExpression.ts b/src/slang-nodes/StringExpression.ts
index d51d5ed88..f13b54423 100644
--- a/src/slang-nodes/StringExpression.ts
+++ b/src/slang-nodes/StringExpression.ts
@@ -8,26 +8,28 @@ import { HexStringLiterals } from './HexStringLiterals.js';
 import { UnicodeStringLiterals } from './UnicodeStringLiterals.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.StringExpression['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): StringExpression['variant'] {
   if (variant instanceof ast.StringLiteral) {
-    return new StringLiteral(variant, options);
+    return new StringLiteral(variant, collected, options);
   }
   if (variant instanceof ast.StringLiterals) {
-    return new StringLiterals(variant, options);
+    return new StringLiterals(variant, collected, options);
   }
   if (variant instanceof ast.HexStringLiteral) {
-    return new HexStringLiteral(variant, options);
+    return new HexStringLiteral(variant, collected, options);
   }
   if (variant instanceof ast.HexStringLiterals) {
-    return new HexStringLiterals(variant, options);
+    return new HexStringLiterals(variant, collected, options);
   }
   if (variant instanceof ast.UnicodeStringLiterals) {
-    return new UnicodeStringLiterals(variant, options);
+    return new UnicodeStringLiterals(variant, collected, options);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -43,10 +45,14 @@ export class StringExpression extends SlangNode {
     | HexStringLiterals
     | UnicodeStringLiterals;
 
-  constructor(ast: ast.StringExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.StringExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/StringLiteral.ts b/src/slang-nodes/StringLiteral.ts
index aee53e230..c65b81056 100644
--- a/src/slang-nodes/StringLiteral.ts
+++ b/src/slang-nodes/StringLiteral.ts
@@ -4,6 +4,7 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc, ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class StringLiteral extends SlangNode {
@@ -11,8 +12,12 @@ export class StringLiteral extends SlangNode {
 
   variant: string;
 
-  constructor(ast: ast.StringLiteral, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.StringLiteral,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     this.variant = ast.variant.unparse();
 
diff --git a/src/slang-nodes/StringLiterals.ts b/src/slang-nodes/StringLiterals.ts
index 88ed51322..5c7effbdd 100644
--- a/src/slang-nodes/StringLiterals.ts
+++ b/src/slang-nodes/StringLiterals.ts
@@ -5,7 +5,7 @@ import { StringLiteral } from './StringLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { join, hardline } = doc.builders;
@@ -15,10 +15,16 @@ export class StringLiterals extends SlangNode {
 
   items: StringLiteral[];
 
-  constructor(ast: ast.StringLiterals, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.StringLiterals,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new StringLiteral(item, options));
+    this.items = ast.items.map(
+      (item) => new StringLiteral(item, collected, options)
+    );
   }
 
   print(path: AstPath<StringLiterals>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/StructDefinition.ts b/src/slang-nodes/StructDefinition.ts
index 474f6fe87..fb396ff2a 100644
--- a/src/slang-nodes/StructDefinition.ts
+++ b/src/slang-nodes/StructDefinition.ts
@@ -5,7 +5,7 @@ import { StructMembers } from './StructMembers.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class StructDefinition extends SlangNode {
@@ -15,11 +15,15 @@ export class StructDefinition extends SlangNode {
 
   members: StructMembers;
 
-  constructor(ast: ast.StructDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.StructDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.name = new TerminalNode(ast.name);
-    this.members = new StructMembers(ast.members, options);
+    this.name = new TerminalNode(ast.name, collected);
+    this.members = new StructMembers(ast.members, collected, options);
 
     this.updateMetadata(this.members);
   }
diff --git a/src/slang-nodes/StructMember.ts b/src/slang-nodes/StructMember.ts
index bfc8fa75b..627502abb 100644
--- a/src/slang-nodes/StructMember.ts
+++ b/src/slang-nodes/StructMember.ts
@@ -6,7 +6,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class StructMember extends SlangNode {
@@ -16,11 +16,17 @@ export class StructMember extends SlangNode {
 
   name: TerminalNode;
 
-  constructor(ast: ast.StructMember, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.typeName = extractVariant(new TypeName(ast.typeName, options));
-    this.name = new TerminalNode(ast.name);
+  constructor(
+    ast: ast.StructMember,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.typeName = extractVariant(
+      new TypeName(ast.typeName, collected, options)
+    );
+    this.name = new TerminalNode(ast.name, collected);
 
     this.updateMetadata(this.typeName);
   }
diff --git a/src/slang-nodes/StructMembers.ts b/src/slang-nodes/StructMembers.ts
index 0acd4c606..ebce37fd8 100644
--- a/src/slang-nodes/StructMembers.ts
+++ b/src/slang-nodes/StructMembers.ts
@@ -6,7 +6,7 @@ import { StructMember } from './StructMember.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { hardline } = doc.builders;
@@ -16,10 +16,16 @@ export class StructMembers extends SlangNode {
 
   items: StructMember[];
 
-  constructor(ast: ast.StructMembers, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.StructMembers,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new StructMember(item, options));
+    this.items = ast.items.map(
+      (item) => new StructMember(item, collected, options)
+    );
   }
 
   print(path: AstPath<StructMembers>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/TerminalNode.ts b/src/slang-nodes/TerminalNode.ts
index 3ff299eb0..cdbab0f03 100644
--- a/src/slang-nodes/TerminalNode.ts
+++ b/src/slang-nodes/TerminalNode.ts
@@ -5,14 +5,15 @@ import type {
   TerminalKind
 } from '@nomicfoundation/slang/cst';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class TerminalNode extends SlangNode {
   kind: TerminalKind;
 
   value: string;
 
-  constructor(ast: SlangTerminalNode) {
-    super(ast);
+  constructor(ast: SlangTerminalNode, collected: CollectedMetadata) {
+    super(ast, collected);
 
     this.kind = ast.kind;
     this.value = ast.unparse();
diff --git a/src/slang-nodes/ThrowStatement.ts b/src/slang-nodes/ThrowStatement.ts
index c59252f59..b8ffe812d 100644
--- a/src/slang-nodes/ThrowStatement.ts
+++ b/src/slang-nodes/ThrowStatement.ts
@@ -3,12 +3,13 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class ThrowStatement extends SlangNode {
   readonly kind = NonterminalKind.ThrowStatement;
 
-  constructor(ast: ast.ThrowStatement) {
-    super(ast);
+  constructor(ast: ast.ThrowStatement, collected: CollectedMetadata) {
+    super(ast, collected);
   }
 
   print(): Doc {
diff --git a/src/slang-nodes/TryStatement.ts b/src/slang-nodes/TryStatement.ts
index c9f048bc8..e8667a431 100644
--- a/src/slang-nodes/TryStatement.ts
+++ b/src/slang-nodes/TryStatement.ts
@@ -11,7 +11,7 @@ import { CatchClauses } from './CatchClauses.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -27,15 +27,21 @@ export class TryStatement extends SlangNode {
 
   catchClauses: CatchClauses;
 
-  constructor(ast: ast.TryStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.TryStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.expression = extractVariant(new Expression(ast.expression, options));
+    this.expression = extractVariant(
+      new Expression(ast.expression, collected, options)
+    );
     if (ast.returns) {
-      this.returns = new ReturnsDeclaration(ast.returns, options);
+      this.returns = new ReturnsDeclaration(ast.returns, collected, options);
     }
-    this.body = new Block(ast.body, options);
-    this.catchClauses = new CatchClauses(ast.catchClauses, options);
+    this.body = new Block(ast.body, collected, options);
+    this.catchClauses = new CatchClauses(ast.catchClauses, collected, options);
 
     this.updateMetadata(
       this.expression,
diff --git a/src/slang-nodes/TupleDeconstructionElement.ts b/src/slang-nodes/TupleDeconstructionElement.ts
index 4a6c0493d..d1e816b78 100644
--- a/src/slang-nodes/TupleDeconstructionElement.ts
+++ b/src/slang-nodes/TupleDeconstructionElement.ts
@@ -5,7 +5,7 @@ import { TupleMember } from './TupleMember.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class TupleDeconstructionElement extends SlangNode {
@@ -15,12 +15,15 @@ export class TupleDeconstructionElement extends SlangNode {
 
   constructor(
     ast: ast.TupleDeconstructionElement,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
     if (ast.member) {
-      this.member = extractVariant(new TupleMember(ast.member, options));
+      this.member = extractVariant(
+        new TupleMember(ast.member, collected, options)
+      );
     }
 
     this.updateMetadata(this.member);
diff --git a/src/slang-nodes/TupleDeconstructionElements.ts b/src/slang-nodes/TupleDeconstructionElements.ts
index da147d272..ab6583d14 100644
--- a/src/slang-nodes/TupleDeconstructionElements.ts
+++ b/src/slang-nodes/TupleDeconstructionElements.ts
@@ -5,7 +5,7 @@ import { TupleDeconstructionElement } from './TupleDeconstructionElement.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class TupleDeconstructionElements extends SlangNode {
@@ -15,12 +15,13 @@ export class TupleDeconstructionElements extends SlangNode {
 
   constructor(
     ast: ast.TupleDeconstructionElements,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast, true);
+    super(ast, collected, true);
 
     this.items = ast.items.map(
-      (item) => new TupleDeconstructionElement(item, options)
+      (item) => new TupleDeconstructionElement(item, collected, options)
     );
   }
 
diff --git a/src/slang-nodes/TupleDeconstructionStatement.ts b/src/slang-nodes/TupleDeconstructionStatement.ts
index 2d286a20f..395a940ee 100644
--- a/src/slang-nodes/TupleDeconstructionStatement.ts
+++ b/src/slang-nodes/TupleDeconstructionStatement.ts
@@ -7,7 +7,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class TupleDeconstructionStatement extends SlangNode {
@@ -21,13 +21,20 @@ export class TupleDeconstructionStatement extends SlangNode {
 
   constructor(
     ast: ast.TupleDeconstructionStatement,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
     this.varKeyword = ast.varKeyword?.unparse();
-    this.elements = new TupleDeconstructionElements(ast.elements, options);
-    this.expression = extractVariant(new Expression(ast.expression, options));
+    this.elements = new TupleDeconstructionElements(
+      ast.elements,
+      collected,
+      options
+    );
+    this.expression = extractVariant(
+      new Expression(ast.expression, collected, options)
+    );
 
     this.updateMetadata(this.elements, this.expression);
   }
diff --git a/src/slang-nodes/TupleExpression.ts b/src/slang-nodes/TupleExpression.ts
index 42b284d34..793587b02 100644
--- a/src/slang-nodes/TupleExpression.ts
+++ b/src/slang-nodes/TupleExpression.ts
@@ -4,7 +4,7 @@ import { TupleValues } from './TupleValues.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class TupleExpression extends SlangNode {
@@ -12,10 +12,14 @@ export class TupleExpression extends SlangNode {
 
   items: TupleValues;
 
-  constructor(ast: ast.TupleExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.TupleExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.items = new TupleValues(ast.items, options);
+    this.items = new TupleValues(ast.items, collected, options);
   }
 
   print(path: AstPath<TupleExpression>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/TupleMember.ts b/src/slang-nodes/TupleMember.ts
index e3361c478..23eb06c1c 100644
--- a/src/slang-nodes/TupleMember.ts
+++ b/src/slang-nodes/TupleMember.ts
@@ -5,17 +5,19 @@ import { TypedTupleMember } from './TypedTupleMember.js';
 import { UntypedTupleMember } from './UntypedTupleMember.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.TupleMember['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): TupleMember['variant'] {
   if (variant instanceof ast.TypedTupleMember) {
-    return new TypedTupleMember(variant, options);
+    return new TypedTupleMember(variant, collected, options);
   }
   if (variant instanceof ast.UntypedTupleMember) {
-    return new UntypedTupleMember(variant);
+    return new UntypedTupleMember(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -26,10 +28,14 @@ export class TupleMember extends SlangNode {
 
   variant: TypedTupleMember | UntypedTupleMember;
 
-  constructor(ast: ast.TupleMember, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.TupleMember,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/TupleValue.ts b/src/slang-nodes/TupleValue.ts
index 0411f5c66..efab230ed 100644
--- a/src/slang-nodes/TupleValue.ts
+++ b/src/slang-nodes/TupleValue.ts
@@ -5,7 +5,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class TupleValue extends SlangNode {
@@ -13,11 +13,17 @@ export class TupleValue extends SlangNode {
 
   expression?: Expression['variant'];
 
-  constructor(ast: ast.TupleValue, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.TupleValue,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     if (ast.expression) {
-      this.expression = extractVariant(new Expression(ast.expression, options));
+      this.expression = extractVariant(
+        new Expression(ast.expression, collected, options)
+      );
     }
 
     this.updateMetadata(this.expression);
diff --git a/src/slang-nodes/TupleValues.ts b/src/slang-nodes/TupleValues.ts
index 916f267b9..a490a437a 100644
--- a/src/slang-nodes/TupleValues.ts
+++ b/src/slang-nodes/TupleValues.ts
@@ -7,7 +7,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 import type { Expression } from './Expression.ts';
 
@@ -16,10 +16,16 @@ export class TupleValues extends SlangNode {
 
   items: TupleValue[];
 
-  constructor(ast: ast.TupleValues, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.TupleValues,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new TupleValue(item, options));
+    this.items = ast.items.map(
+      (item) => new TupleValue(item, collected, options)
+    );
   }
 
   getSingleExpression(): Expression['variant'] | undefined {
diff --git a/src/slang-nodes/TypeExpression.ts b/src/slang-nodes/TypeExpression.ts
index 14d87f050..0f4a09a33 100644
--- a/src/slang-nodes/TypeExpression.ts
+++ b/src/slang-nodes/TypeExpression.ts
@@ -5,7 +5,7 @@ import { TypeName } from './TypeName.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class TypeExpression extends SlangNode {
@@ -13,10 +13,16 @@ export class TypeExpression extends SlangNode {
 
   typeName: TypeName['variant'];
 
-  constructor(ast: ast.TypeExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.TypeExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.typeName = extractVariant(new TypeName(ast.typeName, options));
+    this.typeName = extractVariant(
+      new TypeName(ast.typeName, collected, options)
+    );
 
     this.updateMetadata(this.typeName);
   }
diff --git a/src/slang-nodes/TypeName.ts b/src/slang-nodes/TypeName.ts
index a04ee7639..5f1a31850 100644
--- a/src/slang-nodes/TypeName.ts
+++ b/src/slang-nodes/TypeName.ts
@@ -9,26 +9,28 @@ import { ElementaryType } from './ElementaryType.js';
 import { IdentifierPath } from './IdentifierPath.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.TypeName['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): TypeName['variant'] {
   if (variant instanceof ast.ArrayTypeName) {
-    return new ArrayTypeName(variant, options);
+    return new ArrayTypeName(variant, collected, options);
   }
   if (variant instanceof ast.FunctionType) {
-    return new FunctionType(variant, options);
+    return new FunctionType(variant, collected, options);
   }
   if (variant instanceof ast.MappingType) {
-    return new MappingType(variant, options);
+    return new MappingType(variant, collected, options);
   }
   if (variant instanceof ast.ElementaryType) {
-    return extractVariant(new ElementaryType(variant));
+    return extractVariant(new ElementaryType(variant, collected));
   }
   if (variant instanceof ast.IdentifierPath) {
-    return new IdentifierPath(variant);
+    return new IdentifierPath(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -44,10 +46,14 @@ export class TypeName extends SlangNode {
     | ElementaryType['variant']
     | IdentifierPath;
 
-  constructor(ast: ast.TypeName, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.TypeName,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/TypedTupleMember.ts b/src/slang-nodes/TypedTupleMember.ts
index 2cf82bd72..48e15f3db 100644
--- a/src/slang-nodes/TypedTupleMember.ts
+++ b/src/slang-nodes/TypedTupleMember.ts
@@ -8,7 +8,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class TypedTupleMember extends SlangNode {
@@ -20,14 +20,23 @@ export class TypedTupleMember extends SlangNode {
 
   name: TerminalNode;
 
-  constructor(ast: ast.TypedTupleMember, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.TypedTupleMember,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.typeName = extractVariant(new TypeName(ast.typeName, options));
+    this.typeName = extractVariant(
+      new TypeName(ast.typeName, collected, options)
+    );
     if (ast.storageLocation) {
-      this.storageLocation = new StorageLocation(ast.storageLocation);
+      this.storageLocation = new StorageLocation(
+        ast.storageLocation,
+        collected
+      );
     }
-    this.name = new TerminalNode(ast.name);
+    this.name = new TerminalNode(ast.name, collected);
 
     this.updateMetadata(this.typeName, this.storageLocation);
   }
diff --git a/src/slang-nodes/UncheckedBlock.ts b/src/slang-nodes/UncheckedBlock.ts
index 45721725f..b83eaab11 100644
--- a/src/slang-nodes/UncheckedBlock.ts
+++ b/src/slang-nodes/UncheckedBlock.ts
@@ -4,7 +4,7 @@ import { Block } from './Block.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class UncheckedBlock extends SlangNode {
@@ -12,10 +12,14 @@ export class UncheckedBlock extends SlangNode {
 
   block: Block;
 
-  constructor(ast: ast.UncheckedBlock, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.UncheckedBlock,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.block = new Block(ast.block, options);
+    this.block = new Block(ast.block, collected, options);
 
     this.updateMetadata(this.block);
   }
diff --git a/src/slang-nodes/UnicodeStringLiteral.ts b/src/slang-nodes/UnicodeStringLiteral.ts
index 68144b674..8804db8e8 100644
--- a/src/slang-nodes/UnicodeStringLiteral.ts
+++ b/src/slang-nodes/UnicodeStringLiteral.ts
@@ -4,6 +4,7 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc, ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class UnicodeStringLiteral extends SlangNode {
@@ -11,8 +12,12 @@ export class UnicodeStringLiteral extends SlangNode {
 
   variant: string;
 
-  constructor(ast: ast.UnicodeStringLiteral, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.UnicodeStringLiteral,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     this.variant = ast.variant.unparse();
 
diff --git a/src/slang-nodes/UnicodeStringLiterals.ts b/src/slang-nodes/UnicodeStringLiterals.ts
index 3faadae22..9f88c7fa5 100644
--- a/src/slang-nodes/UnicodeStringLiterals.ts
+++ b/src/slang-nodes/UnicodeStringLiterals.ts
@@ -5,7 +5,7 @@ import { UnicodeStringLiteral } from './UnicodeStringLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { join, hardline } = doc.builders;
@@ -15,11 +15,15 @@ export class UnicodeStringLiterals extends SlangNode {
 
   items: UnicodeStringLiteral[];
 
-  constructor(ast: ast.UnicodeStringLiterals, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.UnicodeStringLiterals,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map(
-      (item) => new UnicodeStringLiteral(item, options)
+      (item) => new UnicodeStringLiteral(item, collected, options)
     );
   }
 
diff --git a/src/slang-nodes/UnnamedFunctionAttribute.ts b/src/slang-nodes/UnnamedFunctionAttribute.ts
index caaf4e447..ac2a1baf7 100644
--- a/src/slang-nodes/UnnamedFunctionAttribute.ts
+++ b/src/slang-nodes/UnnamedFunctionAttribute.ts
@@ -8,6 +8,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class UnnamedFunctionAttribute extends SlangNode {
@@ -17,16 +18,17 @@ export class UnnamedFunctionAttribute extends SlangNode {
 
   constructor(
     ast: ast.UnnamedFunctionAttribute,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new ModifierInvocation(variant, options);
+    this.variant = new ModifierInvocation(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/UnnamedFunctionAttributes.ts b/src/slang-nodes/UnnamedFunctionAttributes.ts
index 52ceb3ff0..ed61d1698 100644
--- a/src/slang-nodes/UnnamedFunctionAttributes.ts
+++ b/src/slang-nodes/UnnamedFunctionAttributes.ts
@@ -7,7 +7,7 @@ import { UnnamedFunctionAttribute } from './UnnamedFunctionAttribute.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line } = doc.builders;
@@ -19,12 +19,13 @@ export class UnnamedFunctionAttributes extends SlangNode {
 
   constructor(
     ast: ast.UnnamedFunctionAttributes,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast, true);
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new UnnamedFunctionAttribute(item, options))
+      extractVariant(new UnnamedFunctionAttribute(item, collected, options))
     );
 
     this.items.sort(sortFunctionAttributes);
diff --git a/src/slang-nodes/UnnamedFunctionDefinition.ts b/src/slang-nodes/UnnamedFunctionDefinition.ts
index 71a0c8414..53d937854 100644
--- a/src/slang-nodes/UnnamedFunctionDefinition.ts
+++ b/src/slang-nodes/UnnamedFunctionDefinition.ts
@@ -8,7 +8,7 @@ import { FunctionBody } from './FunctionBody.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class UnnamedFunctionDefinition extends SlangNode {
@@ -22,13 +22,22 @@ export class UnnamedFunctionDefinition extends SlangNode {
 
   constructor(
     ast: ast.UnnamedFunctionDefinition,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
-
-    this.parameters = new ParametersDeclaration(ast.parameters, options);
-    this.attributes = new UnnamedFunctionAttributes(ast.attributes, options);
-    this.body = extractVariant(new FunctionBody(ast.body, options));
+    super(ast, collected);
+
+    this.parameters = new ParametersDeclaration(
+      ast.parameters,
+      collected,
+      options
+    );
+    this.attributes = new UnnamedFunctionAttributes(
+      ast.attributes,
+      collected,
+      options
+    );
+    this.body = extractVariant(new FunctionBody(ast.body, collected, options));
 
     this.updateMetadata(this.parameters, this.attributes, this.body);
 
diff --git a/src/slang-nodes/UntypedTupleMember.ts b/src/slang-nodes/UntypedTupleMember.ts
index 3220fe913..443cd6e68 100644
--- a/src/slang-nodes/UntypedTupleMember.ts
+++ b/src/slang-nodes/UntypedTupleMember.ts
@@ -6,7 +6,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class UntypedTupleMember extends SlangNode {
   readonly kind = NonterminalKind.UntypedTupleMember;
@@ -15,13 +15,16 @@ export class UntypedTupleMember extends SlangNode {
 
   name: TerminalNode;
 
-  constructor(ast: ast.UntypedTupleMember) {
-    super(ast);
+  constructor(ast: ast.UntypedTupleMember, collected: CollectedMetadata) {
+    super(ast, collected);
 
     if (ast.storageLocation) {
-      this.storageLocation = new StorageLocation(ast.storageLocation);
+      this.storageLocation = new StorageLocation(
+        ast.storageLocation,
+        collected
+      );
     }
-    this.name = new TerminalNode(ast.name);
+    this.name = new TerminalNode(ast.name, collected);
 
     this.updateMetadata(this.storageLocation);
   }
diff --git a/src/slang-nodes/UserDefinedValueTypeDefinition.ts b/src/slang-nodes/UserDefinedValueTypeDefinition.ts
index a9e5ea8c5..97ab74a22 100644
--- a/src/slang-nodes/UserDefinedValueTypeDefinition.ts
+++ b/src/slang-nodes/UserDefinedValueTypeDefinition.ts
@@ -6,7 +6,7 @@ import { ElementaryType } from './ElementaryType.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class UserDefinedValueTypeDefinition extends SlangNode {
   readonly kind = NonterminalKind.UserDefinedValueTypeDefinition;
@@ -15,11 +15,16 @@ export class UserDefinedValueTypeDefinition extends SlangNode {
 
   valueType: ElementaryType['variant'];
 
-  constructor(ast: ast.UserDefinedValueTypeDefinition) {
-    super(ast);
+  constructor(
+    ast: ast.UserDefinedValueTypeDefinition,
+    collected: CollectedMetadata
+  ) {
+    super(ast, collected);
 
-    this.name = new TerminalNode(ast.name);
-    this.valueType = extractVariant(new ElementaryType(ast.valueType));
+    this.name = new TerminalNode(ast.name, collected);
+    this.valueType = extractVariant(
+      new ElementaryType(ast.valueType, collected)
+    );
 
     this.updateMetadata(this.valueType);
   }
diff --git a/src/slang-nodes/UsingAlias.ts b/src/slang-nodes/UsingAlias.ts
index f1823b6c4..beed641a5 100644
--- a/src/slang-nodes/UsingAlias.ts
+++ b/src/slang-nodes/UsingAlias.ts
@@ -4,17 +4,17 @@ import { UsingOperator } from './UsingOperator.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class UsingAlias extends SlangNode {
   readonly kind = NonterminalKind.UsingAlias;
 
   operator: UsingOperator;
 
-  constructor(ast: ast.UsingAlias) {
-    super(ast);
+  constructor(ast: ast.UsingAlias, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.operator = new UsingOperator(ast.operator);
+    this.operator = new UsingOperator(ast.operator, collected);
 
     this.updateMetadata(this.operator);
   }
diff --git a/src/slang-nodes/UsingClause.ts b/src/slang-nodes/UsingClause.ts
index 38e951b20..53f05044a 100644
--- a/src/slang-nodes/UsingClause.ts
+++ b/src/slang-nodes/UsingClause.ts
@@ -4,14 +4,17 @@ import { SlangNode } from './SlangNode.js';
 import { IdentifierPath } from './IdentifierPath.js';
 import { UsingDeconstruction } from './UsingDeconstruction.js';
 
+import type { CollectedMetadata } from '../types.d.ts';
+
 function createNonterminalVariant(
-  variant: ast.UsingClause['variant']
+  variant: ast.UsingClause['variant'],
+  collected: CollectedMetadata
 ): UsingClause['variant'] {
   if (variant instanceof ast.IdentifierPath) {
-    return new IdentifierPath(variant);
+    return new IdentifierPath(variant, collected);
   }
   if (variant instanceof ast.UsingDeconstruction) {
-    return new UsingDeconstruction(variant);
+    return new UsingDeconstruction(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -22,10 +25,10 @@ export class UsingClause extends SlangNode {
 
   variant: IdentifierPath | UsingDeconstruction;
 
-  constructor(ast: ast.UsingClause) {
-    super(ast);
+  constructor(ast: ast.UsingClause, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant);
+    this.variant = createNonterminalVariant(ast.variant, collected);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/UsingDeconstruction.ts b/src/slang-nodes/UsingDeconstruction.ts
index 940290fc1..7d261c044 100644
--- a/src/slang-nodes/UsingDeconstruction.ts
+++ b/src/slang-nodes/UsingDeconstruction.ts
@@ -4,17 +4,17 @@ import { UsingDeconstructionSymbols } from './UsingDeconstructionSymbols.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class UsingDeconstruction extends SlangNode {
   readonly kind = NonterminalKind.UsingDeconstruction;
 
   symbols: UsingDeconstructionSymbols;
 
-  constructor(ast: ast.UsingDeconstruction) {
-    super(ast);
+  constructor(ast: ast.UsingDeconstruction, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.symbols = new UsingDeconstructionSymbols(ast.symbols);
+    this.symbols = new UsingDeconstructionSymbols(ast.symbols, collected);
 
     this.updateMetadata(this.symbols);
   }
diff --git a/src/slang-nodes/UsingDeconstructionSymbol.ts b/src/slang-nodes/UsingDeconstructionSymbol.ts
index 6158ee528..edd7df842 100644
--- a/src/slang-nodes/UsingDeconstructionSymbol.ts
+++ b/src/slang-nodes/UsingDeconstructionSymbol.ts
@@ -5,7 +5,7 @@ import { UsingAlias } from './UsingAlias.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class UsingDeconstructionSymbol extends SlangNode {
   readonly kind = NonterminalKind.UsingDeconstructionSymbol;
@@ -14,12 +14,15 @@ export class UsingDeconstructionSymbol extends SlangNode {
 
   alias?: UsingAlias;
 
-  constructor(ast: ast.UsingDeconstructionSymbol) {
-    super(ast);
+  constructor(
+    ast: ast.UsingDeconstructionSymbol,
+    collected: CollectedMetadata
+  ) {
+    super(ast, collected);
 
-    this.name = new IdentifierPath(ast.name);
+    this.name = new IdentifierPath(ast.name, collected);
     if (ast.alias) {
-      this.alias = new UsingAlias(ast.alias);
+      this.alias = new UsingAlias(ast.alias, collected);
     }
 
     this.updateMetadata(this.name, this.alias);
diff --git a/src/slang-nodes/UsingDeconstructionSymbols.ts b/src/slang-nodes/UsingDeconstructionSymbols.ts
index aad43cbc5..def7fe523 100644
--- a/src/slang-nodes/UsingDeconstructionSymbols.ts
+++ b/src/slang-nodes/UsingDeconstructionSymbols.ts
@@ -6,7 +6,7 @@ import { UsingDeconstructionSymbol } from './UsingDeconstructionSymbol.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { line, softline } = doc.builders;
@@ -16,10 +16,15 @@ export class UsingDeconstructionSymbols extends SlangNode {
 
   items: UsingDeconstructionSymbol[];
 
-  constructor(ast: ast.UsingDeconstructionSymbols) {
-    super(ast, true);
+  constructor(
+    ast: ast.UsingDeconstructionSymbols,
+    collected: CollectedMetadata
+  ) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new UsingDeconstructionSymbol(item));
+    this.items = ast.items.map(
+      (item) => new UsingDeconstructionSymbol(item, collected)
+    );
   }
 
   print(
diff --git a/src/slang-nodes/UsingDirective.ts b/src/slang-nodes/UsingDirective.ts
index 10f1789a8..164fe13d0 100644
--- a/src/slang-nodes/UsingDirective.ts
+++ b/src/slang-nodes/UsingDirective.ts
@@ -6,7 +6,7 @@ import { UsingTarget } from './UsingTarget.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class UsingDirective extends SlangNode {
@@ -18,11 +18,17 @@ export class UsingDirective extends SlangNode {
 
   globalKeyword?: string;
 
-  constructor(ast: ast.UsingDirective, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.clause = extractVariant(new UsingClause(ast.clause));
-    this.target = extractVariant(new UsingTarget(ast.target, options));
+  constructor(
+    ast: ast.UsingDirective,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.clause = extractVariant(new UsingClause(ast.clause, collected));
+    this.target = extractVariant(
+      new UsingTarget(ast.target, collected, options)
+    );
     this.globalKeyword = ast.globalKeyword?.unparse();
 
     this.updateMetadata(this.clause, this.target);
diff --git a/src/slang-nodes/UsingOperator.ts b/src/slang-nodes/UsingOperator.ts
index 48cbbe861..d4f91a778 100644
--- a/src/slang-nodes/UsingOperator.ts
+++ b/src/slang-nodes/UsingOperator.ts
@@ -3,14 +3,15 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class UsingOperator extends SlangNode {
   readonly kind = NonterminalKind.UsingOperator;
 
   variant: string;
 
-  constructor(ast: ast.UsingOperator) {
-    super(ast);
+  constructor(ast: ast.UsingOperator, collected: CollectedMetadata) {
+    super(ast, collected);
 
     this.variant = ast.variant.unparse();
   }
diff --git a/src/slang-nodes/UsingTarget.ts b/src/slang-nodes/UsingTarget.ts
index 74d07e770..11c8eba25 100644
--- a/src/slang-nodes/UsingTarget.ts
+++ b/src/slang-nodes/UsingTarget.ts
@@ -9,6 +9,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class UsingTarget extends SlangNode {
@@ -16,15 +17,19 @@ export class UsingTarget extends SlangNode {
 
   variant: TypeName['variant'] | TerminalNode;
 
-  constructor(ast: ast.UsingTarget, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.UsingTarget,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = extractVariant(new TypeName(variant, options));
+    this.variant = extractVariant(new TypeName(variant, collected, options));
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/VariableDeclarationStatement.ts b/src/slang-nodes/VariableDeclarationStatement.ts
index b777d637f..887fffe86 100644
--- a/src/slang-nodes/VariableDeclarationStatement.ts
+++ b/src/slang-nodes/VariableDeclarationStatement.ts
@@ -10,7 +10,7 @@ import { VariableDeclarationValue } from './VariableDeclarationValue.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { indent, line } = doc.builders;
@@ -28,19 +28,23 @@ export class VariableDeclarationStatement extends SlangNode {
 
   constructor(
     ast: ast.VariableDeclarationStatement,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
     this.variableType = extractVariant(
-      new VariableDeclarationType(ast.variableType, options)
+      new VariableDeclarationType(ast.variableType, collected, options)
     );
     if (ast.storageLocation) {
-      this.storageLocation = new StorageLocation(ast.storageLocation);
+      this.storageLocation = new StorageLocation(
+        ast.storageLocation,
+        collected
+      );
     }
-    this.name = new TerminalNode(ast.name);
+    this.name = new TerminalNode(ast.name, collected);
     if (ast.value) {
-      this.value = new VariableDeclarationValue(ast.value, options);
+      this.value = new VariableDeclarationValue(ast.value, collected, options);
     }
 
     this.updateMetadata(this.variableType, this.storageLocation, this.value);
diff --git a/src/slang-nodes/VariableDeclarationType.ts b/src/slang-nodes/VariableDeclarationType.ts
index 99bfff663..628b419ab 100644
--- a/src/slang-nodes/VariableDeclarationType.ts
+++ b/src/slang-nodes/VariableDeclarationType.ts
@@ -9,6 +9,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class VariableDeclarationType extends SlangNode {
@@ -18,16 +19,17 @@ export class VariableDeclarationType extends SlangNode {
 
   constructor(
     ast: ast.VariableDeclarationType,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = extractVariant(new TypeName(variant, options));
+    this.variant = extractVariant(new TypeName(variant, collected, options));
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/VariableDeclarationValue.ts b/src/slang-nodes/VariableDeclarationValue.ts
index 1306002ca..03c989424 100644
--- a/src/slang-nodes/VariableDeclarationValue.ts
+++ b/src/slang-nodes/VariableDeclarationValue.ts
@@ -5,7 +5,7 @@ import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class VariableDeclarationValue extends SlangNode {
@@ -15,11 +15,14 @@ export class VariableDeclarationValue extends SlangNode {
 
   constructor(
     ast: ast.VariableDeclarationValue,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.expression = extractVariant(new Expression(ast.expression, options));
+    this.expression = extractVariant(
+      new Expression(ast.expression, collected, options)
+    );
 
     this.updateMetadata(this.expression);
   }
diff --git a/src/slang-nodes/VersionExpression.ts b/src/slang-nodes/VersionExpression.ts
index d0661724d..ac1339e0d 100644
--- a/src/slang-nodes/VersionExpression.ts
+++ b/src/slang-nodes/VersionExpression.ts
@@ -4,14 +4,17 @@ import { SlangNode } from './SlangNode.js';
 import { VersionRange } from './VersionRange.js';
 import { VersionTerm } from './VersionTerm.js';
 
+import type { CollectedMetadata } from '../types.d.ts';
+
 function createNonterminalVariant(
-  variant: ast.VersionExpression['variant']
+  variant: ast.VersionExpression['variant'],
+  collected: CollectedMetadata
 ): VersionExpression['variant'] {
   if (variant instanceof ast.VersionRange) {
-    return new VersionRange(variant);
+    return new VersionRange(variant, collected);
   }
   if (variant instanceof ast.VersionTerm) {
-    return new VersionTerm(variant);
+    return new VersionTerm(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -22,10 +25,10 @@ export class VersionExpression extends SlangNode {
 
   variant: VersionRange | VersionTerm;
 
-  constructor(ast: ast.VersionExpression) {
-    super(ast);
+  constructor(ast: ast.VersionExpression, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant);
+    this.variant = createNonterminalVariant(ast.variant, collected);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/VersionExpressionSet.ts b/src/slang-nodes/VersionExpressionSet.ts
index 25d58d6c6..a364d8563 100644
--- a/src/slang-nodes/VersionExpressionSet.ts
+++ b/src/slang-nodes/VersionExpressionSet.ts
@@ -6,7 +6,7 @@ import { VersionExpression } from './VersionExpression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { join } = doc.builders;
 
@@ -15,11 +15,11 @@ export class VersionExpressionSet extends SlangNode {
 
   items: VersionExpression['variant'][];
 
-  constructor(ast: ast.VersionExpressionSet) {
-    super(ast, true);
+  constructor(ast: ast.VersionExpressionSet, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new VersionExpression(item))
+      extractVariant(new VersionExpression(item, collected))
     );
   }
 
diff --git a/src/slang-nodes/VersionExpressionSets.ts b/src/slang-nodes/VersionExpressionSets.ts
index 4a7e2f317..3b72c95dc 100644
--- a/src/slang-nodes/VersionExpressionSets.ts
+++ b/src/slang-nodes/VersionExpressionSets.ts
@@ -5,7 +5,7 @@ import { VersionExpressionSet } from './VersionExpressionSet.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { join } = doc.builders;
 
@@ -14,10 +14,12 @@ export class VersionExpressionSets extends SlangNode {
 
   items: VersionExpressionSet[];
 
-  constructor(ast: ast.VersionExpressionSets) {
-    super(ast, true);
+  constructor(ast: ast.VersionExpressionSets, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new VersionExpressionSet(item));
+    this.items = ast.items.map(
+      (item) => new VersionExpressionSet(item, collected)
+    );
   }
 
   print(path: AstPath<VersionExpressionSets>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/VersionLiteral.ts b/src/slang-nodes/VersionLiteral.ts
index 6d13cfb2a..1950711ec 100644
--- a/src/slang-nodes/VersionLiteral.ts
+++ b/src/slang-nodes/VersionLiteral.ts
@@ -7,21 +7,22 @@ import { SimpleVersionLiteral } from './SimpleVersionLiteral.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class VersionLiteral extends SlangNode {
   readonly kind = NonterminalKind.VersionLiteral;
 
   variant: SimpleVersionLiteral | TerminalNode;
 
-  constructor(ast: ast.VersionLiteral) {
-    super(ast);
+  constructor(ast: ast.VersionLiteral, collected: CollectedMetadata) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new SimpleVersionLiteral(variant);
+    this.variant = new SimpleVersionLiteral(variant, collected);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/VersionOperator.ts b/src/slang-nodes/VersionOperator.ts
index a94a213f0..a9408e02b 100644
--- a/src/slang-nodes/VersionOperator.ts
+++ b/src/slang-nodes/VersionOperator.ts
@@ -3,14 +3,15 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class VersionOperator extends SlangNode {
   readonly kind = NonterminalKind.VersionOperator;
 
   variant: string;
 
-  constructor(ast: ast.VersionOperator) {
-    super(ast);
+  constructor(ast: ast.VersionOperator, collected: CollectedMetadata) {
+    super(ast, collected);
 
     this.variant = ast.variant.unparse();
   }
diff --git a/src/slang-nodes/VersionPragma.ts b/src/slang-nodes/VersionPragma.ts
index 3f7fecf86..16e2c260d 100644
--- a/src/slang-nodes/VersionPragma.ts
+++ b/src/slang-nodes/VersionPragma.ts
@@ -4,17 +4,17 @@ import { VersionExpressionSets } from './VersionExpressionSets.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class VersionPragma extends SlangNode {
   readonly kind = NonterminalKind.VersionPragma;
 
   sets: VersionExpressionSets;
 
-  constructor(ast: ast.VersionPragma) {
-    super(ast);
+  constructor(ast: ast.VersionPragma, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.sets = new VersionExpressionSets(ast.sets);
+    this.sets = new VersionExpressionSets(ast.sets, collected);
 
     this.updateMetadata(this.sets);
   }
diff --git a/src/slang-nodes/VersionRange.ts b/src/slang-nodes/VersionRange.ts
index 9da999c9c..a82085ab5 100644
--- a/src/slang-nodes/VersionRange.ts
+++ b/src/slang-nodes/VersionRange.ts
@@ -5,7 +5,7 @@ import { VersionLiteral } from './VersionLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class VersionRange extends SlangNode {
   readonly kind = NonterminalKind.VersionRange;
@@ -14,11 +14,11 @@ export class VersionRange extends SlangNode {
 
   end: VersionLiteral['variant'];
 
-  constructor(ast: ast.VersionRange) {
-    super(ast);
+  constructor(ast: ast.VersionRange, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.start = extractVariant(new VersionLiteral(ast.start));
-    this.end = extractVariant(new VersionLiteral(ast.end));
+    this.start = extractVariant(new VersionLiteral(ast.start, collected));
+    this.end = extractVariant(new VersionLiteral(ast.end, collected));
 
     this.updateMetadata(this.start, this.end);
   }
diff --git a/src/slang-nodes/VersionTerm.ts b/src/slang-nodes/VersionTerm.ts
index e4a2dfc02..dd1362877 100644
--- a/src/slang-nodes/VersionTerm.ts
+++ b/src/slang-nodes/VersionTerm.ts
@@ -6,7 +6,7 @@ import { VersionLiteral } from './VersionLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class VersionTerm extends SlangNode {
   readonly kind = NonterminalKind.VersionTerm;
@@ -15,13 +15,13 @@ export class VersionTerm extends SlangNode {
 
   literal: VersionLiteral['variant'];
 
-  constructor(ast: ast.VersionTerm) {
-    super(ast);
+  constructor(ast: ast.VersionTerm, collected: CollectedMetadata) {
+    super(ast, collected);
 
     if (ast.operator) {
-      this.operator = new VersionOperator(ast.operator);
+      this.operator = new VersionOperator(ast.operator, collected);
     }
-    this.literal = extractVariant(new VersionLiteral(ast.literal));
+    this.literal = extractVariant(new VersionLiteral(ast.literal, collected));
 
     this.updateMetadata(this.operator, this.literal);
   }
diff --git a/src/slang-nodes/WhileStatement.ts b/src/slang-nodes/WhileStatement.ts
index ccbd35772..6676817b1 100644
--- a/src/slang-nodes/WhileStatement.ts
+++ b/src/slang-nodes/WhileStatement.ts
@@ -8,7 +8,7 @@ import { Statement } from './Statement.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class WhileStatement extends SlangNode {
@@ -18,11 +18,17 @@ export class WhileStatement extends SlangNode {
 
   body: Statement['variant'];
 
-  constructor(ast: ast.WhileStatement, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.condition = extractVariant(new Expression(ast.condition, options));
-    this.body = extractVariant(new Statement(ast.body, options));
+  constructor(
+    ast: ast.WhileStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.condition = extractVariant(
+      new Expression(ast.condition, collected, options)
+    );
+    this.body = extractVariant(new Statement(ast.body, collected, options));
 
     this.updateMetadata(this.condition, this.body);
   }
diff --git a/src/slang-nodes/YulArguments.ts b/src/slang-nodes/YulArguments.ts
index 1309f3f1b..2d3bd0f63 100644
--- a/src/slang-nodes/YulArguments.ts
+++ b/src/slang-nodes/YulArguments.ts
@@ -6,7 +6,7 @@ import { YulExpression } from './YulExpression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class YulArguments extends SlangNode {
@@ -14,11 +14,15 @@ export class YulArguments extends SlangNode {
 
   items: YulExpression['variant'][];
 
-  constructor(ast: ast.YulArguments, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.YulArguments,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new YulExpression(item, options))
+      extractVariant(new YulExpression(item, collected, options))
     );
   }
 
diff --git a/src/slang-nodes/YulAssignmentOperator.ts b/src/slang-nodes/YulAssignmentOperator.ts
index e23ebed1b..93e6384e3 100644
--- a/src/slang-nodes/YulAssignmentOperator.ts
+++ b/src/slang-nodes/YulAssignmentOperator.ts
@@ -7,21 +7,22 @@ import { YulColonAndEqual } from './YulColonAndEqual.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class YulAssignmentOperator extends SlangNode {
   readonly kind = NonterminalKind.YulAssignmentOperator;
 
   variant: YulColonAndEqual | TerminalNode;
 
-  constructor(ast: ast.YulAssignmentOperator) {
-    super(ast);
+  constructor(ast: ast.YulAssignmentOperator, collected: CollectedMetadata) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new YulColonAndEqual(variant);
+    this.variant = new YulColonAndEqual(variant, collected);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/YulBlock.ts b/src/slang-nodes/YulBlock.ts
index 7b80d6829..1f14641e3 100644
--- a/src/slang-nodes/YulBlock.ts
+++ b/src/slang-nodes/YulBlock.ts
@@ -4,7 +4,7 @@ import { YulStatements } from './YulStatements.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class YulBlock extends SlangNode {
@@ -12,10 +12,14 @@ export class YulBlock extends SlangNode {
 
   statements: YulStatements;
 
-  constructor(ast: ast.YulBlock, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.YulBlock,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.statements = new YulStatements(ast.statements, options);
+    this.statements = new YulStatements(ast.statements, collected, options);
 
     this.updateMetadata(this.statements);
   }
diff --git a/src/slang-nodes/YulBreakStatement.ts b/src/slang-nodes/YulBreakStatement.ts
index 96a48843c..14ad3dc97 100644
--- a/src/slang-nodes/YulBreakStatement.ts
+++ b/src/slang-nodes/YulBreakStatement.ts
@@ -3,12 +3,13 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class YulBreakStatement extends SlangNode {
   readonly kind = NonterminalKind.YulBreakStatement;
 
-  constructor(ast: ast.YulBreakStatement) {
-    super(ast);
+  constructor(ast: ast.YulBreakStatement, collected: CollectedMetadata) {
+    super(ast, collected);
   }
 
   print(): Doc {
diff --git a/src/slang-nodes/YulColonAndEqual.ts b/src/slang-nodes/YulColonAndEqual.ts
index 3e9f49d2f..b6cf41114 100644
--- a/src/slang-nodes/YulColonAndEqual.ts
+++ b/src/slang-nodes/YulColonAndEqual.ts
@@ -3,12 +3,13 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class YulColonAndEqual extends SlangNode {
   readonly kind = NonterminalKind.YulColonAndEqual;
 
-  constructor(ast: ast.YulColonAndEqual) {
-    super(ast);
+  constructor(ast: ast.YulColonAndEqual, collected: CollectedMetadata) {
+    super(ast, collected);
   }
 
   print(): Doc {
diff --git a/src/slang-nodes/YulContinueStatement.ts b/src/slang-nodes/YulContinueStatement.ts
index 93bbd3eb2..11427e729 100644
--- a/src/slang-nodes/YulContinueStatement.ts
+++ b/src/slang-nodes/YulContinueStatement.ts
@@ -3,12 +3,13 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class YulContinueStatement extends SlangNode {
   readonly kind = NonterminalKind.YulContinueStatement;
 
-  constructor(ast: ast.YulContinueStatement) {
-    super(ast);
+  constructor(ast: ast.YulContinueStatement, collected: CollectedMetadata) {
+    super(ast, collected);
   }
 
   print(): Doc {
diff --git a/src/slang-nodes/YulDefaultCase.ts b/src/slang-nodes/YulDefaultCase.ts
index 9768042a0..12ff0f9c7 100644
--- a/src/slang-nodes/YulDefaultCase.ts
+++ b/src/slang-nodes/YulDefaultCase.ts
@@ -4,7 +4,7 @@ import { YulBlock } from './YulBlock.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class YulDefaultCase extends SlangNode {
@@ -12,10 +12,14 @@ export class YulDefaultCase extends SlangNode {
 
   body: YulBlock;
 
-  constructor(ast: ast.YulDefaultCase, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.YulDefaultCase,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.body = new YulBlock(ast.body, options);
+    this.body = new YulBlock(ast.body, collected, options);
 
     this.updateMetadata(this.body);
   }
diff --git a/src/slang-nodes/YulEqualAndColon.ts b/src/slang-nodes/YulEqualAndColon.ts
index eac4d384d..17e930d75 100644
--- a/src/slang-nodes/YulEqualAndColon.ts
+++ b/src/slang-nodes/YulEqualAndColon.ts
@@ -3,12 +3,13 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class YulEqualAndColon extends SlangNode {
   readonly kind = NonterminalKind.YulEqualAndColon;
 
-  constructor(ast: ast.YulEqualAndColon) {
-    super(ast);
+  constructor(ast: ast.YulEqualAndColon, collected: CollectedMetadata) {
+    super(ast, collected);
   }
 
   print(): Doc {
diff --git a/src/slang-nodes/YulExpression.ts b/src/slang-nodes/YulExpression.ts
index dd697cc5c..8b1312906 100644
--- a/src/slang-nodes/YulExpression.ts
+++ b/src/slang-nodes/YulExpression.ts
@@ -7,20 +7,22 @@ import { YulLiteral } from './YulLiteral.js';
 import { YulPath } from './YulPath.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.YulExpression['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): YulExpression['variant'] {
   if (variant instanceof ast.YulFunctionCallExpression) {
-    return new YulFunctionCallExpression(variant, options);
+    return new YulFunctionCallExpression(variant, collected, options);
   }
   if (variant instanceof ast.YulLiteral) {
-    return extractVariant(new YulLiteral(variant, options));
+    return extractVariant(new YulLiteral(variant, collected, options));
   }
   if (variant instanceof ast.YulPath) {
-    return new YulPath(variant);
+    return new YulPath(variant, collected);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -31,10 +33,14 @@ export class YulExpression extends SlangNode {
 
   variant: YulFunctionCallExpression | YulLiteral['variant'] | YulPath;
 
-  constructor(ast: ast.YulExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.YulExpression,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/YulForStatement.ts b/src/slang-nodes/YulForStatement.ts
index 1fdeb2b85..070a2b632 100644
--- a/src/slang-nodes/YulForStatement.ts
+++ b/src/slang-nodes/YulForStatement.ts
@@ -7,7 +7,7 @@ import { YulExpression } from './YulExpression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { join } = doc.builders;
@@ -23,13 +23,19 @@ export class YulForStatement extends SlangNode {
 
   body: YulBlock;
 
-  constructor(ast: ast.YulForStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.YulForStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.initialization = new YulBlock(ast.initialization, options);
-    this.condition = extractVariant(new YulExpression(ast.condition, options));
-    this.iterator = new YulBlock(ast.iterator, options);
-    this.body = new YulBlock(ast.body, options);
+    this.initialization = new YulBlock(ast.initialization, collected, options);
+    this.condition = extractVariant(
+      new YulExpression(ast.condition, collected, options)
+    );
+    this.iterator = new YulBlock(ast.iterator, collected, options);
+    this.body = new YulBlock(ast.body, collected, options);
 
     this.updateMetadata(
       this.initialization,
diff --git a/src/slang-nodes/YulFunctionCallExpression.ts b/src/slang-nodes/YulFunctionCallExpression.ts
index 6b5f5bc4f..45b7f032d 100644
--- a/src/slang-nodes/YulFunctionCallExpression.ts
+++ b/src/slang-nodes/YulFunctionCallExpression.ts
@@ -6,7 +6,7 @@ import { YulArguments } from './YulArguments.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class YulFunctionCallExpression extends SlangNode {
@@ -18,12 +18,15 @@ export class YulFunctionCallExpression extends SlangNode {
 
   constructor(
     ast: ast.YulFunctionCallExpression,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.operand = extractVariant(new YulExpression(ast.operand, options));
-    this.arguments = new YulArguments(ast.arguments, options);
+    this.operand = extractVariant(
+      new YulExpression(ast.operand, collected, options)
+    );
+    this.arguments = new YulArguments(ast.arguments, collected, options);
 
     this.updateMetadata(this.operand, this.arguments);
   }
diff --git a/src/slang-nodes/YulFunctionDefinition.ts b/src/slang-nodes/YulFunctionDefinition.ts
index ce30edbbc..dff5064ff 100644
--- a/src/slang-nodes/YulFunctionDefinition.ts
+++ b/src/slang-nodes/YulFunctionDefinition.ts
@@ -7,7 +7,7 @@ import { YulBlock } from './YulBlock.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class YulFunctionDefinition extends SlangNode {
@@ -21,15 +21,19 @@ export class YulFunctionDefinition extends SlangNode {
 
   body: YulBlock;
 
-  constructor(ast: ast.YulFunctionDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.YulFunctionDefinition,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.name = new TerminalNode(ast.name);
-    this.parameters = new YulParametersDeclaration(ast.parameters);
+    this.name = new TerminalNode(ast.name, collected);
+    this.parameters = new YulParametersDeclaration(ast.parameters, collected);
     if (ast.returns) {
-      this.returns = new YulReturnsDeclaration(ast.returns);
+      this.returns = new YulReturnsDeclaration(ast.returns, collected);
     }
-    this.body = new YulBlock(ast.body, options);
+    this.body = new YulBlock(ast.body, collected, options);
 
     this.updateMetadata(this.parameters, this.returns, this.body);
   }
diff --git a/src/slang-nodes/YulIfStatement.ts b/src/slang-nodes/YulIfStatement.ts
index 5be71f59e..037b2426d 100644
--- a/src/slang-nodes/YulIfStatement.ts
+++ b/src/slang-nodes/YulIfStatement.ts
@@ -6,7 +6,7 @@ import { YulBlock } from './YulBlock.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class YulIfStatement extends SlangNode {
@@ -16,11 +16,17 @@ export class YulIfStatement extends SlangNode {
 
   body: YulBlock;
 
-  constructor(ast: ast.YulIfStatement, options: ParserOptions<AstNode>) {
-    super(ast);
-
-    this.condition = extractVariant(new YulExpression(ast.condition, options));
-    this.body = new YulBlock(ast.body, options);
+  constructor(
+    ast: ast.YulIfStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
+
+    this.condition = extractVariant(
+      new YulExpression(ast.condition, collected, options)
+    );
+    this.body = new YulBlock(ast.body, collected, options);
 
     this.updateMetadata(this.condition, this.body);
   }
diff --git a/src/slang-nodes/YulLabel.ts b/src/slang-nodes/YulLabel.ts
index a9d6b47ce..dc2945967 100644
--- a/src/slang-nodes/YulLabel.ts
+++ b/src/slang-nodes/YulLabel.ts
@@ -5,7 +5,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { dedent, line } = doc.builders;
 
@@ -14,10 +14,10 @@ export class YulLabel extends SlangNode {
 
   label: TerminalNode;
 
-  constructor(ast: ast.YulLabel) {
-    super(ast);
+  constructor(ast: ast.YulLabel, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.label = new TerminalNode(ast.label);
+    this.label = new TerminalNode(ast.label, collected);
   }
 
   print(path: AstPath<YulLabel>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/YulLeaveStatement.ts b/src/slang-nodes/YulLeaveStatement.ts
index eccf192b8..fd246bfdd 100644
--- a/src/slang-nodes/YulLeaveStatement.ts
+++ b/src/slang-nodes/YulLeaveStatement.ts
@@ -3,12 +3,13 @@ import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class YulLeaveStatement extends SlangNode {
   readonly kind = NonterminalKind.YulLeaveStatement;
 
-  constructor(ast: ast.YulLeaveStatement) {
-    super(ast);
+  constructor(ast: ast.YulLeaveStatement, collected: CollectedMetadata) {
+    super(ast, collected);
   }
 
   print(): Doc {
diff --git a/src/slang-nodes/YulLiteral.ts b/src/slang-nodes/YulLiteral.ts
index a14f8ee5b..cbfb0194d 100644
--- a/src/slang-nodes/YulLiteral.ts
+++ b/src/slang-nodes/YulLiteral.ts
@@ -9,17 +9,19 @@ import { StringLiteral } from './StringLiteral.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: Exclude<ast.YulLiteral['variant'], SlangTerminalNode>,
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Exclude<YulLiteral['variant'], TerminalNode> {
   if (variant instanceof ast.HexStringLiteral) {
-    return new HexStringLiteral(variant, options);
+    return new HexStringLiteral(variant, collected, options);
   }
   if (variant instanceof ast.StringLiteral) {
-    return new StringLiteral(variant, options);
+    return new StringLiteral(variant, collected, options);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -30,15 +32,19 @@ export class YulLiteral extends SlangNode {
 
   variant: HexStringLiteral | StringLiteral | TerminalNode;
 
-  constructor(ast: ast.YulLiteral, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.YulLiteral,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = createNonterminalVariant(variant, options);
+    this.variant = createNonterminalVariant(variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/YulParameters.ts b/src/slang-nodes/YulParameters.ts
index 435ddc110..a8b1326c9 100644
--- a/src/slang-nodes/YulParameters.ts
+++ b/src/slang-nodes/YulParameters.ts
@@ -5,17 +5,17 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class YulParameters extends SlangNode {
   readonly kind = NonterminalKind.YulParameters;
 
   items: TerminalNode[];
 
-  constructor(ast: ast.YulParameters) {
-    super(ast, true);
+  constructor(ast: ast.YulParameters, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new TerminalNode(item));
+    this.items = ast.items.map((item) => new TerminalNode(item, collected));
   }
 
   print(path: AstPath<YulParameters>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/YulParametersDeclaration.ts b/src/slang-nodes/YulParametersDeclaration.ts
index 1f283930f..434223c50 100644
--- a/src/slang-nodes/YulParametersDeclaration.ts
+++ b/src/slang-nodes/YulParametersDeclaration.ts
@@ -4,17 +4,17 @@ import { YulParameters } from './YulParameters.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 export class YulParametersDeclaration extends SlangNode {
   readonly kind = NonterminalKind.YulParametersDeclaration;
 
   parameters: YulParameters;
 
-  constructor(ast: ast.YulParametersDeclaration) {
-    super(ast);
+  constructor(ast: ast.YulParametersDeclaration, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.parameters = new YulParameters(ast.parameters);
+    this.parameters = new YulParameters(ast.parameters, collected);
 
     this.updateMetadata(this.parameters);
   }
diff --git a/src/slang-nodes/YulPath.ts b/src/slang-nodes/YulPath.ts
index 137cbee6a..7d9cd3e46 100644
--- a/src/slang-nodes/YulPath.ts
+++ b/src/slang-nodes/YulPath.ts
@@ -5,7 +5,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { join } = doc.builders;
 
@@ -14,10 +14,10 @@ export class YulPath extends SlangNode {
 
   items: TerminalNode[];
 
-  constructor(ast: ast.YulPath) {
-    super(ast, true);
+  constructor(ast: ast.YulPath, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new TerminalNode(item));
+    this.items = ast.items.map((item) => new TerminalNode(item, collected));
   }
 
   print(path: AstPath<YulPath>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/YulPaths.ts b/src/slang-nodes/YulPaths.ts
index f655df8e9..8417011b0 100644
--- a/src/slang-nodes/YulPaths.ts
+++ b/src/slang-nodes/YulPaths.ts
@@ -5,7 +5,7 @@ import { YulPath } from './YulPath.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { join } = doc.builders;
 
@@ -14,10 +14,10 @@ export class YulPaths extends SlangNode {
 
   items: YulPath[];
 
-  constructor(ast: ast.YulPaths) {
-    super(ast, true);
+  constructor(ast: ast.YulPaths, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new YulPath(item));
+    this.items = ast.items.map((item) => new YulPath(item, collected));
   }
 
   print(path: AstPath<YulPaths>, print: PrintFunction): Doc {
diff --git a/src/slang-nodes/YulReturnsDeclaration.ts b/src/slang-nodes/YulReturnsDeclaration.ts
index a000de91d..5866d3f3e 100644
--- a/src/slang-nodes/YulReturnsDeclaration.ts
+++ b/src/slang-nodes/YulReturnsDeclaration.ts
@@ -6,7 +6,7 @@ import { YulVariableNames } from './YulVariableNames.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { line } = doc.builders;
 
@@ -15,10 +15,10 @@ export class YulReturnsDeclaration extends SlangNode {
 
   variables: YulVariableNames;
 
-  constructor(ast: ast.YulReturnsDeclaration) {
-    super(ast);
+  constructor(ast: ast.YulReturnsDeclaration, collected: CollectedMetadata) {
+    super(ast, collected);
 
-    this.variables = new YulVariableNames(ast.variables);
+    this.variables = new YulVariableNames(ast.variables, collected);
 
     this.updateMetadata(this.variables);
   }
diff --git a/src/slang-nodes/YulStackAssignmentOperator.ts b/src/slang-nodes/YulStackAssignmentOperator.ts
index 0318ae8bf..9fa0d5e1d 100644
--- a/src/slang-nodes/YulStackAssignmentOperator.ts
+++ b/src/slang-nodes/YulStackAssignmentOperator.ts
@@ -7,21 +7,25 @@ import { YulEqualAndColon } from './YulEqualAndColon.js';
 import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
+import type { CollectedMetadata } from '../types.d.ts';
 
 export class YulStackAssignmentOperator extends SlangNode {
   readonly kind = NonterminalKind.YulStackAssignmentOperator;
 
   variant: YulEqualAndColon | TerminalNode;
 
-  constructor(ast: ast.YulStackAssignmentOperator) {
-    super(ast);
+  constructor(
+    ast: ast.YulStackAssignmentOperator,
+    collected: CollectedMetadata
+  ) {
+    super(ast, collected);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, collected);
       return;
     }
-    this.variant = new YulEqualAndColon(variant);
+    this.variant = new YulEqualAndColon(variant, collected);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/YulStackAssignmentStatement.ts b/src/slang-nodes/YulStackAssignmentStatement.ts
index e2bd99982..f130e0e5e 100644
--- a/src/slang-nodes/YulStackAssignmentStatement.ts
+++ b/src/slang-nodes/YulStackAssignmentStatement.ts
@@ -8,7 +8,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { line } = doc.builders;
 
@@ -19,13 +19,16 @@ export class YulStackAssignmentStatement extends SlangNode {
 
   variable: TerminalNode;
 
-  constructor(ast: ast.YulStackAssignmentStatement) {
-    super(ast);
+  constructor(
+    ast: ast.YulStackAssignmentStatement,
+    collected: CollectedMetadata
+  ) {
+    super(ast, collected);
 
     this.assignment = extractVariant(
-      new YulStackAssignmentOperator(ast.assignment)
+      new YulStackAssignmentOperator(ast.assignment, collected)
     );
-    this.variable = new TerminalNode(ast.variable);
+    this.variable = new TerminalNode(ast.variable, collected);
 
     this.updateMetadata(this.assignment);
   }
diff --git a/src/slang-nodes/YulStatement.ts b/src/slang-nodes/YulStatement.ts
index 88a693eb7..146378877 100644
--- a/src/slang-nodes/YulStatement.ts
+++ b/src/slang-nodes/YulStatement.ts
@@ -17,50 +17,52 @@ import { YulLabel } from './YulLabel.js';
 import { YulExpression } from './YulExpression.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.YulStatement['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): YulStatement['variant'] {
   if (variant instanceof ast.YulBlock) {
-    return new YulBlock(variant, options);
+    return new YulBlock(variant, collected, options);
   }
   if (variant instanceof ast.YulFunctionDefinition) {
-    return new YulFunctionDefinition(variant, options);
+    return new YulFunctionDefinition(variant, collected, options);
   }
   if (variant instanceof ast.YulVariableDeclarationStatement) {
-    return new YulVariableDeclarationStatement(variant, options);
+    return new YulVariableDeclarationStatement(variant, collected, options);
   }
   if (variant instanceof ast.YulVariableAssignmentStatement) {
-    return new YulVariableAssignmentStatement(variant, options);
+    return new YulVariableAssignmentStatement(variant, collected, options);
   }
   if (variant instanceof ast.YulStackAssignmentStatement) {
-    return new YulStackAssignmentStatement(variant);
+    return new YulStackAssignmentStatement(variant, collected);
   }
   if (variant instanceof ast.YulIfStatement) {
-    return new YulIfStatement(variant, options);
+    return new YulIfStatement(variant, collected, options);
   }
   if (variant instanceof ast.YulForStatement) {
-    return new YulForStatement(variant, options);
+    return new YulForStatement(variant, collected, options);
   }
   if (variant instanceof ast.YulSwitchStatement) {
-    return new YulSwitchStatement(variant, options);
+    return new YulSwitchStatement(variant, collected, options);
   }
   if (variant instanceof ast.YulLeaveStatement) {
-    return new YulLeaveStatement(variant);
+    return new YulLeaveStatement(variant, collected);
   }
   if (variant instanceof ast.YulBreakStatement) {
-    return new YulBreakStatement(variant);
+    return new YulBreakStatement(variant, collected);
   }
   if (variant instanceof ast.YulContinueStatement) {
-    return new YulContinueStatement(variant);
+    return new YulContinueStatement(variant, collected);
   }
   if (variant instanceof ast.YulLabel) {
-    return new YulLabel(variant);
+    return new YulLabel(variant, collected);
   }
   if (variant instanceof ast.YulExpression) {
-    return extractVariant(new YulExpression(variant, options));
+    return extractVariant(new YulExpression(variant, collected, options));
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -84,10 +86,14 @@ export class YulStatement extends SlangNode {
     | YulLabel
     | YulExpression['variant'];
 
-  constructor(ast: ast.YulStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.YulStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/YulStatements.ts b/src/slang-nodes/YulStatements.ts
index 6744f1e9b..260ad201a 100644
--- a/src/slang-nodes/YulStatements.ts
+++ b/src/slang-nodes/YulStatements.ts
@@ -8,7 +8,7 @@ import { YulStatement } from './YulStatement.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { hardline } = doc.builders;
@@ -18,11 +18,15 @@ export class YulStatements extends SlangNode {
 
   items: YulStatement['variant'][];
 
-  constructor(ast: ast.YulStatements, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.YulStatements,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new YulStatement(item, options))
+      extractVariant(new YulStatement(item, collected, options))
     );
   }
 
diff --git a/src/slang-nodes/YulSwitchCase.ts b/src/slang-nodes/YulSwitchCase.ts
index aaba336e4..acde4dbcb 100644
--- a/src/slang-nodes/YulSwitchCase.ts
+++ b/src/slang-nodes/YulSwitchCase.ts
@@ -5,17 +5,19 @@ import { YulDefaultCase } from './YulDefaultCase.js';
 import { YulValueCase } from './YulValueCase.js';
 
 import type { ParserOptions } from 'prettier';
+import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 function createNonterminalVariant(
   variant: ast.YulSwitchCase['variant'],
+  collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): YulSwitchCase['variant'] {
   if (variant instanceof ast.YulDefaultCase) {
-    return new YulDefaultCase(variant, options);
+    return new YulDefaultCase(variant, collected, options);
   }
   if (variant instanceof ast.YulValueCase) {
-    return new YulValueCase(variant, options);
+    return new YulValueCase(variant, collected, options);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -26,10 +28,14 @@ export class YulSwitchCase extends SlangNode {
 
   variant: YulDefaultCase | YulValueCase;
 
-  constructor(ast: ast.YulSwitchCase, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.YulSwitchCase,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.variant = createNonterminalVariant(ast.variant, options);
+    this.variant = createNonterminalVariant(ast.variant, collected, options);
 
     this.updateMetadata(this.variant);
   }
diff --git a/src/slang-nodes/YulSwitchCases.ts b/src/slang-nodes/YulSwitchCases.ts
index 0b0d672b2..c14cd16ec 100644
--- a/src/slang-nodes/YulSwitchCases.ts
+++ b/src/slang-nodes/YulSwitchCases.ts
@@ -6,7 +6,7 @@ import { YulSwitchCase } from './YulSwitchCase.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { hardline, join } = doc.builders;
@@ -16,11 +16,15 @@ export class YulSwitchCases extends SlangNode {
 
   items: YulSwitchCase['variant'][];
 
-  constructor(ast: ast.YulSwitchCases, options: ParserOptions<AstNode>) {
-    super(ast, true);
+  constructor(
+    ast: ast.YulSwitchCases,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected, true);
 
     this.items = ast.items.map((item) =>
-      extractVariant(new YulSwitchCase(item, options))
+      extractVariant(new YulSwitchCase(item, collected, options))
     );
   }
 
diff --git a/src/slang-nodes/YulSwitchStatement.ts b/src/slang-nodes/YulSwitchStatement.ts
index 319fa26be..ab9248db2 100644
--- a/src/slang-nodes/YulSwitchStatement.ts
+++ b/src/slang-nodes/YulSwitchStatement.ts
@@ -7,7 +7,7 @@ import { YulSwitchCases } from './YulSwitchCases.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { hardline } = doc.builders;
@@ -19,13 +19,17 @@ export class YulSwitchStatement extends SlangNode {
 
   cases: YulSwitchCases;
 
-  constructor(ast: ast.YulSwitchStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.YulSwitchStatement,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
     this.expression = extractVariant(
-      new YulExpression(ast.expression, options)
+      new YulExpression(ast.expression, collected, options)
     );
-    this.cases = new YulSwitchCases(ast.cases, options);
+    this.cases = new YulSwitchCases(ast.cases, collected, options);
 
     this.updateMetadata(this.expression, this.cases);
   }
diff --git a/src/slang-nodes/YulValueCase.ts b/src/slang-nodes/YulValueCase.ts
index 7a8c43c18..4e0b13477 100644
--- a/src/slang-nodes/YulValueCase.ts
+++ b/src/slang-nodes/YulValueCase.ts
@@ -6,7 +6,7 @@ import { YulBlock } from './YulBlock.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class YulValueCase extends SlangNode {
@@ -16,11 +16,15 @@ export class YulValueCase extends SlangNode {
 
   body: YulBlock;
 
-  constructor(ast: ast.YulValueCase, options: ParserOptions<AstNode>) {
-    super(ast);
+  constructor(
+    ast: ast.YulValueCase,
+    collected: CollectedMetadata,
+    options: ParserOptions<AstNode>
+  ) {
+    super(ast, collected);
 
-    this.value = extractVariant(new YulLiteral(ast.value, options));
-    this.body = new YulBlock(ast.body, options);
+    this.value = extractVariant(new YulLiteral(ast.value, collected, options));
+    this.body = new YulBlock(ast.body, collected, options);
 
     this.updateMetadata(this.value, this.body);
   }
diff --git a/src/slang-nodes/YulVariableAssignmentStatement.ts b/src/slang-nodes/YulVariableAssignmentStatement.ts
index df314159a..eb53f6377 100644
--- a/src/slang-nodes/YulVariableAssignmentStatement.ts
+++ b/src/slang-nodes/YulVariableAssignmentStatement.ts
@@ -8,7 +8,7 @@ import { YulExpression } from './YulExpression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 const { join } = doc.builders;
@@ -24,14 +24,17 @@ export class YulVariableAssignmentStatement extends SlangNode {
 
   constructor(
     ast: ast.YulVariableAssignmentStatement,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.variables = new YulPaths(ast.variables);
-    this.assignment = extractVariant(new YulAssignmentOperator(ast.assignment));
+    this.variables = new YulPaths(ast.variables, collected);
+    this.assignment = extractVariant(
+      new YulAssignmentOperator(ast.assignment, collected)
+    );
     this.expression = extractVariant(
-      new YulExpression(ast.expression, options)
+      new YulExpression(ast.expression, collected, options)
     );
 
     this.updateMetadata(this.variables, this.assignment, this.expression);
diff --git a/src/slang-nodes/YulVariableDeclarationStatement.ts b/src/slang-nodes/YulVariableDeclarationStatement.ts
index d95766e6f..4eb1aabd3 100644
--- a/src/slang-nodes/YulVariableDeclarationStatement.ts
+++ b/src/slang-nodes/YulVariableDeclarationStatement.ts
@@ -6,7 +6,7 @@ import { YulVariableNames } from './YulVariableNames.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class YulVariableDeclarationStatement extends SlangNode {
@@ -18,13 +18,18 @@ export class YulVariableDeclarationStatement extends SlangNode {
 
   constructor(
     ast: ast.YulVariableDeclarationStatement,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.variables = new YulVariableNames(ast.variables);
+    this.variables = new YulVariableNames(ast.variables, collected);
     if (ast.value) {
-      this.value = new YulVariableDeclarationValue(ast.value, options);
+      this.value = new YulVariableDeclarationValue(
+        ast.value,
+        collected,
+        options
+      );
     }
 
     this.updateMetadata(this.value);
diff --git a/src/slang-nodes/YulVariableDeclarationValue.ts b/src/slang-nodes/YulVariableDeclarationValue.ts
index 9a249df21..8711d74af 100644
--- a/src/slang-nodes/YulVariableDeclarationValue.ts
+++ b/src/slang-nodes/YulVariableDeclarationValue.ts
@@ -6,7 +6,7 @@ import { YulExpression } from './YulExpression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
 export class YulVariableDeclarationValue extends SlangNode {
@@ -18,13 +18,16 @@ export class YulVariableDeclarationValue extends SlangNode {
 
   constructor(
     ast: ast.YulVariableDeclarationValue,
+    collected: CollectedMetadata,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, collected);
 
-    this.assignment = extractVariant(new YulAssignmentOperator(ast.assignment));
+    this.assignment = extractVariant(
+      new YulAssignmentOperator(ast.assignment, collected)
+    );
     this.expression = extractVariant(
-      new YulExpression(ast.expression, options)
+      new YulExpression(ast.expression, collected, options)
     );
 
     this.updateMetadata(this.assignment, this.expression);
diff --git a/src/slang-nodes/YulVariableNames.ts b/src/slang-nodes/YulVariableNames.ts
index 823302471..6a4ce473b 100644
--- a/src/slang-nodes/YulVariableNames.ts
+++ b/src/slang-nodes/YulVariableNames.ts
@@ -6,7 +6,7 @@ import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction } from '../types.d.ts';
+import type { CollectedMetadata, PrintFunction } from '../types.d.ts';
 
 const { line } = doc.builders;
 
@@ -15,10 +15,10 @@ export class YulVariableNames extends SlangNode {
 
   items: TerminalNode[];
 
-  constructor(ast: ast.YulVariableNames) {
-    super(ast, true);
+  constructor(ast: ast.YulVariableNames, collected: CollectedMetadata) {
+    super(ast, collected, true);
 
-    this.items = ast.items.map((item) => new TerminalNode(item));
+    this.items = ast.items.map((item) => new TerminalNode(item, collected));
   }
 
   print(path: AstPath<YulVariableNames>, print: PrintFunction): Doc {
diff --git a/src/slang-utils/extract-variant.ts b/src/slang-utils/extract-variant.ts
index 4ded9b6e4..5abce7b1e 100644
--- a/src/slang-utils/extract-variant.ts
+++ b/src/slang-utils/extract-variant.ts
@@ -1,4 +1,4 @@
-import type { StrictPolymorphicNode } from '../slang-nodes/types.ts';
+import type { StrictPolymorphicNode } from '../slang-nodes/types.d.ts';
 
 export function extractVariant<T extends StrictPolymorphicNode>({
   variant,
diff --git a/src/slangSolidityParser.ts b/src/slangSolidityParser.ts
index 408e7bdfd..e6495e2ce 100644
--- a/src/slangSolidityParser.ts
+++ b/src/slangSolidityParser.ts
@@ -1,11 +1,10 @@
 // https://prettier.io/docs/en/plugins.html#parsers
 import { SourceUnit as SlangSourceUnit } from '@nomicfoundation/slang/ast';
-import { clearComments, clearOffsets } from './slang-nodes/SlangNode.js';
 import { createParser } from './slang-utils/create-parser.js';
 import { SourceUnit } from './slang-nodes/SourceUnit.js';
 
 import type { ParserOptions } from 'prettier';
-import type { AstNode } from './slang-nodes/types.d.ts';
+import type { AstNode, Comment } from './slang-nodes/types.d.ts';
 
 export default function parse(
   text: string,
@@ -15,14 +14,15 @@ export default function parse(
 
   // We update the compiler version by the inferred one.
   options.compiler = parser.languageVersion;
+  const comments: Comment[] = [];
   const parsed = new SourceUnit(
     new SlangSourceUnit(parseOutput.tree.asNonterminalNode()),
+    { offsets: new Map<number, number>(), comments },
     options
   );
 
   // Because of comments being extracted like a Russian doll, the order needs
   // to be fixed at the end.
-  parsed.comments = clearComments().sort((a, b) => a.loc.start - b.loc.start);
-  clearOffsets();
+  parsed.comments = comments.sort((a, b) => a.loc.start - b.loc.start);
   return parsed;
 }
diff --git a/src/types.d.ts b/src/types.d.ts
index 5193b7b15..e7fb3db40 100644
--- a/src/types.d.ts
+++ b/src/types.d.ts
@@ -1,6 +1,6 @@
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { AstNode } from './slang-nodes/types.d.ts';
+import type { AstNode, Comment } from './slang-nodes/types.d.ts';
 
 // Adding our own options to prettier's `ParserOptions` interface.
 declare module 'prettier' {
@@ -9,6 +9,11 @@ declare module 'prettier' {
   }
 }
 
+interface CollectedMetadata {
+  offsets: Map<number, number>;
+  comments: Comment[];
+}
+
 interface Location {
   start: number;
   end: number;