Safety for system running parallel threads of Prettier

src/slang-nodes/AbicoderPragma.ts

@@ -3,18 +3,19 @@ import { SlangNode } from './SlangNode.js';
 import { AbicoderVersion } from './AbicoderVersion.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { AstPath, Doc } from 'prettier';
+import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { PrintFunction } from '../types.d.ts';
+import type { AstNode } 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, options: ParserOptions<AstNode>) {
+    super(ast, options);
 
-    this.version = new AbicoderVersion(ast.version);
+    this.version = new AbicoderVersion(ast.version, options);
   }
 
   print(path: AstPath<AbicoderPragma>, print: PrintFunction): Doc {

src/slang-nodes/AbicoderVersion.ts

@@ -2,15 +2,16 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { Doc } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
+import type { AstNode } 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, options: ParserOptions<AstNode>) {
+    super(ast, options);
 
     this.variant = ast.variant.unparse();
   }

src/slang-nodes/AdditiveExpression.ts

@@ -36,7 +36,7 @@ export class AdditiveExpression extends SlangNode {
   rightOperand: Expression['variant'];
 
   constructor(ast: ast.AdditiveExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();

src/slang-nodes/AddressType.ts

@@ -2,15 +2,16 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { Doc } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
+import type { AstNode } 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, options: ParserOptions<AstNode>) {
+    super(ast, options);
 
     this.payableKeyword = ast.payableKeyword?.unparse();
   }

src/slang-nodes/AndExpression.ts

@@ -19,7 +19,7 @@ export class AndExpression extends SlangNode {
   rightOperand: Expression['variant'];
 
   constructor(ast: ast.AndExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();

src/slang-nodes/ArgumentsDeclaration.ts

@@ -27,7 +27,7 @@ export class ArgumentsDeclaration extends SlangNode {
   variant: PositionalArgumentsDeclaration | NamedArgumentsDeclaration;
 
   constructor(ast: ast.ArgumentsDeclaration, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.variant = createNonterminalVariant(ast.variant, options);
 

src/slang-nodes/ArrayExpression.ts

@@ -13,7 +13,7 @@ export class ArrayExpression extends SlangNode {
   items: ArrayValues;
 
   constructor(ast: ast.ArrayExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.items = new ArrayValues(ast.items, options);
   }

src/slang-nodes/ArrayTypeName.ts

@@ -17,7 +17,7 @@ export class ArrayTypeName extends SlangNode {
   index?: Expression['variant'];
 
   constructor(ast: ast.ArrayTypeName, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.operand = extractVariant(new TypeName(ast.operand, options));
     if (ast.index) {

src/slang-nodes/ArrayValues.ts

@@ -15,7 +15,7 @@ export class ArrayValues extends SlangNode {
   items: Expression['variant'][];
 
   constructor(ast: ast.ArrayValues, options: ParserOptions<AstNode>) {
-    super(ast, true);
+    super(ast, options, true);
 
     this.items = ast.items.map((item) =>
       extractVariant(new Expression(item, options))

src/slang-nodes/AssemblyFlags.ts

@@ -14,7 +14,7 @@ export class AssemblyFlags extends SlangNode {
   items: StringLiteral[];
 
   constructor(ast: ast.AssemblyFlags, options: ParserOptions<AstNode>) {
-    super(ast, true);
+    super(ast, options, true);
 
     this.items = ast.items.map((item) => new StringLiteral(item, options));
   }

src/slang-nodes/AssemblyFlagsDeclaration.ts

@@ -16,7 +16,7 @@ export class AssemblyFlagsDeclaration extends SlangNode {
     ast: ast.AssemblyFlagsDeclaration,
     options: ParserOptions<AstNode>
   ) {
-    super(ast);
+    super(ast, options);
 
     this.flags = new AssemblyFlags(ast.flags, options);
 

src/slang-nodes/AssemblyStatement.ts

@@ -20,7 +20,7 @@ export class AssemblyStatement extends SlangNode {
   body: YulBlock;
 
   constructor(ast: ast.AssemblyStatement, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     if (ast.label) {
       this.label = new StringLiteral(ast.label, options);

src/slang-nodes/AssignmentExpression.ts

@@ -21,7 +21,7 @@ export class AssignmentExpression extends SlangNode {
   rightOperand: Expression['variant'];
 
   constructor(ast: ast.AssignmentExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();

src/slang-nodes/BitwiseAndExpression.ts

@@ -32,7 +32,7 @@ export class BitwiseAndExpression extends SlangNode {
   rightOperand: Expression['variant'];
 
   constructor(ast: ast.BitwiseAndExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();

src/slang-nodes/BitwiseOrExpression.ts

@@ -42,7 +42,7 @@ export class BitwiseOrExpression extends SlangNode {
   rightOperand: Expression['variant'];
 
   constructor(ast: ast.BitwiseOrExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();

src/slang-nodes/BitwiseXorExpression.ts

@@ -32,7 +32,7 @@ export class BitwiseXorExpression extends SlangNode {
   rightOperand: Expression['variant'];
 
   constructor(ast: ast.BitwiseXorExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();

src/slang-nodes/Block.ts

@@ -13,7 +13,7 @@ export class Block extends SlangNode {
   statements: Statements;
 
   constructor(ast: ast.Block, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.statements = new Statements(ast.statements, options);
 

src/slang-nodes/BreakStatement.ts

@@ -2,13 +2,14 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { Doc } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
+import type { AstNode } from './types.d.ts';
 
 export class BreakStatement extends SlangNode {
   readonly kind = NonterminalKind.BreakStatement;
 
-  constructor(ast: ast.BreakStatement) {
-    super(ast);
+  constructor(ast: ast.BreakStatement, options: ParserOptions<AstNode>) {
+    super(ast, options);
   }
 
   print(): Doc {

src/slang-nodes/CallOptions.ts

@@ -17,7 +17,7 @@ export class CallOptions extends SlangNode {
   items: NamedArgument[];
 
   constructor(ast: ast.CallOptions, options: ParserOptions<AstNode>) {
-    super(ast, true);
+    super(ast, options, true);
 
     this.items = ast.items.map((item) => new NamedArgument(item, options));
   }

src/slang-nodes/CallOptionsExpression.ts

@@ -17,7 +17,7 @@ export class CallOptionsExpression extends SlangNode {
   options: CallOptions;
 
   constructor(ast: ast.CallOptionsExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.operand = extractVariant(new Expression(ast.operand, options));
     this.options = new CallOptions(ast.options, options);

src/slang-nodes/CatchClause.ts

@@ -16,7 +16,7 @@ export class CatchClause extends SlangNode {
   body: Block;
 
   constructor(ast: ast.CatchClause, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     if (ast.error) {
       this.error = new CatchClauseError(ast.error, options);

src/slang-nodes/CatchClauseError.ts

@@ -19,10 +19,10 @@ export class CatchClauseError extends SlangNode {
   parameters: ParametersDeclaration;
 
   constructor(ast: ast.CatchClauseError, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     if (ast.name) {
-      this.name = new TerminalNode(ast.name);
+      this.name = new TerminalNode(ast.name, options);
     }
     this.parameters = new ParametersDeclaration(ast.parameters, options);
 

src/slang-nodes/CatchClauses.ts

@@ -16,7 +16,7 @@ export class CatchClauses extends SlangNode {
   items: CatchClause[];
 
   constructor(ast: ast.CatchClauses, options: ParserOptions<AstNode>) {
-    super(ast, true);
+    super(ast, options, true);
 
     this.items = ast.items.map((item) => new CatchClause(item, options));
 

src/slang-nodes/ConditionalExpression.ts

@@ -120,7 +120,7 @@ export class ConditionalExpression extends SlangNode {
   falseExpression: Expression['variant'];
 
   constructor(ast: ast.ConditionalExpression, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.operand = extractVariant(new Expression(ast.operand, options));
     this.trueExpression = extractVariant(

src/slang-nodes/ConstantDefinition.ts

@@ -20,10 +20,10 @@ export class ConstantDefinition extends SlangNode {
   value: Expression['variant'];
 
   constructor(ast: ast.ConstantDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.typeName = extractVariant(new TypeName(ast.typeName, options));
-    this.name = new TerminalNode(ast.name);
+    this.name = new TerminalNode(ast.name, options);
     this.value = extractVariant(new Expression(ast.value, options));
 
     this.updateMetadata(this.typeName, this.value);

src/slang-nodes/ConstructorAttribute.ts

@@ -16,11 +16,11 @@ export class ConstructorAttribute extends SlangNode {
   variant: ModifierInvocation | TerminalNode;
 
   constructor(ast: ast.ConstructorAttribute, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     const variant = ast.variant;
     if (variant instanceof SlangTerminalNode) {
-      this.variant = new TerminalNode(variant);
+      this.variant = new TerminalNode(variant, options);
       return;
     }
     this.variant = new ModifierInvocation(variant, options);

src/slang-nodes/ConstructorAttributes.ts

@@ -18,7 +18,7 @@ export class ConstructorAttributes extends SlangNode {
   items: ConstructorAttribute['variant'][];
 
   constructor(ast: ast.ConstructorAttributes, options: ParserOptions<AstNode>) {
-    super(ast, true);
+    super(ast, options, true);
 
     this.items = ast.items.map((item) =>
       extractVariant(new ConstructorAttribute(item, options))

src/slang-nodes/ConstructorDefinition.ts

@@ -20,7 +20,7 @@ export class ConstructorDefinition extends SlangNode {
   body: Block;
 
   constructor(ast: ast.ConstructorDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.parameters = new ParametersDeclaration(ast.parameters, options);
     this.attributes = new ConstructorAttributes(ast.attributes, options);

src/slang-nodes/ContinueStatement.ts

@@ -2,13 +2,14 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { SlangNode } from './SlangNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
-import type { Doc } from 'prettier';
+import type { Doc, ParserOptions } from 'prettier';
+import type { AstNode } from './types.d.ts';
 
 export class ContinueStatement extends SlangNode {
   readonly kind = NonterminalKind.ContinueStatement;
 
-  constructor(ast: ast.ContinueStatement) {
-    super(ast);
+  constructor(ast: ast.ContinueStatement, options: ParserOptions<AstNode>) {
+    super(ast, options);
   }
 
   print(): Doc {

src/slang-nodes/ContractDefinition.ts

@@ -25,10 +25,10 @@ export class ContractDefinition extends SlangNode {
   members: ContractMembers;
 
   constructor(ast: ast.ContractDefinition, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.abstractKeyword = ast.abstractKeyword?.unparse();
-    this.name = new TerminalNode(ast.name);
+    this.name = new TerminalNode(ast.name, options);
     this.specifiers = new ContractSpecifiers(ast.specifiers, options);
     this.members = new ContractMembers(ast.members, options);
 

src/slang-nodes/ContractMember.ts

@@ -47,7 +47,7 @@ function createNonterminalVariant(
     return new StructDefinition(variant, options);
   }
   if (variant instanceof ast.EnumDefinition) {
-    return new EnumDefinition(variant);
+    return new EnumDefinition(variant, options);
   }
   if (variant instanceof ast.EventDefinition) {
     return new EventDefinition(variant, options);
@@ -59,7 +59,7 @@ function createNonterminalVariant(
     return new ErrorDefinition(variant, options);
   }
   if (variant instanceof ast.UserDefinedValueTypeDefinition) {
-    return new UserDefinedValueTypeDefinition(variant);
+    return new UserDefinedValueTypeDefinition(variant, options);
   }
   const exhaustiveCheck: never = variant;
   throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`);
@@ -84,7 +84,7 @@ export class ContractMember extends SlangNode {
     | UserDefinedValueTypeDefinition;
 
   constructor(ast: ast.ContractMember, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.variant = createNonterminalVariant(ast.variant, options);
 

src/slang-nodes/ContractMembers.ts

@@ -19,7 +19,7 @@ export class ContractMembers extends SlangNode {
   items: ContractMember['variant'][];
 
   constructor(ast: ast.ContractMembers, options: ParserOptions<AstNode>) {
-    super(ast, true);
+    super(ast, options, true);
 
     this.items = ast.items.map((item) =>
       extractVariant(new ContractMember(item, options))

src/slang-nodes/ContractSpecifier.ts

@@ -27,7 +27,7 @@ export class ContractSpecifier extends SlangNode {
   variant: InheritanceSpecifier | StorageLayoutSpecifier;
 
   constructor(ast: ast.ContractSpecifier, options: ParserOptions<AstNode>) {
-    super(ast);
+    super(ast, options);
 
     this.variant = createNonterminalVariant(ast.variant, options);
 

src/slang-nodes/ContractSpecifiers.ts

@@ -19,7 +19,7 @@ export class ContractSpecifiers extends SlangNode {
   items: ContractSpecifier['variant'][];
 
   constructor(ast: ast.ContractSpecifiers, options: ParserOptions<AstNode>) {
-    super(ast, true);
+    super(ast, options, true);
 
     this.items = ast.items.map((item) =>
       extractVariant(new ContractSpecifier(item, options))