Reviewing metadata (#1196)

* if metadata is a fixed array, then it can more easily be destructured into class attributes saving file size

* avoid using the temporary variable `metadata` since it can be destructured directly

* if `updateMetadata` modifies directly `comments` and `loc`, there's no need to destructure twice

* 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

* by using rest parameters on `updateMetadata` we don't have to build arrays manually.

* reordering the imports

* avoiding an extra iteration over all children

* using a reverse iterator instead of reversing the array

Author: Janther

src/slang-nodes/AbicoderPragma.ts

@@ -1,27 +1,20 @@
 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) {
-    const metadata = getNodeMetadata(ast);
+    super(ast);
 
     this.version = new Identifier(ast.version);
-
-    this.comments = metadata.comments;
-    this.loc = metadata.loc;
   }
 
   print(path: AstPath<AbicoderPragma>, print: PrintFunction): Doc {

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>) {
-    let metadata = getNodeMetadata(ast);
+    super(ast);
 
     this.leftOperand = new Expression(ast.leftOperand, options);
     this.operator = ast.operator.unparse();
     this.rightOperand = new Expression(ast.rightOperand, options);
 
-    metadata = updateMetadata(metadata, [this.leftOperand, this.rightOperand]);
-
-    this.comments = metadata.comments;
-    this.loc = metadata.loc;
+    this.updateMetadata(this.leftOperand, this.rightOperand);
 
     this.leftOperand = tryToHug(this.leftOperand);
     this.rightOperand = tryToHug(this.rightOperand);

src/slang-nodes/AddressType.ts

@@ -1,27 +1,19 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
-import { getNodeMetadata } from '../slang-utils/metadata.js';
 import { joinExisting } from '../slang-utils/join-existing.js';
+import { SlangNode } from './SlangNode.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) {
-    const metadata = getNodeMetadata(ast);
+    super(ast);
 
     this.payableKeyword = ast.payableKeyword?.unparse();
-
-    this.comments = metadata.comments;
-    this.loc = metadata.loc;
   }
 
   print(): Doc {

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>) {
-    let metadata = getNodeMetadata(ast);
+    super(ast);
 
     this.leftOperand = new Expression(ast.leftOperand, options);
     this.operator = ast.operator.unparse();
     this.rightOperand = new Expression(ast.rightOperand, options);
 
-    metadata = updateMetadata(metadata, [this.leftOperand, this.rightOperand]);
-
-    this.comments = metadata.comments;
-    this.loc = metadata.loc;
+    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>) {
-    let metadata = getNodeMetadata(ast);
+    super(ast);
 
     switch (ast.variant.cst.kind) {
       case NonterminalKind.PositionalArgumentsDeclaration:
@@ -37,10 +33,7 @@ export class ArgumentsDeclaration implements SlangNode {
         throw new Error(`Unexpected variant: ${ast.variant.cst.kind}`);
     }
 
-    metadata = updateMetadata(metadata, [this.variant]);
-
-    this.comments = metadata.comments;
-    this.loc = metadata.loc;
+    this.updateMetadata(this.variant);
   }
 
   print(path: AstPath<ArgumentsDeclaration>, print: PrintFunction): Doc {

src/slang-nodes/ArrayExpression.ts

@@ -1,33 +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>) {
-    let metadata = getNodeMetadata(ast);
+    super(ast);
 
     this.items = new ArrayValues(ast.items, options);
 
-    metadata = updateMetadata(metadata, [this.items]);
-
-    this.comments = metadata.comments;
-    this.loc = metadata.loc;
+    this.updateMetadata(this.items);
   }
 
   print(path: AstPath<ArrayExpression>, print: PrintFunction): Doc {

src/slang-nodes/ArrayTypeName.ts

@@ -1,36 +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>) {
-    let metadata = getNodeMetadata(ast);
+    super(ast);
 
     this.operand = new TypeName(ast.operand, options);
     if (ast.index) {
       this.index = new Expression(ast.index, options);
     }
 
-    metadata = updateMetadata(metadata, [this.operand, this.index]);
-
-    this.comments = metadata.comments;
-    this.loc = metadata.loc;
+    this.updateMetadata(this.operand, this.index);
   }
 
   print(path: AstPath<ArrayTypeName>, print: PrintFunction): Doc {

src/slang-nodes/ArrayValues.ts

@@ -1,31 +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>) {
-    let metadata = getNodeMetadata(ast, true);
+    super(ast, true);
 
     this.items = ast.items.map((item) => new Expression(item, options));
 
-    metadata = updateMetadata(metadata, [this.items]);
-
-    this.comments = metadata.comments;
-    this.loc = metadata.loc;
+    this.updateMetadata(this.items);
   }
 
   print(path: AstPath<ArrayValues>, print: PrintFunction): Doc {

src/slang-nodes/AssemblyFlags.ts

@@ -1,31 +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>) {
-    let metadata = getNodeMetadata(ast, true);
+    super(ast, true);
 
     this.items = ast.items.map((item) => new StringLiteral(item, options));
 
-    metadata = updateMetadata(metadata, [this.items]);
-
-    this.comments = metadata.comments;
-    this.loc = metadata.loc;
+    this.updateMetadata(this.items);
   }
 
   print(path: AstPath<AssemblyFlags>, print: PrintFunction): Doc {

src/slang-nodes/AssemblyFlagsDeclaration.ts

@@ -1,33 +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>
   ) {
-    let metadata = getNodeMetadata(ast);
+    super(ast);
 
     this.flags = new AssemblyFlags(ast.flags, options);
 
-    metadata = updateMetadata(metadata, [this.flags]);
-
-    this.comments = metadata.comments;
-    this.loc = metadata.loc;
+    this.updateMetadata(this.flags);
   }
 
   print(path: AstPath<AssemblyFlagsDeclaration>, print: PrintFunction): Doc {