since all calls to getMetadata had been standardised, it's much cleaner to have it as a constructor of a parent class and updateMetadata being a class function

Author: Janther

src/slang-nodes/AbicoderPragma.ts

@@ -1,22 +1,18 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { getNodeMetadata } from '../slang-utils/metadata.js';
+import { SlangNode } from './SlangNode.js';
 import { Identifier } from './Identifier.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
-import type { PrintFunction, SlangNode } from '../types.d.ts';
+import type { PrintFunction } from '../types.d.ts';
 
-export class AbicoderPragma implements SlangNode {
+export class AbicoderPragma extends SlangNode {
   readonly kind = NonterminalKind.AbicoderPragma;
 
-  comments;
-
-  loc;
-
   version: Identifier;
 
   constructor(ast: ast.AbicoderPragma) {
-    [this.loc, this.comments] = getNodeMetadata(ast);
+    super(ast);
 
     this.version = new Identifier(ast.version);
   }

src/slang-nodes/AdditiveExpression.ts

@@ -2,13 +2,13 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printBinaryOperation } from '../slang-printers/print-binary-operation.js';
 import { createHugFunction } from '../slang-utils/create-hug-function.js';
 import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js';
-import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
-import type { PrintFunction, SlangNode } from '../types.d.ts';
+import type { PrintFunction } from '../types.d.ts';
 
 const tryToHug = createHugFunction(['%']);
 
@@ -25,30 +25,23 @@ const printAdditiveExpression = printBinaryOperation(
   ])
 );
 
