Multi thread safe b (#1393)

* prettier could be run in parallel, this should add a layer of safety for those cases.

* fixing extensions

* using a separate object from Prettier's options

* cleaning up type

Author: Janther

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 {

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();
   }

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);

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();
   }

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);

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);
   }

src/slang-nodes/ArrayExpression.ts

@@ -4,18 +4,22 @@ 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 {
   readonly kind = NonterminalKind.ArrayExpression;
 
   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 {

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);

src/slang-nodes/ArrayValues.ts

@@ -6,19 +6,23 @@ 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 {
   readonly kind = NonterminalKind.ArrayValues;
 
   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))
     );
   }
 

src/slang-nodes/AssemblyFlags.ts

@@ -5,18 +5,24 @@ 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 {
   readonly kind = NonterminalKind.AssemblyFlags;
 
   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 {