dropping all the unnecessary storing of separators

src/slang-nodes/ArrayValues.ts

@@ -17,13 +17,10 @@ export class ArrayValues implements SlangNode {
 
   items: Expression[];
 
-  separators: string[];
-
   constructor(ast: ast.ArrayValues, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new Expression(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/AssemblyFlags.ts

@@ -17,13 +17,10 @@ export class AssemblyFlags implements SlangNode {
 
   items: StringLiteral[];
 
-  separators: string[];
-
   constructor(ast: ast.AssemblyFlags, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new StringLiteral(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/CallOptions.ts

@@ -20,13 +20,10 @@ export class CallOptions implements SlangNode {
 
   items: NamedArgument[];
 
-  separators: string[];
-
   constructor(ast: ast.CallOptions, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new NamedArgument(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/EnumMembers.ts

@@ -19,13 +19,10 @@ export class EnumMembers implements SlangNode {
 
   items: Identifier[];
 
-  separators: string[];
-
   constructor(ast: ast.EnumMembers) {
     const metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new Identifier(item));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     this.comments = metadata.comments;
     this.loc = metadata.loc;

src/slang-nodes/ErrorParameters.ts

@@ -17,13 +17,10 @@ export class ErrorParameters implements SlangNode {
 
   items: ErrorParameter[];
 
-  separators: string[];
-
   constructor(ast: ast.ErrorParameters, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new ErrorParameter(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/EventParameters.ts

@@ -17,13 +17,10 @@ export class EventParameters implements SlangNode {
 
   items: EventParameter[];
 
-  separators: string[];
-
   constructor(ast: ast.EventParameters, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new EventParameter(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/IdentifierPath.ts

@@ -1,11 +1,14 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
+import { doc } from 'prettier';
 import { getNodeMetadata } from '../slang-utils/metadata.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';
 
+const { join } = doc.builders;
+
 export class IdentifierPath implements SlangNode {
   readonly kind = NonterminalKind.IdentifierPath;
 
@@ -15,23 +18,16 @@ export class IdentifierPath implements SlangNode {
 
   items: Identifier[];
 
-  separators: string[];
-
   constructor(ast: ast.IdentifierPath) {
     const metadata = getNodeMetadata(ast);
 
     this.items = ast.items.map((item) => new Identifier(item));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     this.comments = metadata.comments;
     this.loc = metadata.loc;
   }
 
   print(path: AstPath<IdentifierPath>, print: PrintFunction): Doc {
-    return path
-      .map(print, 'items')
-      .map((item, index) =>
-        index === 0 ? item : [this.separators[index - 1], item]
-      );
+    return join('.', path.map(print, 'items'));
   }
 }

src/slang-nodes/ImportDeconstructionSymbols.ts

@@ -21,13 +21,10 @@ export class ImportDeconstructionSymbols implements SlangNode {
 
   items: ImportDeconstructionSymbol[];
 
-  separators: string[];
-
   constructor(ast: ast.ImportDeconstructionSymbols) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new ImportDeconstructionSymbol(item));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/InheritanceTypes.ts

@@ -20,13 +20,10 @@ export class InheritanceTypes implements SlangNode {
 
   items: InheritanceType[];
 
-  separators: string[];
-
   constructor(ast: ast.InheritanceTypes, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new InheritanceType(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/ModifierDefinition.ts

@@ -68,8 +68,7 @@ export class ModifierDefinition implements SlangNode {
               kind: NonterminalKind.Parameters,
               loc: { ...parametersLoc },
               comments: [],
-              items: [],
-              separators: []
+              items: []
             }
           )
         }

src/slang-nodes/NamedArguments.ts

@@ -20,13 +20,10 @@ export class NamedArguments implements SlangNode {
 
   items: NamedArgument[];
 
-  separators: string[];
-
   constructor(ast: ast.NamedArguments, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new NamedArgument(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/OverridePaths.ts

@@ -16,13 +16,10 @@ export class OverridePaths implements SlangNode {
 
   items: IdentifierPath[];
 
-  separators: string[];
-
   constructor(ast: ast.OverridePaths) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new IdentifierPath(item));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/Parameters.ts

@@ -19,13 +19,10 @@ export class Parameters implements SlangNode {
 
   items: Parameter[];
 
-  separators: string[];
-
   constructor(ast: ast.Parameters, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new Parameter(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/PositionalArguments.ts

@@ -19,13 +19,10 @@ export class PositionalArguments implements SlangNode {
 
   items: Expression[];
 
-  separators: string[];
-
   constructor(ast: ast.PositionalArguments, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new Expression(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/SimpleVersionLiteral.ts

@@ -14,21 +14,16 @@ export class SimpleVersionLiteral implements SlangNode {
 
   items: string[];
 
-  separators: string[];
-
   constructor(ast: ast.SimpleVersionLiteral) {
     const metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => item.unparse());
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     this.comments = metadata.comments;
     this.loc = metadata.loc;
   }
 
   print(): Doc {
-    return this.items.map((item, index) =>
-      index === 0 ? item : [this.separators[index - 1], item]
-    );
+    return this.items.join('.');
   }
 }

src/slang-nodes/TupleDeconstructionElements.ts

@@ -17,8 +17,6 @@ export class TupleDeconstructionElements implements SlangNode {
 
   items: TupleDeconstructionElement[];
 
-  separators: string[];
-
   constructor(
     ast: ast.TupleDeconstructionElements,
     options: ParserOptions<AstNode>
@@ -28,7 +26,6 @@ export class TupleDeconstructionElements implements SlangNode {
     this.items = ast.items.map(
       (item) => new TupleDeconstructionElement(item, options)
     );
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/TupleValues.ts

@@ -18,13 +18,10 @@ export class TupleValues implements SlangNode {
 
   items: TupleValue[];
 
-  separators: string[];
-
   constructor(ast: ast.TupleValues, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new TupleValue(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/UsingDeconstructionSymbols.ts

@@ -20,13 +20,10 @@ export class UsingDeconstructionSymbols implements SlangNode {
 
   items: UsingDeconstructionSymbol[];
 
-  separators: string[];
-
   constructor(ast: ast.UsingDeconstructionSymbols) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new UsingDeconstructionSymbol(item));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/VersionExpressionSets.ts

@@ -1,11 +1,14 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
+import { doc } from 'prettier';
 import { getNodeMetadata, updateMetadata } from '../slang-utils/metadata.js';
 import { VersionExpressionSet } from './VersionExpressionSet.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
 import type { PrintFunction, SlangNode } from '../types.d.ts';
 
+const { join } = doc.builders;
+
 export class VersionExpressionSets implements SlangNode {
   readonly kind = NonterminalKind.VersionExpressionSets;
 
@@ -15,13 +18,10 @@ export class VersionExpressionSets implements SlangNode {
 
   items: VersionExpressionSet[];
 
-  separators: string[];
-
   constructor(ast: ast.VersionExpressionSets) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new VersionExpressionSet(item));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 
@@ -30,10 +30,6 @@ export class VersionExpressionSets implements SlangNode {
   }
 
   print(path: AstPath<VersionExpressionSets>, print: PrintFunction): Doc {
-    return path
-      .map(print, 'items')
-      .map((item, index) =>
-        index === 0 ? item : [` ${this.separators[index - 1]} `, item]
-      );
+    return join(' || ', path.map(print, 'items'));
   }
 }

src/slang-nodes/YulArguments.ts

@@ -17,13 +17,10 @@ export class YulArguments implements SlangNode {
 
   items: YulExpression[];
 
-  separators: string[];
-
   constructor(ast: ast.YulArguments, options: ParserOptions<AstNode>) {
     let metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new YulExpression(item, options));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     metadata = updateMetadata(metadata, [this.items]);
 

src/slang-nodes/YulParameters.ts

@@ -16,13 +16,10 @@ export class YulParameters implements SlangNode {
 
   items: YulIdentifier[];
 
-  separators: string[];
-
   constructor(ast: ast.YulParameters) {
     const metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new YulIdentifier(item));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     this.comments = metadata.comments;
     this.loc = metadata.loc;

src/slang-nodes/YulPath.ts

@@ -1,11 +1,14 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
+import { doc } from 'prettier';
 import { getNodeMetadata } from '../slang-utils/metadata.js';
 import { YulIdentifier } from './YulIdentifier.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc } from 'prettier';
 import type { PrintFunction, SlangNode } from '../types.d.ts';
 
+const { join } = doc.builders;
+
 export class YulPath implements SlangNode {
   readonly kind = NonterminalKind.YulPath;
 
@@ -15,23 +18,16 @@ export class YulPath implements SlangNode {
 
   items: YulIdentifier[];
 
-  separators: string[];
-
   constructor(ast: ast.YulPath) {
     const metadata = getNodeMetadata(ast, true);
 
     this.items = ast.items.map((item) => new YulIdentifier(item));
-    this.separators = ast.separators.map((separator) => separator.unparse());
 
     this.comments = metadata.comments;
     this.loc = metadata.loc;
   }
 
   print(path: AstPath<YulPath>, print: PrintFunction): Doc {
-    return path
-      .map(print, 'items')
-      .map((item, index) =>
-        index === 0 ? item : [this.separators[index - 1], item]
-      );
+    return join('.', path.map(print, 'items'));
   }
 }