-export class AdditiveExpression implements SlangNode {
+export class AdditiveExpression extends SlangNode {
   readonly kind = NonterminalKind.AdditiveExpression;
 
-  comments;
-
-  loc;
-
   leftOperand: Expression;
 
   operator: string;
 
   rightOperand: Expression;
 
   constructor(ast: ast.AdditiveExpression, options: ParserOptions<AstNode>) {
-    [this.loc, this.comments] = getNodeMetadata(ast);
+    super(ast);
 
     this.leftOperand = new Expression(ast.leftOperand, options);
     this.operator = ast.operator.unparse();
     this.rightOperand = new Expression(ast.rightOperand, options);
 
-    updateMetadata(this.loc, this.comments, [
-      this.leftOperand,
-      this.rightOperand
-    ]);
+    this.updateMetadata([this.leftOperand, this.rightOperand]);
 
     this.leftOperand = tryToHug(this.leftOperand);
     this.rightOperand = tryToHug(this.rightOperand);

src/slang-nodes/AddressType.ts

@@ -1,22 +1,17 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { getNodeMetadata } from '../slang-utils/metadata.js';
+import { SlangNode } from './SlangNode.js';
 import { joinExisting } from '../slang-utils/join-existing.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { Doc } from 'prettier';
-import type { SlangNode } from '../types.d.ts';
 
-export class AddressType implements SlangNode {
+export class AddressType extends SlangNode {
   readonly kind = NonterminalKind.AddressType;
 
-  comments;
-
-  loc;
-
   payableKeyword?: string;
 
   constructor(ast: ast.AddressType) {
-    [this.loc, this.comments] = getNodeMetadata(ast);
+    super(ast);
 
     this.payableKeyword = ast.payableKeyword?.unparse();
   }

src/slang-nodes/AndExpression.ts

@@ -1,37 +1,30 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printLogicalOperation } from '../slang-printers/print-logical-operation.js';
-import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
-import type { PrintFunction, SlangNode } from '../types.d.ts';
+import type { PrintFunction } from '../types.d.ts';
 
-export class AndExpression implements SlangNode {
+export class AndExpression extends SlangNode {
   readonly kind = NonterminalKind.AndExpression;
 
-  comments;
-
-  loc;
-
   leftOperand: Expression;
 
   operator: string;
 
   rightOperand: Expression;
 
   constructor(ast: ast.AndExpression, options: ParserOptions<AstNode>) {
-    [this.loc, this.comments] = getNodeMetadata(ast);
+    super(ast);
 
     this.leftOperand = new Expression(ast.leftOperand, options);
     this.operator = ast.operator.unparse();
     this.rightOperand = new Expression(ast.rightOperand, options);
 
-    updateMetadata(this.loc, this.comments, [
-      this.leftOperand,
-      this.rightOperand
-    ]);
+    this.updateMetadata([this.leftOperand, this.rightOperand]);
   }
 
   print(

src/slang-nodes/ArgumentsDeclaration.ts

@@ -1,24 +1,20 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { SlangNode } from './SlangNode.js';
 import { PositionalArgumentsDeclaration } from './PositionalArgumentsDeclaration.js';
 import { NamedArgumentsDeclaration } from './NamedArgumentsDeclaration.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
-import type { PrintFunction, SlangNode } from '../types.d.ts';
+import type { PrintFunction } from '../types.d.ts';
 
-export class ArgumentsDeclaration implements SlangNode {
+export class ArgumentsDeclaration extends SlangNode {
   readonly kind = NonterminalKind.ArgumentsDeclaration;
 
-  comments;
-
-  loc;
-
   variant: PositionalArgumentsDeclaration | NamedArgumentsDeclaration;
 
   constructor(ast: ast.ArgumentsDeclaration, options: ParserOptions<AstNode>) {
-    [this.loc, this.comments] = getNodeMetadata(ast);
+    super(ast);
 
     switch (ast.variant.cst.kind) {
       case NonterminalKind.PositionalArgumentsDeclaration:
@@ -37,7 +33,7 @@ export class ArgumentsDeclaration implements SlangNode {
         throw new Error(`Unexpected variant: ${ast.variant.cst.kind}`);
     }
 
-    updateMetadata(this.loc, this.comments, [this.variant]);
+    this.updateMetadata([this.variant]);
   }
 
   print(path: AstPath<ArgumentsDeclaration>, print: PrintFunction): Doc {

src/slang-nodes/ArrayExpression.ts

@@ -1,30 +1,26 @@
 import { doc } from 'prettier';
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { SlangNode } from './SlangNode.js';
 import { ArrayValues } from './ArrayValues.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
-import type { PrintFunction, SlangNode } from '../types.d.ts';
+import type { PrintFunction } from '../types.d.ts';
 
 const { group } = doc.builders;
 
-export class ArrayExpression implements SlangNode {
+export class ArrayExpression extends SlangNode {
   readonly kind = NonterminalKind.ArrayExpression;
 
-  comments;
-
-  loc;
-
   items: ArrayValues;
 
   constructor(ast: ast.ArrayExpression, options: ParserOptions<AstNode>) {
-    [this.loc, this.comments] = getNodeMetadata(ast);
+    super(ast);
 
     this.items = new ArrayValues(ast.items, options);
 
-    updateMetadata(this.loc, this.comments, [this.items]);
+    this.updateMetadata([this.items]);
   }
 
   print(path: AstPath<ArrayExpression>, print: PrintFunction): Doc {

src/slang-nodes/ArrayTypeName.ts

@@ -1,33 +1,29 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { SlangNode } from './SlangNode.js';
 import { TypeName } from './TypeName.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
-import type { PrintFunction, SlangNode } from '../types.d.ts';
+import type { PrintFunction } from '../types.d.ts';
 
-export class ArrayTypeName implements SlangNode {
+export class ArrayTypeName extends SlangNode {
   readonly kind = NonterminalKind.ArrayTypeName;
 
-  comments;
-
-  loc;
-
   operand: TypeName;
 
   index?: Expression;
 
   constructor(ast: ast.ArrayTypeName, options: ParserOptions<AstNode>) {
-    [this.loc, this.comments] = getNodeMetadata(ast);
+    super(ast);
 
     this.operand = new TypeName(ast.operand, options);
     if (ast.index) {
       this.index = new Expression(ast.index, options);
     }
 
-    updateMetadata(this.loc, this.comments, [this.operand, this.index]);
+    this.updateMetadata([this.operand, this.index]);
   }
 
   print(path: AstPath<ArrayTypeName>, print: PrintFunction): Doc {

src/slang-nodes/ArrayValues.ts

@@ -1,28 +1,24 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printSeparatedList } from '../slang-printers/print-separated-list.js';
-import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
-import type { PrintFunction, SlangNode } from '../types.d.ts';
+import type { PrintFunction } from '../types.d.ts';
 
-export class ArrayValues implements SlangNode {
+export class ArrayValues extends SlangNode {
   readonly kind = NonterminalKind.ArrayValues;
 
-  comments;
-
-  loc;
-
   items: Expression[];
 
   constructor(ast: ast.ArrayValues, options: ParserOptions<AstNode>) {
-    [this.loc, this.comments] = getNodeMetadata(ast, true);
+    super(ast, true);
 
     this.items = ast.items.map((item) => new Expression(item, options));
 
-    updateMetadata(this.loc, this.comments, [this.items]);
+    this.updateMetadata([this.items]);
   }
 
   print(path: AstPath<ArrayValues>, print: PrintFunction): Doc {

src/slang-nodes/AssemblyFlags.ts

@@ -1,28 +1,24 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printSeparatedList } from '../slang-printers/print-separated-list.js';
-import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { SlangNode } from './SlangNode.js';
 import { StringLiteral } from './StringLiteral.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
-import type { PrintFunction, SlangNode } from '../types.d.ts';
+import type { PrintFunction } from '../types.d.ts';
 
-export class AssemblyFlags implements SlangNode {
+export class AssemblyFlags extends SlangNode {
   readonly kind = NonterminalKind.AssemblyFlags;
 
-  comments;
-
-  loc;
-
   items: StringLiteral[];
 
   constructor(ast: ast.AssemblyFlags, options: ParserOptions<AstNode>) {
-    [this.loc, this.comments] = getNodeMetadata(ast, true);
+    super(ast, true);
 
     this.items = ast.items.map((item) => new StringLiteral(item, options));
 
-    updateMetadata(this.loc, this.comments, [this.items]);
+    this.updateMetadata([this.items]);
   }
 
   print(path: AstPath<AssemblyFlags>, print: PrintFunction): Doc {

src/slang-nodes/AssemblyFlagsDeclaration.ts

@@ -1,30 +1,26 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
+import { SlangNode } from './SlangNode.js';
 import { AssemblyFlags } from './AssemblyFlags.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from './types.d.ts';
-import type { PrintFunction, SlangNode } from '../types.d.ts';
+import type { PrintFunction } from '../types.d.ts';
 
-export class AssemblyFlagsDeclaration implements SlangNode {
+export class AssemblyFlagsDeclaration extends SlangNode {
   readonly kind = NonterminalKind.AssemblyFlagsDeclaration;
 
-  comments;
-
-  loc;
-
   flags: AssemblyFlags;
 
   constructor(
     ast: ast.AssemblyFlagsDeclaration,
     options: ParserOptions<AstNode>
   ) {
-    [this.loc, this.comments] = getNodeMetadata(ast);
+    super(ast);
 
     this.flags = new AssemblyFlags(ast.flags, options);
 
-    updateMetadata(this.loc, this.comments, [this.flags]);
+    this.updateMetadata([this.flags]);
   }
 
   print(path: AstPath<AssemblyFlagsDeclaration>, print: PrintFunction): Doc {