From 5da487ad64502f2e1272ae84022e8eae31edaf4a Mon Sep 17 00:00:00 2001 From: Klaus Hott Date: Mon, 26 Jan 2026 12:03:24 -0300 Subject: [PATCH 1/2] prettier could be run in parallel, this should add a layer of safety for those cases. --- src/slang-nodes/AbicoderPragma.ts | 9 ++-- src/slang-nodes/AbicoderVersion.ts | 7 ++-- src/slang-nodes/AdditiveExpression.ts | 2 +- src/slang-nodes/AddressType.ts | 7 ++-- src/slang-nodes/AndExpression.ts | 2 +- src/slang-nodes/ArgumentsDeclaration.ts | 2 +- src/slang-nodes/ArrayExpression.ts | 2 +- src/slang-nodes/ArrayTypeName.ts | 2 +- src/slang-nodes/ArrayValues.ts | 2 +- src/slang-nodes/AssemblyFlags.ts | 2 +- src/slang-nodes/AssemblyFlagsDeclaration.ts | 2 +- src/slang-nodes/AssemblyStatement.ts | 2 +- src/slang-nodes/AssignmentExpression.ts | 2 +- src/slang-nodes/BitwiseAndExpression.ts | 2 +- src/slang-nodes/BitwiseOrExpression.ts | 2 +- src/slang-nodes/BitwiseXorExpression.ts | 2 +- src/slang-nodes/Block.ts | 2 +- src/slang-nodes/BreakStatement.ts | 7 ++-- src/slang-nodes/CallOptions.ts | 2 +- src/slang-nodes/CallOptionsExpression.ts | 2 +- src/slang-nodes/CatchClause.ts | 2 +- src/slang-nodes/CatchClauseError.ts | 4 +- src/slang-nodes/CatchClauses.ts | 2 +- src/slang-nodes/ConditionalExpression.ts | 2 +- src/slang-nodes/ConstantDefinition.ts | 4 +- src/slang-nodes/ConstructorAttribute.ts | 4 +- src/slang-nodes/ConstructorAttributes.ts | 2 +- src/slang-nodes/ConstructorDefinition.ts | 2 +- src/slang-nodes/ContinueStatement.ts | 7 ++-- src/slang-nodes/ContractDefinition.ts | 4 +- src/slang-nodes/ContractMember.ts | 6 +-- src/slang-nodes/ContractMembers.ts | 2 +- src/slang-nodes/ContractSpecifier.ts | 2 +- src/slang-nodes/ContractSpecifiers.ts | 2 +- src/slang-nodes/DecimalNumberExpression.ts | 12 ++++-- src/slang-nodes/DoWhileStatement.ts | 2 +- src/slang-nodes/ElementaryType.ts | 10 +++-- src/slang-nodes/ElseBranch.ts | 2 +- src/slang-nodes/EmitStatement.ts | 4 +- src/slang-nodes/EnumDefinition.ts | 11 ++--- src/slang-nodes/EnumMembers.ts | 9 ++-- src/slang-nodes/EqualityExpression.ts | 2 +- src/slang-nodes/ErrorDefinition.ts | 4 +- src/slang-nodes/ErrorParameter.ts | 4 +- src/slang-nodes/ErrorParameters.ts | 2 +- src/slang-nodes/ErrorParametersDeclaration.ts | 2 +- src/slang-nodes/EventDefinition.ts | 4 +- src/slang-nodes/EventParameter.ts | 4 +- src/slang-nodes/EventParameters.ts | 2 +- src/slang-nodes/EventParametersDeclaration.ts | 2 +- src/slang-nodes/ExperimentalFeature.ts | 4 +- src/slang-nodes/ExperimentalPragma.ts | 2 +- src/slang-nodes/ExponentiationExpression.ts | 2 +- src/slang-nodes/Expression.ts | 10 ++--- src/slang-nodes/ExpressionStatement.ts | 2 +- src/slang-nodes/FallbackFunctionAttribute.ts | 6 +-- src/slang-nodes/FallbackFunctionAttributes.ts | 2 +- src/slang-nodes/FallbackFunctionDefinition.ts | 2 +- src/slang-nodes/ForStatement.ts | 2 +- src/slang-nodes/ForStatementCondition.ts | 4 +- src/slang-nodes/ForStatementInitialization.ts | 4 +- src/slang-nodes/FunctionAttribute.ts | 6 +-- src/slang-nodes/FunctionAttributes.ts | 2 +- src/slang-nodes/FunctionBody.ts | 4 +- src/slang-nodes/FunctionCallExpression.ts | 2 +- src/slang-nodes/FunctionDefinition.ts | 4 +- src/slang-nodes/FunctionName.ts | 8 ++-- src/slang-nodes/FunctionType.ts | 4 +- src/slang-nodes/FunctionTypeAttribute.ts | 8 ++-- src/slang-nodes/FunctionTypeAttributes.ts | 12 ++++-- src/slang-nodes/HexNumberExpression.ts | 9 ++-- src/slang-nodes/HexStringLiteral.ts | 2 +- src/slang-nodes/HexStringLiterals.ts | 2 +- src/slang-nodes/IdentifierPath.ts | 9 ++-- src/slang-nodes/IfStatement.ts | 2 +- src/slang-nodes/ImportAlias.ts | 9 ++-- src/slang-nodes/ImportClause.ts | 2 +- src/slang-nodes/ImportDeconstruction.ts | 4 +- src/slang-nodes/ImportDeconstructionSymbol.ts | 14 ++++--- .../ImportDeconstructionSymbols.ts | 11 +++-- src/slang-nodes/ImportDirective.ts | 2 +- src/slang-nodes/IndexAccessEnd.ts | 2 +- src/slang-nodes/IndexAccessExpression.ts | 2 +- src/slang-nodes/InequalityExpression.ts | 2 +- src/slang-nodes/InheritanceSpecifier.ts | 2 +- src/slang-nodes/InheritanceType.ts | 4 +- src/slang-nodes/InheritanceTypes.ts | 2 +- src/slang-nodes/InterfaceDefinition.ts | 4 +- src/slang-nodes/InterfaceMembers.ts | 2 +- src/slang-nodes/LibraryDefinition.ts | 4 +- src/slang-nodes/LibraryMembers.ts | 2 +- src/slang-nodes/MappingKey.ts | 11 ++--- src/slang-nodes/MappingKeyType.ts | 16 +++++--- src/slang-nodes/MappingType.ts | 4 +- src/slang-nodes/MappingValue.ts | 4 +- src/slang-nodes/MemberAccessExpression.ts | 4 +- src/slang-nodes/ModifierAttribute.ts | 10 +++-- src/slang-nodes/ModifierAttributes.ts | 9 ++-- src/slang-nodes/ModifierDefinition.ts | 6 +-- src/slang-nodes/ModifierInvocation.ts | 4 +- src/slang-nodes/MultiplicativeExpression.ts | 2 +- src/slang-nodes/NamedArgument.ts | 4 +- src/slang-nodes/NamedArgumentGroup.ts | 2 +- src/slang-nodes/NamedArguments.ts | 2 +- src/slang-nodes/NamedArgumentsDeclaration.ts | 2 +- src/slang-nodes/NamedImport.ts | 4 +- src/slang-nodes/NewExpression.ts | 2 +- src/slang-nodes/NumberUnit.ts | 7 ++-- src/slang-nodes/OrExpression.ts | 2 +- src/slang-nodes/OverridePaths.ts | 9 ++-- src/slang-nodes/OverridePathsDeclaration.ts | 12 ++++-- src/slang-nodes/OverrideSpecifier.ts | 9 ++-- src/slang-nodes/Parameter.ts | 6 +-- src/slang-nodes/Parameters.ts | 2 +- src/slang-nodes/ParametersDeclaration.ts | 2 +- src/slang-nodes/PathImport.ts | 4 +- src/slang-nodes/PositionalArguments.ts | 2 +- .../PositionalArgumentsDeclaration.ts | 2 +- src/slang-nodes/PostfixExpression.ts | 2 +- src/slang-nodes/Pragma.ts | 6 +-- src/slang-nodes/PragmaDirective.ts | 2 +- src/slang-nodes/PrefixExpression.ts | 2 +- src/slang-nodes/ReceiveFunctionAttribute.ts | 6 +-- src/slang-nodes/ReceiveFunctionAttributes.ts | 2 +- src/slang-nodes/ReceiveFunctionDefinition.ts | 2 +- src/slang-nodes/ReturnStatement.ts | 2 +- src/slang-nodes/ReturnsDeclaration.ts | 2 +- src/slang-nodes/RevertStatement.ts | 4 +- src/slang-nodes/ShiftExpression.ts | 2 +- src/slang-nodes/SimpleVersionLiteral.ts | 7 ++-- src/slang-nodes/SlangNode.ts | 41 ++++++++++--------- src/slang-nodes/SourceUnit.ts | 2 +- src/slang-nodes/SourceUnitMember.ts | 6 +-- src/slang-nodes/SourceUnitMembers.ts | 2 +- src/slang-nodes/StateVariableAttribute.ts | 13 ++++-- src/slang-nodes/StateVariableAttributes.ts | 12 ++++-- src/slang-nodes/StateVariableDefinition.ts | 6 +-- .../StateVariableDefinitionValue.ts | 2 +- src/slang-nodes/Statement.ts | 8 ++-- src/slang-nodes/Statements.ts | 2 +- src/slang-nodes/StorageLayoutSpecifier.ts | 2 +- src/slang-nodes/StorageLocation.ts | 7 ++-- src/slang-nodes/StringExpression.ts | 2 +- src/slang-nodes/StringLiteral.ts | 2 +- src/slang-nodes/StringLiterals.ts | 2 +- src/slang-nodes/StructDefinition.ts | 4 +- src/slang-nodes/StructMember.ts | 4 +- src/slang-nodes/StructMembers.ts | 2 +- src/slang-nodes/TerminalNode.ts | 7 ++-- src/slang-nodes/ThrowStatement.ts | 7 ++-- src/slang-nodes/TryStatement.ts | 2 +- src/slang-nodes/TupleDeconstructionElement.ts | 2 +- .../TupleDeconstructionElements.ts | 2 +- .../TupleDeconstructionStatement.ts | 2 +- src/slang-nodes/TupleExpression.ts | 2 +- src/slang-nodes/TupleMember.ts | 4 +- src/slang-nodes/TupleValue.ts | 2 +- src/slang-nodes/TupleValues.ts | 2 +- src/slang-nodes/TypeExpression.ts | 2 +- src/slang-nodes/TypeName.ts | 6 +-- src/slang-nodes/TypedTupleMember.ts | 6 +-- src/slang-nodes/UncheckedBlock.ts | 2 +- src/slang-nodes/UnicodeStringLiteral.ts | 2 +- src/slang-nodes/UnicodeStringLiterals.ts | 2 +- src/slang-nodes/UnnamedFunctionAttribute.ts | 4 +- src/slang-nodes/UnnamedFunctionAttributes.ts | 2 +- src/slang-nodes/UnnamedFunctionDefinition.ts | 2 +- src/slang-nodes/UntypedTupleMember.ts | 11 ++--- .../UserDefinedValueTypeDefinition.ts | 14 ++++--- src/slang-nodes/UsingAlias.ts | 9 ++-- src/slang-nodes/UsingClause.ts | 16 +++++--- src/slang-nodes/UsingDeconstruction.ts | 9 ++-- src/slang-nodes/UsingDeconstructionSymbol.ts | 14 ++++--- src/slang-nodes/UsingDeconstructionSymbols.ts | 11 +++-- src/slang-nodes/UsingDirective.ts | 4 +- src/slang-nodes/UsingOperator.ts | 7 ++-- src/slang-nodes/UsingTarget.ts | 4 +- .../VariableDeclarationStatement.ts | 6 +-- src/slang-nodes/VariableDeclarationType.ts | 4 +- src/slang-nodes/VariableDeclarationValue.ts | 2 +- src/slang-nodes/VersionExpression.ts | 16 +++++--- src/slang-nodes/VersionExpressionSet.ts | 9 ++-- src/slang-nodes/VersionExpressionSets.ts | 11 +++-- src/slang-nodes/VersionLiteral.ts | 10 +++-- src/slang-nodes/VersionOperator.ts | 7 ++-- src/slang-nodes/VersionPragma.ts | 9 ++-- src/slang-nodes/VersionRange.ts | 11 ++--- src/slang-nodes/VersionTerm.ts | 11 ++--- src/slang-nodes/WhileStatement.ts | 2 +- src/slang-nodes/YulArguments.ts | 2 +- src/slang-nodes/YulAssignmentOperator.ts | 10 +++-- src/slang-nodes/YulBlock.ts | 2 +- src/slang-nodes/YulBreakStatement.ts | 7 ++-- src/slang-nodes/YulColonAndEqual.ts | 7 ++-- src/slang-nodes/YulContinueStatement.ts | 7 ++-- src/slang-nodes/YulDefaultCase.ts | 2 +- src/slang-nodes/YulEqualAndColon.ts | 7 ++-- src/slang-nodes/YulExpression.ts | 4 +- src/slang-nodes/YulForStatement.ts | 2 +- src/slang-nodes/YulFunctionCallExpression.ts | 2 +- src/slang-nodes/YulFunctionDefinition.ts | 8 ++-- src/slang-nodes/YulIfStatement.ts | 2 +- src/slang-nodes/YulLabel.ts | 9 ++-- src/slang-nodes/YulLeaveStatement.ts | 7 ++-- src/slang-nodes/YulLiteral.ts | 4 +- src/slang-nodes/YulParameters.ts | 9 ++-- src/slang-nodes/YulParametersDeclaration.ts | 12 ++++-- src/slang-nodes/YulPath.ts | 9 ++-- src/slang-nodes/YulPaths.ts | 9 ++-- src/slang-nodes/YulReturnsDeclaration.ts | 9 ++-- src/slang-nodes/YulStackAssignmentOperator.ts | 13 ++++-- .../YulStackAssignmentStatement.ts | 14 ++++--- src/slang-nodes/YulStatement.ts | 12 +++--- src/slang-nodes/YulStatements.ts | 2 +- src/slang-nodes/YulSwitchCase.ts | 2 +- src/slang-nodes/YulSwitchCases.ts | 2 +- src/slang-nodes/YulSwitchStatement.ts | 2 +- src/slang-nodes/YulValueCase.ts | 2 +- .../YulVariableAssignmentStatement.ts | 8 ++-- .../YulVariableDeclarationStatement.ts | 4 +- .../YulVariableDeclarationValue.ts | 6 ++- src/slang-nodes/YulVariableNames.ts | 9 ++-- src/slangSolidityParser.ts | 8 ++-- src/types.d.ts | 4 +- 224 files changed, 637 insertions(+), 504 deletions(-) diff --git a/src/slang-nodes/AbicoderPragma.ts b/src/slang-nodes/AbicoderPragma.ts index 4bb8bfb36..3f2e9b05e 100644 --- a/src/slang-nodes/AbicoderPragma.ts +++ b/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.ts'; export class AbicoderPragma extends SlangNode { readonly kind = NonterminalKind.AbicoderPragma; version: AbicoderVersion; - constructor(ast: ast.AbicoderPragma) { - super(ast); + constructor(ast: ast.AbicoderPragma, options: ParserOptions) { + super(ast, options); - this.version = new AbicoderVersion(ast.version); + this.version = new AbicoderVersion(ast.version, options); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slang-nodes/AbicoderVersion.ts b/src/slang-nodes/AbicoderVersion.ts index 3e12c13e8..4a3a55091 100644 --- a/src/slang-nodes/AbicoderVersion.ts +++ b/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.ts'; export class AbicoderVersion extends SlangNode { readonly kind = NonterminalKind.AbicoderVersion; variant: string; - constructor(ast: ast.AbicoderVersion) { - super(ast); + constructor(ast: ast.AbicoderVersion, options: ParserOptions) { + super(ast, options); this.variant = ast.variant.unparse(); } diff --git a/src/slang-nodes/AdditiveExpression.ts b/src/slang-nodes/AdditiveExpression.ts index e11e235b9..18dd5ef02 100644 --- a/src/slang-nodes/AdditiveExpression.ts +++ b/src/slang-nodes/AdditiveExpression.ts @@ -36,7 +36,7 @@ export class AdditiveExpression extends SlangNode { rightOperand: Expression['variant']; constructor(ast: ast.AdditiveExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/AddressType.ts b/src/slang-nodes/AddressType.ts index 86862359a..f4d66cfa0 100644 --- a/src/slang-nodes/AddressType.ts +++ b/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.ts'; export class AddressType extends SlangNode { readonly kind = NonterminalKind.AddressType; payableKeyword?: string; - constructor(ast: ast.AddressType) { - super(ast); + constructor(ast: ast.AddressType, options: ParserOptions) { + super(ast, options); this.payableKeyword = ast.payableKeyword?.unparse(); } diff --git a/src/slang-nodes/AndExpression.ts b/src/slang-nodes/AndExpression.ts index 20b9e79bc..52d52b52d 100644 --- a/src/slang-nodes/AndExpression.ts +++ b/src/slang-nodes/AndExpression.ts @@ -19,7 +19,7 @@ export class AndExpression extends SlangNode { rightOperand: Expression['variant']; constructor(ast: ast.AndExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/ArgumentsDeclaration.ts b/src/slang-nodes/ArgumentsDeclaration.ts index a6b8f0988..13b88cd64 100644 --- a/src/slang-nodes/ArgumentsDeclaration.ts +++ b/src/slang-nodes/ArgumentsDeclaration.ts @@ -27,7 +27,7 @@ export class ArgumentsDeclaration extends SlangNode { variant: PositionalArgumentsDeclaration | NamedArgumentsDeclaration; constructor(ast: ast.ArgumentsDeclaration, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/ArrayExpression.ts b/src/slang-nodes/ArrayExpression.ts index 4d9155cba..869b84c37 100644 --- a/src/slang-nodes/ArrayExpression.ts +++ b/src/slang-nodes/ArrayExpression.ts @@ -13,7 +13,7 @@ export class ArrayExpression extends SlangNode { items: ArrayValues; constructor(ast: ast.ArrayExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.items = new ArrayValues(ast.items, options); } diff --git a/src/slang-nodes/ArrayTypeName.ts b/src/slang-nodes/ArrayTypeName.ts index eea23eb13..04e157f29 100644 --- a/src/slang-nodes/ArrayTypeName.ts +++ b/src/slang-nodes/ArrayTypeName.ts @@ -17,7 +17,7 @@ export class ArrayTypeName extends SlangNode { index?: Expression['variant']; constructor(ast: ast.ArrayTypeName, options: ParserOptions) { - super(ast); + super(ast, options); this.operand = extractVariant(new TypeName(ast.operand, options)); if (ast.index) { diff --git a/src/slang-nodes/ArrayValues.ts b/src/slang-nodes/ArrayValues.ts index 4d896e3b6..93fd8abaa 100644 --- a/src/slang-nodes/ArrayValues.ts +++ b/src/slang-nodes/ArrayValues.ts @@ -15,7 +15,7 @@ export class ArrayValues extends SlangNode { items: Expression['variant'][]; constructor(ast: ast.ArrayValues, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new Expression(item, options)) diff --git a/src/slang-nodes/AssemblyFlags.ts b/src/slang-nodes/AssemblyFlags.ts index e5f54c8f2..39250fcbe 100644 --- a/src/slang-nodes/AssemblyFlags.ts +++ b/src/slang-nodes/AssemblyFlags.ts @@ -14,7 +14,7 @@ export class AssemblyFlags extends SlangNode { items: StringLiteral[]; constructor(ast: ast.AssemblyFlags, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new StringLiteral(item, options)); } diff --git a/src/slang-nodes/AssemblyFlagsDeclaration.ts b/src/slang-nodes/AssemblyFlagsDeclaration.ts index 8a827182a..17e8c8b9f 100644 --- a/src/slang-nodes/AssemblyFlagsDeclaration.ts +++ b/src/slang-nodes/AssemblyFlagsDeclaration.ts @@ -16,7 +16,7 @@ export class AssemblyFlagsDeclaration extends SlangNode { ast: ast.AssemblyFlagsDeclaration, options: ParserOptions ) { - super(ast); + super(ast, options); this.flags = new AssemblyFlags(ast.flags, options); diff --git a/src/slang-nodes/AssemblyStatement.ts b/src/slang-nodes/AssemblyStatement.ts index 9c4a1d366..b4b49bf2c 100644 --- a/src/slang-nodes/AssemblyStatement.ts +++ b/src/slang-nodes/AssemblyStatement.ts @@ -20,7 +20,7 @@ export class AssemblyStatement extends SlangNode { body: YulBlock; constructor(ast: ast.AssemblyStatement, options: ParserOptions) { - super(ast); + super(ast, options); if (ast.label) { this.label = new StringLiteral(ast.label, options); diff --git a/src/slang-nodes/AssignmentExpression.ts b/src/slang-nodes/AssignmentExpression.ts index f1963330b..2be8daa70 100644 --- a/src/slang-nodes/AssignmentExpression.ts +++ b/src/slang-nodes/AssignmentExpression.ts @@ -21,7 +21,7 @@ export class AssignmentExpression extends SlangNode { rightOperand: Expression['variant']; constructor(ast: ast.AssignmentExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/BitwiseAndExpression.ts b/src/slang-nodes/BitwiseAndExpression.ts index 88547f1d4..3634e0676 100644 --- a/src/slang-nodes/BitwiseAndExpression.ts +++ b/src/slang-nodes/BitwiseAndExpression.ts @@ -32,7 +32,7 @@ export class BitwiseAndExpression extends SlangNode { rightOperand: Expression['variant']; constructor(ast: ast.BitwiseAndExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/BitwiseOrExpression.ts b/src/slang-nodes/BitwiseOrExpression.ts index c2daaa349..bf3c46f5a 100644 --- a/src/slang-nodes/BitwiseOrExpression.ts +++ b/src/slang-nodes/BitwiseOrExpression.ts @@ -42,7 +42,7 @@ export class BitwiseOrExpression extends SlangNode { rightOperand: Expression['variant']; constructor(ast: ast.BitwiseOrExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/BitwiseXorExpression.ts b/src/slang-nodes/BitwiseXorExpression.ts index 9c9adfe84..94827a278 100644 --- a/src/slang-nodes/BitwiseXorExpression.ts +++ b/src/slang-nodes/BitwiseXorExpression.ts @@ -32,7 +32,7 @@ export class BitwiseXorExpression extends SlangNode { rightOperand: Expression['variant']; constructor(ast: ast.BitwiseXorExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/Block.ts b/src/slang-nodes/Block.ts index 8b441b877..71b2ee208 100644 --- a/src/slang-nodes/Block.ts +++ b/src/slang-nodes/Block.ts @@ -13,7 +13,7 @@ export class Block extends SlangNode { statements: Statements; constructor(ast: ast.Block, options: ParserOptions) { - super(ast); + super(ast, options); this.statements = new Statements(ast.statements, options); diff --git a/src/slang-nodes/BreakStatement.ts b/src/slang-nodes/BreakStatement.ts index 2e8eb523d..532ff0ae0 100644 --- a/src/slang-nodes/BreakStatement.ts +++ b/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.ts'; export class BreakStatement extends SlangNode { readonly kind = NonterminalKind.BreakStatement; - constructor(ast: ast.BreakStatement) { - super(ast); + constructor(ast: ast.BreakStatement, options: ParserOptions) { + super(ast, options); } print(): Doc { diff --git a/src/slang-nodes/CallOptions.ts b/src/slang-nodes/CallOptions.ts index 4092d5d6a..9c76836a9 100644 --- a/src/slang-nodes/CallOptions.ts +++ b/src/slang-nodes/CallOptions.ts @@ -17,7 +17,7 @@ export class CallOptions extends SlangNode { items: NamedArgument[]; constructor(ast: ast.CallOptions, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new NamedArgument(item, options)); } diff --git a/src/slang-nodes/CallOptionsExpression.ts b/src/slang-nodes/CallOptionsExpression.ts index 77bcccb24..2d78cbc20 100644 --- a/src/slang-nodes/CallOptionsExpression.ts +++ b/src/slang-nodes/CallOptionsExpression.ts @@ -17,7 +17,7 @@ export class CallOptionsExpression extends SlangNode { options: CallOptions; constructor(ast: ast.CallOptionsExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.operand = extractVariant(new Expression(ast.operand, options)); this.options = new CallOptions(ast.options, options); diff --git a/src/slang-nodes/CatchClause.ts b/src/slang-nodes/CatchClause.ts index 620df53f4..40283418f 100644 --- a/src/slang-nodes/CatchClause.ts +++ b/src/slang-nodes/CatchClause.ts @@ -16,7 +16,7 @@ export class CatchClause extends SlangNode { body: Block; constructor(ast: ast.CatchClause, options: ParserOptions) { - super(ast); + super(ast, options); if (ast.error) { this.error = new CatchClauseError(ast.error, options); diff --git a/src/slang-nodes/CatchClauseError.ts b/src/slang-nodes/CatchClauseError.ts index 04f651c65..404695310 100644 --- a/src/slang-nodes/CatchClauseError.ts +++ b/src/slang-nodes/CatchClauseError.ts @@ -19,10 +19,10 @@ export class CatchClauseError extends SlangNode { parameters: ParametersDeclaration; constructor(ast: ast.CatchClauseError, options: ParserOptions) { - 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); diff --git a/src/slang-nodes/CatchClauses.ts b/src/slang-nodes/CatchClauses.ts index 5106e0411..08f3f8e98 100644 --- a/src/slang-nodes/CatchClauses.ts +++ b/src/slang-nodes/CatchClauses.ts @@ -16,7 +16,7 @@ export class CatchClauses extends SlangNode { items: CatchClause[]; constructor(ast: ast.CatchClauses, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new CatchClause(item, options)); diff --git a/src/slang-nodes/ConditionalExpression.ts b/src/slang-nodes/ConditionalExpression.ts index 5e06c8a78..fbc0b52cd 100644 --- a/src/slang-nodes/ConditionalExpression.ts +++ b/src/slang-nodes/ConditionalExpression.ts @@ -120,7 +120,7 @@ export class ConditionalExpression extends SlangNode { falseExpression: Expression['variant']; constructor(ast: ast.ConditionalExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.operand = extractVariant(new Expression(ast.operand, options)); this.trueExpression = extractVariant( diff --git a/src/slang-nodes/ConstantDefinition.ts b/src/slang-nodes/ConstantDefinition.ts index 0c898b8e4..9fb12799d 100644 --- a/src/slang-nodes/ConstantDefinition.ts +++ b/src/slang-nodes/ConstantDefinition.ts @@ -20,10 +20,10 @@ export class ConstantDefinition extends SlangNode { value: Expression['variant']; constructor(ast: ast.ConstantDefinition, options: ParserOptions) { - 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); diff --git a/src/slang-nodes/ConstructorAttribute.ts b/src/slang-nodes/ConstructorAttribute.ts index 5414d6d5c..71cb5c181 100644 --- a/src/slang-nodes/ConstructorAttribute.ts +++ b/src/slang-nodes/ConstructorAttribute.ts @@ -16,11 +16,11 @@ export class ConstructorAttribute extends SlangNode { variant: ModifierInvocation | TerminalNode; constructor(ast: ast.ConstructorAttribute, options: ParserOptions) { - 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); diff --git a/src/slang-nodes/ConstructorAttributes.ts b/src/slang-nodes/ConstructorAttributes.ts index 7c72b9264..354660255 100644 --- a/src/slang-nodes/ConstructorAttributes.ts +++ b/src/slang-nodes/ConstructorAttributes.ts @@ -18,7 +18,7 @@ export class ConstructorAttributes extends SlangNode { items: ConstructorAttribute['variant'][]; constructor(ast: ast.ConstructorAttributes, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new ConstructorAttribute(item, options)) diff --git a/src/slang-nodes/ConstructorDefinition.ts b/src/slang-nodes/ConstructorDefinition.ts index 384ff41f5..293c4fc90 100644 --- a/src/slang-nodes/ConstructorDefinition.ts +++ b/src/slang-nodes/ConstructorDefinition.ts @@ -20,7 +20,7 @@ export class ConstructorDefinition extends SlangNode { body: Block; constructor(ast: ast.ConstructorDefinition, options: ParserOptions) { - super(ast); + super(ast, options); this.parameters = new ParametersDeclaration(ast.parameters, options); this.attributes = new ConstructorAttributes(ast.attributes, options); diff --git a/src/slang-nodes/ContinueStatement.ts b/src/slang-nodes/ContinueStatement.ts index 5e856cb49..d9e0400a3 100644 --- a/src/slang-nodes/ContinueStatement.ts +++ b/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.ts'; export class ContinueStatement extends SlangNode { readonly kind = NonterminalKind.ContinueStatement; - constructor(ast: ast.ContinueStatement) { - super(ast); + constructor(ast: ast.ContinueStatement, options: ParserOptions) { + super(ast, options); } print(): Doc { diff --git a/src/slang-nodes/ContractDefinition.ts b/src/slang-nodes/ContractDefinition.ts index 41c24bd5a..93268775f 100644 --- a/src/slang-nodes/ContractDefinition.ts +++ b/src/slang-nodes/ContractDefinition.ts @@ -25,10 +25,10 @@ export class ContractDefinition extends SlangNode { members: ContractMembers; constructor(ast: ast.ContractDefinition, options: ParserOptions) { - 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); diff --git a/src/slang-nodes/ContractMember.ts b/src/slang-nodes/ContractMember.ts index 2a109000b..81a9ab7b5 100644 --- a/src/slang-nodes/ContractMember.ts +++ b/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) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/ContractMembers.ts b/src/slang-nodes/ContractMembers.ts index 884421a9b..4c1844ea9 100644 --- a/src/slang-nodes/ContractMembers.ts +++ b/src/slang-nodes/ContractMembers.ts @@ -19,7 +19,7 @@ export class ContractMembers extends SlangNode { items: ContractMember['variant'][]; constructor(ast: ast.ContractMembers, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new ContractMember(item, options)) diff --git a/src/slang-nodes/ContractSpecifier.ts b/src/slang-nodes/ContractSpecifier.ts index aa55bb401..a62c0478a 100644 --- a/src/slang-nodes/ContractSpecifier.ts +++ b/src/slang-nodes/ContractSpecifier.ts @@ -27,7 +27,7 @@ export class ContractSpecifier extends SlangNode { variant: InheritanceSpecifier | StorageLayoutSpecifier; constructor(ast: ast.ContractSpecifier, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/ContractSpecifiers.ts b/src/slang-nodes/ContractSpecifiers.ts index e5cea806a..8e57bb822 100644 --- a/src/slang-nodes/ContractSpecifiers.ts +++ b/src/slang-nodes/ContractSpecifiers.ts @@ -19,7 +19,7 @@ export class ContractSpecifiers extends SlangNode { items: ContractSpecifier['variant'][]; constructor(ast: ast.ContractSpecifiers, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new ContractSpecifier(item, options)) diff --git a/src/slang-nodes/DecimalNumberExpression.ts b/src/slang-nodes/DecimalNumberExpression.ts index 211fb2bee..6ef5d26be 100644 --- a/src/slang-nodes/DecimalNumberExpression.ts +++ b/src/slang-nodes/DecimalNumberExpression.ts @@ -4,8 +4,9 @@ import { SlangNode } from './SlangNode.js'; import { NumberUnit } from './NumberUnit.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.ts'; export class DecimalNumberExpression extends SlangNode { readonly kind = NonterminalKind.DecimalNumberExpression; @@ -14,12 +15,15 @@ export class DecimalNumberExpression extends SlangNode { unit?: NumberUnit; - constructor(ast: ast.DecimalNumberExpression) { - super(ast); + constructor( + ast: ast.DecimalNumberExpression, + options: ParserOptions + ) { + super(ast, options); this.literal = ast.literal.unparse(); if (ast.unit) { - this.unit = new NumberUnit(ast.unit); + this.unit = new NumberUnit(ast.unit, options); } this.updateMetadata(this.unit); diff --git a/src/slang-nodes/DoWhileStatement.ts b/src/slang-nodes/DoWhileStatement.ts index 00cea0967..8416d0dd8 100644 --- a/src/slang-nodes/DoWhileStatement.ts +++ b/src/slang-nodes/DoWhileStatement.ts @@ -21,7 +21,7 @@ export class DoWhileStatement extends SlangNode { condition: Expression['variant']; constructor(ast: ast.DoWhileStatement, options: ParserOptions) { - super(ast); + super(ast, options); this.body = extractVariant(new Statement(ast.body, options)); this.condition = extractVariant(new Expression(ast.condition, options)); diff --git a/src/slang-nodes/ElementaryType.ts b/src/slang-nodes/ElementaryType.ts index 5f958e5b3..a23a39669 100644 --- a/src/slang-nodes/ElementaryType.ts +++ b/src/slang-nodes/ElementaryType.ts @@ -7,21 +7,23 @@ import { AddressType } from './AddressType.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.ts'; export class ElementaryType extends SlangNode { readonly kind = NonterminalKind.ElementaryType; variant: AddressType | TerminalNode; - constructor(ast: ast.ElementaryType) { - super(ast); + constructor(ast: ast.ElementaryType, options: ParserOptions) { + 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 AddressType(variant); + this.variant = new AddressType(variant, options); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ElseBranch.ts b/src/slang-nodes/ElseBranch.ts index e7d3f4fcf..4e9feaefa 100644 --- a/src/slang-nodes/ElseBranch.ts +++ b/src/slang-nodes/ElseBranch.ts @@ -21,7 +21,7 @@ export class ElseBranch extends SlangNode { body: Statement['variant']; constructor(ast: ast.ElseBranch, options: ParserOptions) { - super(ast); + super(ast, options); this.body = extractVariant(new Statement(ast.body, options)); diff --git a/src/slang-nodes/EmitStatement.ts b/src/slang-nodes/EmitStatement.ts index 42e7166ec..66db8b5ee 100644 --- a/src/slang-nodes/EmitStatement.ts +++ b/src/slang-nodes/EmitStatement.ts @@ -17,9 +17,9 @@ export class EmitStatement extends SlangNode { arguments: ArgumentsDeclaration['variant']; constructor(ast: ast.EmitStatement, options: ParserOptions) { - super(ast); + super(ast, options); - this.event = new IdentifierPath(ast.event); + this.event = new IdentifierPath(ast.event, options); this.arguments = extractVariant( new ArgumentsDeclaration(ast.arguments, options) ); diff --git a/src/slang-nodes/EnumDefinition.ts b/src/slang-nodes/EnumDefinition.ts index a0b287b23..bc6e17d57 100644 --- a/src/slang-nodes/EnumDefinition.ts +++ b/src/slang-nodes/EnumDefinition.ts @@ -4,8 +4,9 @@ import { TerminalNode } from './TerminalNode.js'; import { EnumMembers } from './EnumMembers.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 EnumDefinition extends SlangNode { readonly kind = NonterminalKind.EnumDefinition; @@ -14,11 +15,11 @@ export class EnumDefinition extends SlangNode { members: EnumMembers; - constructor(ast: ast.EnumDefinition) { - super(ast); + constructor(ast: ast.EnumDefinition, options: ParserOptions) { + super(ast, options); - this.name = new TerminalNode(ast.name); - this.members = new EnumMembers(ast.members); + this.name = new TerminalNode(ast.name, options); + this.members = new EnumMembers(ast.members, options); this.updateMetadata(this.members); } diff --git a/src/slang-nodes/EnumMembers.ts b/src/slang-nodes/EnumMembers.ts index bb4058e73..f21ca49c0 100644 --- a/src/slang-nodes/EnumMembers.ts +++ b/src/slang-nodes/EnumMembers.ts @@ -5,8 +5,9 @@ import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.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'; const { hardline } = doc.builders; @@ -15,10 +16,10 @@ export class EnumMembers extends SlangNode { items: TerminalNode[]; - constructor(ast: ast.EnumMembers) { - super(ast, true); + constructor(ast: ast.EnumMembers, options: ParserOptions) { + super(ast, options, true); - this.items = ast.items.map((item) => new TerminalNode(item)); + this.items = ast.items.map((item) => new TerminalNode(item, options)); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slang-nodes/EqualityExpression.ts b/src/slang-nodes/EqualityExpression.ts index 81727e9f1..1d6c8faf0 100644 --- a/src/slang-nodes/EqualityExpression.ts +++ b/src/slang-nodes/EqualityExpression.ts @@ -30,7 +30,7 @@ export class EqualityExpression extends SlangNode { rightOperand: Expression['variant']; constructor(ast: ast.EqualityExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/ErrorDefinition.ts b/src/slang-nodes/ErrorDefinition.ts index 64e0fa45f..77368b476 100644 --- a/src/slang-nodes/ErrorDefinition.ts +++ b/src/slang-nodes/ErrorDefinition.ts @@ -16,9 +16,9 @@ export class ErrorDefinition extends SlangNode { members: ErrorParametersDeclaration; constructor(ast: ast.ErrorDefinition, options: ParserOptions) { - super(ast); + super(ast, options); - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); this.members = new ErrorParametersDeclaration(ast.members, options); this.updateMetadata(this.members); diff --git a/src/slang-nodes/ErrorParameter.ts b/src/slang-nodes/ErrorParameter.ts index bca479f2e..97129c200 100644 --- a/src/slang-nodes/ErrorParameter.ts +++ b/src/slang-nodes/ErrorParameter.ts @@ -18,11 +18,11 @@ export class ErrorParameter extends SlangNode { name?: TerminalNode; constructor(ast: ast.ErrorParameter, options: ParserOptions) { - super(ast); + super(ast, options); this.typeName = extractVariant(new TypeName(ast.typeName, options)); if (ast.name) { - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); } this.updateMetadata(this.typeName); diff --git a/src/slang-nodes/ErrorParameters.ts b/src/slang-nodes/ErrorParameters.ts index 2db19415d..450b1556a 100644 --- a/src/slang-nodes/ErrorParameters.ts +++ b/src/slang-nodes/ErrorParameters.ts @@ -14,7 +14,7 @@ export class ErrorParameters extends SlangNode { items: ErrorParameter[]; constructor(ast: ast.ErrorParameters, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new ErrorParameter(item, options)); } diff --git a/src/slang-nodes/ErrorParametersDeclaration.ts b/src/slang-nodes/ErrorParametersDeclaration.ts index 36f7cbd61..ee57dceae 100644 --- a/src/slang-nodes/ErrorParametersDeclaration.ts +++ b/src/slang-nodes/ErrorParametersDeclaration.ts @@ -16,7 +16,7 @@ export class ErrorParametersDeclaration extends SlangNode { ast: ast.ErrorParametersDeclaration, options: ParserOptions ) { - super(ast); + super(ast, options); this.parameters = new ErrorParameters(ast.parameters, options); diff --git a/src/slang-nodes/EventDefinition.ts b/src/slang-nodes/EventDefinition.ts index 3d3368ed3..a2791d328 100644 --- a/src/slang-nodes/EventDefinition.ts +++ b/src/slang-nodes/EventDefinition.ts @@ -18,9 +18,9 @@ export class EventDefinition extends SlangNode { anonymousKeyword?: string; constructor(ast: ast.EventDefinition, options: ParserOptions) { - super(ast); + super(ast, options); - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); this.parameters = new EventParametersDeclaration(ast.parameters, options); this.anonymousKeyword = ast.anonymousKeyword?.unparse(); diff --git a/src/slang-nodes/EventParameter.ts b/src/slang-nodes/EventParameter.ts index 4e49d652b..42e11ff1b 100644 --- a/src/slang-nodes/EventParameter.ts +++ b/src/slang-nodes/EventParameter.ts @@ -20,12 +20,12 @@ export class EventParameter extends SlangNode { name?: TerminalNode; constructor(ast: ast.EventParameter, options: ParserOptions) { - super(ast); + super(ast, options); this.typeName = extractVariant(new TypeName(ast.typeName, options)); this.indexedKeyword = ast.indexedKeyword?.unparse(); if (ast.name) { - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); } this.updateMetadata(this.typeName); diff --git a/src/slang-nodes/EventParameters.ts b/src/slang-nodes/EventParameters.ts index f546f9282..ea6d08805 100644 --- a/src/slang-nodes/EventParameters.ts +++ b/src/slang-nodes/EventParameters.ts @@ -14,7 +14,7 @@ export class EventParameters extends SlangNode { items: EventParameter[]; constructor(ast: ast.EventParameters, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new EventParameter(item, options)); } diff --git a/src/slang-nodes/EventParametersDeclaration.ts b/src/slang-nodes/EventParametersDeclaration.ts index f8f055bef..b69ada72e 100644 --- a/src/slang-nodes/EventParametersDeclaration.ts +++ b/src/slang-nodes/EventParametersDeclaration.ts @@ -16,7 +16,7 @@ export class EventParametersDeclaration extends SlangNode { ast: ast.EventParametersDeclaration, options: ParserOptions ) { - super(ast); + super(ast, options); this.parameters = new EventParameters(ast.parameters, options); diff --git a/src/slang-nodes/ExperimentalFeature.ts b/src/slang-nodes/ExperimentalFeature.ts index b07563fa2..0866255e6 100644 --- a/src/slang-nodes/ExperimentalFeature.ts +++ b/src/slang-nodes/ExperimentalFeature.ts @@ -16,11 +16,11 @@ export class ExperimentalFeature extends SlangNode { variant: StringLiteral | TerminalNode; constructor(ast: ast.ExperimentalFeature, options: ParserOptions) { - 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 StringLiteral(variant, options); diff --git a/src/slang-nodes/ExperimentalPragma.ts b/src/slang-nodes/ExperimentalPragma.ts index 513996419..975d83a76 100644 --- a/src/slang-nodes/ExperimentalPragma.ts +++ b/src/slang-nodes/ExperimentalPragma.ts @@ -14,7 +14,7 @@ export class ExperimentalPragma extends SlangNode { feature: ExperimentalFeature['variant']; constructor(ast: ast.ExperimentalPragma, options: ParserOptions) { - super(ast); + super(ast, options); this.feature = extractVariant( new ExperimentalFeature(ast.feature, options) diff --git a/src/slang-nodes/ExponentiationExpression.ts b/src/slang-nodes/ExponentiationExpression.ts index b0f862c77..a69273396 100644 --- a/src/slang-nodes/ExponentiationExpression.ts +++ b/src/slang-nodes/ExponentiationExpression.ts @@ -50,7 +50,7 @@ export class ExponentiationExpression extends SlangNode { ast: ast.ExponentiationExpression, options: ParserOptions ) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/Expression.ts b/src/slang-nodes/Expression.ts index 7d9468628..5bff5adf1 100644 --- a/src/slang-nodes/Expression.ts +++ b/src/slang-nodes/Expression.ts @@ -111,16 +111,16 @@ function createNonterminalVariant( return new ArrayExpression(variant, options); } if (variant instanceof ast.HexNumberExpression) { - return new HexNumberExpression(variant); + return new HexNumberExpression(variant, options); } if (variant instanceof ast.DecimalNumberExpression) { - return new DecimalNumberExpression(variant); + return new DecimalNumberExpression(variant, options); } if (variant instanceof ast.StringExpression) { return extractVariant(new StringExpression(variant, options)); } if (variant instanceof ast.ElementaryType) { - return extractVariant(new ElementaryType(variant)); + return extractVariant(new ElementaryType(variant, options)); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -160,11 +160,11 @@ export class Expression extends SlangNode { | TerminalNode; constructor(ast: ast.Expression, options: ParserOptions) { - 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 = createNonterminalVariant(variant, options); diff --git a/src/slang-nodes/ExpressionStatement.ts b/src/slang-nodes/ExpressionStatement.ts index 021a399d8..e335f3dad 100644 --- a/src/slang-nodes/ExpressionStatement.ts +++ b/src/slang-nodes/ExpressionStatement.ts @@ -14,7 +14,7 @@ export class ExpressionStatement extends SlangNode { expression: Expression['variant']; constructor(ast: ast.ExpressionStatement, options: ParserOptions) { - super(ast); + super(ast, options); this.expression = extractVariant(new Expression(ast.expression, options)); diff --git a/src/slang-nodes/FallbackFunctionAttribute.ts b/src/slang-nodes/FallbackFunctionAttribute.ts index 735d47ab8..8cb7be13c 100644 --- a/src/slang-nodes/FallbackFunctionAttribute.ts +++ b/src/slang-nodes/FallbackFunctionAttribute.ts @@ -19,7 +19,7 @@ function createNonterminalVariant( return new ModifierInvocation(variant, options); } if (variant instanceof ast.OverrideSpecifier) { - return new OverrideSpecifier(variant); + return new OverrideSpecifier(variant, options); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -34,11 +34,11 @@ export class FallbackFunctionAttribute extends SlangNode { ast: ast.FallbackFunctionAttribute, options: ParserOptions ) { - 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 = createNonterminalVariant(variant, options); diff --git a/src/slang-nodes/FallbackFunctionAttributes.ts b/src/slang-nodes/FallbackFunctionAttributes.ts index c603b6ab0..9c3320229 100644 --- a/src/slang-nodes/FallbackFunctionAttributes.ts +++ b/src/slang-nodes/FallbackFunctionAttributes.ts @@ -21,7 +21,7 @@ export class FallbackFunctionAttributes extends SlangNode { ast: ast.FallbackFunctionAttributes, options: ParserOptions ) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new FallbackFunctionAttribute(item, options)) diff --git a/src/slang-nodes/FallbackFunctionDefinition.ts b/src/slang-nodes/FallbackFunctionDefinition.ts index 500171d27..9e3f76042 100644 --- a/src/slang-nodes/FallbackFunctionDefinition.ts +++ b/src/slang-nodes/FallbackFunctionDefinition.ts @@ -27,7 +27,7 @@ export class FallbackFunctionDefinition extends SlangNode { ast: ast.FallbackFunctionDefinition, options: ParserOptions ) { - super(ast); + super(ast, options); this.parameters = new ParametersDeclaration(ast.parameters, options); this.attributes = new FallbackFunctionAttributes(ast.attributes, options); diff --git a/src/slang-nodes/ForStatement.ts b/src/slang-nodes/ForStatement.ts index 4dc772089..0ee016f62 100644 --- a/src/slang-nodes/ForStatement.ts +++ b/src/slang-nodes/ForStatement.ts @@ -28,7 +28,7 @@ export class ForStatement extends SlangNode { body: Statement['variant']; constructor(ast: ast.ForStatement, options: ParserOptions) { - super(ast); + super(ast, options); this.initialization = extractVariant( new ForStatementInitialization(ast.initialization, options) diff --git a/src/slang-nodes/ForStatementCondition.ts b/src/slang-nodes/ForStatementCondition.ts index 0c75d9c94..6d36745f2 100644 --- a/src/slang-nodes/ForStatementCondition.ts +++ b/src/slang-nodes/ForStatementCondition.ts @@ -16,11 +16,11 @@ export class ForStatementCondition extends SlangNode { variant: ExpressionStatement | TerminalNode; constructor(ast: ast.ForStatementCondition, options: ParserOptions) { - 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 ExpressionStatement(variant, options); diff --git a/src/slang-nodes/ForStatementInitialization.ts b/src/slang-nodes/ForStatementInitialization.ts index 94174c051..e5afe8d3a 100644 --- a/src/slang-nodes/ForStatementInitialization.ts +++ b/src/slang-nodes/ForStatementInitialization.ts @@ -45,11 +45,11 @@ export class ForStatementInitialization extends SlangNode { ast: ast.ForStatementInitialization, options: ParserOptions ) { - 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 = createNonterminalVariant(variant, options); diff --git a/src/slang-nodes/FunctionAttribute.ts b/src/slang-nodes/FunctionAttribute.ts index 689dd070a..c2dda8753 100644 --- a/src/slang-nodes/FunctionAttribute.ts +++ b/src/slang-nodes/FunctionAttribute.ts @@ -19,7 +19,7 @@ function createNonterminalVariant( return new ModifierInvocation(variant, options); } if (variant instanceof ast.OverrideSpecifier) { - return new OverrideSpecifier(variant); + return new OverrideSpecifier(variant, options); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -31,11 +31,11 @@ export class FunctionAttribute extends SlangNode { variant: ModifierInvocation | OverrideSpecifier | TerminalNode; constructor(ast: ast.FunctionAttribute, options: ParserOptions) { - 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 = createNonterminalVariant(variant, options); diff --git a/src/slang-nodes/FunctionAttributes.ts b/src/slang-nodes/FunctionAttributes.ts index 61eb54bdb..72f289c33 100644 --- a/src/slang-nodes/FunctionAttributes.ts +++ b/src/slang-nodes/FunctionAttributes.ts @@ -18,7 +18,7 @@ export class FunctionAttributes extends SlangNode { items: FunctionAttribute['variant'][]; constructor(ast: ast.FunctionAttributes, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new FunctionAttribute(item, options)) diff --git a/src/slang-nodes/FunctionBody.ts b/src/slang-nodes/FunctionBody.ts index 364a0923f..057aa3928 100644 --- a/src/slang-nodes/FunctionBody.ts +++ b/src/slang-nodes/FunctionBody.ts @@ -16,11 +16,11 @@ export class FunctionBody extends SlangNode { variant: Block | TerminalNode; constructor(ast: ast.FunctionBody, options: ParserOptions) { - 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 Block(variant, options); diff --git a/src/slang-nodes/FunctionCallExpression.ts b/src/slang-nodes/FunctionCallExpression.ts index 4152289b6..a4d58e0de 100644 --- a/src/slang-nodes/FunctionCallExpression.ts +++ b/src/slang-nodes/FunctionCallExpression.ts @@ -25,7 +25,7 @@ export class FunctionCallExpression extends SlangNode { ast: ast.FunctionCallExpression, options: ParserOptions ) { - super(ast); + super(ast, options); this.operand = extractVariant(new Expression(ast.operand, options)); this.arguments = extractVariant( diff --git a/src/slang-nodes/FunctionDefinition.ts b/src/slang-nodes/FunctionDefinition.ts index a59d7afb9..b0516c65c 100644 --- a/src/slang-nodes/FunctionDefinition.ts +++ b/src/slang-nodes/FunctionDefinition.ts @@ -28,9 +28,9 @@ export class FunctionDefinition extends SlangNode { body: FunctionBody['variant']; constructor(ast: ast.FunctionDefinition, options: ParserOptions) { - super(ast); + super(ast, options); - this.name = extractVariant(new FunctionName(ast.name)); + this.name = extractVariant(new FunctionName(ast.name, options)); this.parameters = new ParametersDeclaration(ast.parameters, options); this.attributes = new FunctionAttributes(ast.attributes, options); if (ast.returns) { diff --git a/src/slang-nodes/FunctionName.ts b/src/slang-nodes/FunctionName.ts index 59cd6325d..f441a25a2 100644 --- a/src/slang-nodes/FunctionName.ts +++ b/src/slang-nodes/FunctionName.ts @@ -3,15 +3,17 @@ import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.d.ts'; export class FunctionName extends SlangNode { readonly kind = NonterminalKind.FunctionName; variant: TerminalNode; - constructor(ast: ast.FunctionName) { - super(ast); + constructor(ast: ast.FunctionName, options: ParserOptions) { + super(ast, options); - this.variant = new TerminalNode(ast.variant); + this.variant = new TerminalNode(ast.variant, options); } } diff --git a/src/slang-nodes/FunctionType.ts b/src/slang-nodes/FunctionType.ts index b384c7692..2a80c3215 100644 --- a/src/slang-nodes/FunctionType.ts +++ b/src/slang-nodes/FunctionType.ts @@ -20,10 +20,10 @@ export class FunctionType extends SlangNode { returns?: ReturnsDeclaration; constructor(ast: ast.FunctionType, options: ParserOptions) { - super(ast); + super(ast, options); this.parameters = new ParametersDeclaration(ast.parameters, options); - this.attributes = new FunctionTypeAttributes(ast.attributes); + this.attributes = new FunctionTypeAttributes(ast.attributes, options); if (ast.returns) { this.returns = new ReturnsDeclaration(ast.returns, options); } diff --git a/src/slang-nodes/FunctionTypeAttribute.ts b/src/slang-nodes/FunctionTypeAttribute.ts index 5e0b2d18d..f2dc2726d 100644 --- a/src/slang-nodes/FunctionTypeAttribute.ts +++ b/src/slang-nodes/FunctionTypeAttribute.ts @@ -3,15 +3,17 @@ import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.d.ts'; export class FunctionTypeAttribute extends SlangNode { readonly kind = NonterminalKind.FunctionTypeAttribute; variant: TerminalNode; - constructor(ast: ast.FunctionTypeAttribute) { - super(ast); + constructor(ast: ast.FunctionTypeAttribute, options: ParserOptions) { + super(ast, options); - this.variant = new TerminalNode(ast.variant); + this.variant = new TerminalNode(ast.variant, options); } } diff --git a/src/slang-nodes/FunctionTypeAttributes.ts b/src/slang-nodes/FunctionTypeAttributes.ts index aa31d9ac4..294b81ca4 100644 --- a/src/slang-nodes/FunctionTypeAttributes.ts +++ b/src/slang-nodes/FunctionTypeAttributes.ts @@ -6,8 +6,9 @@ import { SlangNode } from './SlangNode.js'; import { FunctionTypeAttribute } from './FunctionTypeAttribute.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'; const { line } = doc.builders; @@ -16,11 +17,14 @@ export class FunctionTypeAttributes extends SlangNode { items: FunctionTypeAttribute['variant'][]; - constructor(ast: ast.FunctionTypeAttributes) { - super(ast, true); + constructor( + ast: ast.FunctionTypeAttributes, + options: ParserOptions + ) { + super(ast, options, true); this.items = ast.items.map((item) => - extractVariant(new FunctionTypeAttribute(item)) + extractVariant(new FunctionTypeAttribute(item, options)) ); this.items.sort(sortFunctionAttributes); diff --git a/src/slang-nodes/HexNumberExpression.ts b/src/slang-nodes/HexNumberExpression.ts index 1308f9c5f..5e482eb8b 100644 --- a/src/slang-nodes/HexNumberExpression.ts +++ b/src/slang-nodes/HexNumberExpression.ts @@ -4,8 +4,9 @@ import { SlangNode } from './SlangNode.js'; import { NumberUnit } from './NumberUnit.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 HexNumberExpression extends SlangNode { readonly kind = NonterminalKind.HexNumberExpression; @@ -14,12 +15,12 @@ export class HexNumberExpression extends SlangNode { unit?: NumberUnit; - constructor(ast: ast.HexNumberExpression) { - super(ast); + constructor(ast: ast.HexNumberExpression, options: ParserOptions) { + super(ast, options); this.literal = ast.literal.unparse(); if (ast.unit) { - this.unit = new NumberUnit(ast.unit); + this.unit = new NumberUnit(ast.unit, options); } this.updateMetadata(this.unit); diff --git a/src/slang-nodes/HexStringLiteral.ts b/src/slang-nodes/HexStringLiteral.ts index d2f0b767c..e5e3dd3e9 100644 --- a/src/slang-nodes/HexStringLiteral.ts +++ b/src/slang-nodes/HexStringLiteral.ts @@ -12,7 +12,7 @@ export class HexStringLiteral extends SlangNode { variant: string; constructor(ast: ast.HexStringLiteral, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = ast.variant.unparse(); diff --git a/src/slang-nodes/HexStringLiterals.ts b/src/slang-nodes/HexStringLiterals.ts index f5ba16031..73f3e0673 100644 --- a/src/slang-nodes/HexStringLiterals.ts +++ b/src/slang-nodes/HexStringLiterals.ts @@ -16,7 +16,7 @@ export class HexStringLiterals extends SlangNode { items: HexStringLiteral[]; constructor(ast: ast.HexStringLiterals, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new HexStringLiteral(item, options)); } diff --git a/src/slang-nodes/IdentifierPath.ts b/src/slang-nodes/IdentifierPath.ts index 603341e41..37f38353d 100644 --- a/src/slang-nodes/IdentifierPath.ts +++ b/src/slang-nodes/IdentifierPath.ts @@ -4,8 +4,9 @@ import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.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'; const { join } = doc.builders; @@ -14,10 +15,10 @@ export class IdentifierPath extends SlangNode { items: TerminalNode[]; - constructor(ast: ast.IdentifierPath) { - super(ast); + constructor(ast: ast.IdentifierPath, options: ParserOptions) { + super(ast, options); - this.items = ast.items.map((item) => new TerminalNode(item)); + this.items = ast.items.map((item) => new TerminalNode(item, options)); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slang-nodes/IfStatement.ts b/src/slang-nodes/IfStatement.ts index 7c68d1175..7d962f3d8 100644 --- a/src/slang-nodes/IfStatement.ts +++ b/src/slang-nodes/IfStatement.ts @@ -26,7 +26,7 @@ export class IfStatement extends SlangNode { elseBranch?: ElseBranch; constructor(ast: ast.IfStatement, options: ParserOptions) { - super(ast); + super(ast, options); this.condition = extractVariant(new Expression(ast.condition, options)); this.body = extractVariant(new Statement(ast.body, options)); diff --git a/src/slang-nodes/ImportAlias.ts b/src/slang-nodes/ImportAlias.ts index 41784d029..510e74f20 100644 --- a/src/slang-nodes/ImportAlias.ts +++ b/src/slang-nodes/ImportAlias.ts @@ -3,18 +3,19 @@ import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.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 ImportAlias extends SlangNode { readonly kind = NonterminalKind.ImportAlias; identifier: TerminalNode; - constructor(ast: ast.ImportAlias) { - super(ast); + constructor(ast: ast.ImportAlias, options: ParserOptions) { + super(ast, options); - this.identifier = new TerminalNode(ast.identifier); + this.identifier = new TerminalNode(ast.identifier, options); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slang-nodes/ImportClause.ts b/src/slang-nodes/ImportClause.ts index fb5ff8a92..206520e5a 100644 --- a/src/slang-nodes/ImportClause.ts +++ b/src/slang-nodes/ImportClause.ts @@ -31,7 +31,7 @@ export class ImportClause extends SlangNode { variant: PathImport | NamedImport | ImportDeconstruction; constructor(ast: ast.ImportClause, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/ImportDeconstruction.ts b/src/slang-nodes/ImportDeconstruction.ts index f72fb2d70..b2fa9fc76 100644 --- a/src/slang-nodes/ImportDeconstruction.ts +++ b/src/slang-nodes/ImportDeconstruction.ts @@ -16,9 +16,9 @@ export class ImportDeconstruction extends SlangNode { path: StringLiteral; constructor(ast: ast.ImportDeconstruction, options: ParserOptions) { - super(ast); + super(ast, options); - this.symbols = new ImportDeconstructionSymbols(ast.symbols); + this.symbols = new ImportDeconstructionSymbols(ast.symbols, options); this.path = new StringLiteral(ast.path, options); this.updateMetadata(this.symbols, this.path); diff --git a/src/slang-nodes/ImportDeconstructionSymbol.ts b/src/slang-nodes/ImportDeconstructionSymbol.ts index a2764196e..3cbc7ce60 100644 --- a/src/slang-nodes/ImportDeconstructionSymbol.ts +++ b/src/slang-nodes/ImportDeconstructionSymbol.ts @@ -4,8 +4,9 @@ import { TerminalNode } from './TerminalNode.js'; import { ImportAlias } from './ImportAlias.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 ImportDeconstructionSymbol extends SlangNode { readonly kind = NonterminalKind.ImportDeconstructionSymbol; @@ -14,12 +15,15 @@ export class ImportDeconstructionSymbol extends SlangNode { alias?: ImportAlias; - constructor(ast: ast.ImportDeconstructionSymbol) { - super(ast); + constructor( + ast: ast.ImportDeconstructionSymbol, + options: ParserOptions + ) { + super(ast, options); - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); if (ast.alias) { - this.alias = new ImportAlias(ast.alias); + this.alias = new ImportAlias(ast.alias, options); } this.updateMetadata(this.alias); diff --git a/src/slang-nodes/ImportDeconstructionSymbols.ts b/src/slang-nodes/ImportDeconstructionSymbols.ts index d80b0a1e9..08e15f56d 100644 --- a/src/slang-nodes/ImportDeconstructionSymbols.ts +++ b/src/slang-nodes/ImportDeconstructionSymbols.ts @@ -17,10 +17,15 @@ export class ImportDeconstructionSymbols extends SlangNode { items: ImportDeconstructionSymbol[]; - constructor(ast: ast.ImportDeconstructionSymbols) { - super(ast, true); + constructor( + ast: ast.ImportDeconstructionSymbols, + options: ParserOptions + ) { + super(ast, options, true); - this.items = ast.items.map((item) => new ImportDeconstructionSymbol(item)); + this.items = ast.items.map( + (item) => new ImportDeconstructionSymbol(item, options) + ); } print( diff --git a/src/slang-nodes/ImportDirective.ts b/src/slang-nodes/ImportDirective.ts index 0f89c1600..6e4fd9315 100644 --- a/src/slang-nodes/ImportDirective.ts +++ b/src/slang-nodes/ImportDirective.ts @@ -14,7 +14,7 @@ export class ImportDirective extends SlangNode { clause: ImportClause['variant']; constructor(ast: ast.ImportDirective, options: ParserOptions) { - super(ast); + super(ast, options); this.clause = extractVariant(new ImportClause(ast.clause, options)); diff --git a/src/slang-nodes/IndexAccessEnd.ts b/src/slang-nodes/IndexAccessEnd.ts index 59dcedf69..17221a326 100644 --- a/src/slang-nodes/IndexAccessEnd.ts +++ b/src/slang-nodes/IndexAccessEnd.ts @@ -14,7 +14,7 @@ export class IndexAccessEnd extends SlangNode { end?: Expression['variant']; constructor(ast: ast.IndexAccessEnd, options: ParserOptions) { - super(ast); + super(ast, options); if (ast.end) { this.end = extractVariant(new Expression(ast.end, options)); diff --git a/src/slang-nodes/IndexAccessExpression.ts b/src/slang-nodes/IndexAccessExpression.ts index aa8f04086..1fa44dfd0 100644 --- a/src/slang-nodes/IndexAccessExpression.ts +++ b/src/slang-nodes/IndexAccessExpression.ts @@ -25,7 +25,7 @@ export class IndexAccessExpression extends SlangNode { end?: IndexAccessEnd; constructor(ast: ast.IndexAccessExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.operand = extractVariant(new Expression(ast.operand, options)); if (ast.start) { diff --git a/src/slang-nodes/InequalityExpression.ts b/src/slang-nodes/InequalityExpression.ts index a24b02886..2baa8b46b 100644 --- a/src/slang-nodes/InequalityExpression.ts +++ b/src/slang-nodes/InequalityExpression.ts @@ -28,7 +28,7 @@ export class InequalityExpression extends SlangNode { rightOperand: Expression['variant']; constructor(ast: ast.InequalityExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/InheritanceSpecifier.ts b/src/slang-nodes/InheritanceSpecifier.ts index 9adc27e23..66313716b 100644 --- a/src/slang-nodes/InheritanceSpecifier.ts +++ b/src/slang-nodes/InheritanceSpecifier.ts @@ -13,7 +13,7 @@ export class InheritanceSpecifier extends SlangNode { types: InheritanceTypes; constructor(ast: ast.InheritanceSpecifier, options: ParserOptions) { - super(ast); + super(ast, options); this.types = new InheritanceTypes(ast.types, options); diff --git a/src/slang-nodes/InheritanceType.ts b/src/slang-nodes/InheritanceType.ts index 55510600e..18e968df7 100644 --- a/src/slang-nodes/InheritanceType.ts +++ b/src/slang-nodes/InheritanceType.ts @@ -17,9 +17,9 @@ export class InheritanceType extends SlangNode { arguments?: ArgumentsDeclaration['variant']; constructor(ast: ast.InheritanceType, options: ParserOptions) { - super(ast); + super(ast, options); - this.typeName = new IdentifierPath(ast.typeName); + this.typeName = new IdentifierPath(ast.typeName, options); if (ast.arguments) { this.arguments = extractVariant( new ArgumentsDeclaration(ast.arguments, options) diff --git a/src/slang-nodes/InheritanceTypes.ts b/src/slang-nodes/InheritanceTypes.ts index 82bddaf8d..619e66c29 100644 --- a/src/slang-nodes/InheritanceTypes.ts +++ b/src/slang-nodes/InheritanceTypes.ts @@ -17,7 +17,7 @@ export class InheritanceTypes extends SlangNode { items: InheritanceType[]; constructor(ast: ast.InheritanceTypes, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new InheritanceType(item, options)); } diff --git a/src/slang-nodes/InterfaceDefinition.ts b/src/slang-nodes/InterfaceDefinition.ts index 5b7a9fb4b..7eb4906d1 100644 --- a/src/slang-nodes/InterfaceDefinition.ts +++ b/src/slang-nodes/InterfaceDefinition.ts @@ -22,9 +22,9 @@ export class InterfaceDefinition extends SlangNode { members: InterfaceMembers; constructor(ast: ast.InterfaceDefinition, options: ParserOptions) { - super(ast); + super(ast, options); - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); if (ast.inheritance) { this.inheritance = new InheritanceSpecifier(ast.inheritance, options); } diff --git a/src/slang-nodes/InterfaceMembers.ts b/src/slang-nodes/InterfaceMembers.ts index d05d42f93..00dbe28d5 100644 --- a/src/slang-nodes/InterfaceMembers.ts +++ b/src/slang-nodes/InterfaceMembers.ts @@ -19,7 +19,7 @@ export class InterfaceMembers extends SlangNode { items: ContractMember['variant'][]; constructor(ast: ast.InterfaceMembers, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new ContractMember(item, options)) diff --git a/src/slang-nodes/LibraryDefinition.ts b/src/slang-nodes/LibraryDefinition.ts index 8590c355f..32f8887cb 100644 --- a/src/slang-nodes/LibraryDefinition.ts +++ b/src/slang-nodes/LibraryDefinition.ts @@ -19,9 +19,9 @@ export class LibraryDefinition extends SlangNode { members: LibraryMembers; constructor(ast: ast.LibraryDefinition, options: ParserOptions) { - super(ast); + super(ast, options); - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); this.members = new LibraryMembers(ast.members, options); this.updateMetadata(this.members); diff --git a/src/slang-nodes/LibraryMembers.ts b/src/slang-nodes/LibraryMembers.ts index 7b61ea783..15549eda1 100644 --- a/src/slang-nodes/LibraryMembers.ts +++ b/src/slang-nodes/LibraryMembers.ts @@ -19,7 +19,7 @@ export class LibraryMembers extends SlangNode { items: ContractMember['variant'][]; constructor(ast: ast.LibraryMembers, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new ContractMember(item, options)) diff --git a/src/slang-nodes/MappingKey.ts b/src/slang-nodes/MappingKey.ts index 9c8248159..a1fd86a37 100644 --- a/src/slang-nodes/MappingKey.ts +++ b/src/slang-nodes/MappingKey.ts @@ -6,8 +6,9 @@ import { MappingKeyType } from './MappingKeyType.js'; import { TerminalNode } from './TerminalNode.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 MappingKey extends SlangNode { readonly kind = NonterminalKind.MappingKey; @@ -16,12 +17,12 @@ export class MappingKey extends SlangNode { name?: TerminalNode; - constructor(ast: ast.MappingKey) { - super(ast); + constructor(ast: ast.MappingKey, options: ParserOptions) { + super(ast, options); - this.keyType = extractVariant(new MappingKeyType(ast.keyType)); + this.keyType = extractVariant(new MappingKeyType(ast.keyType, options)); if (ast.name) { - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); } this.updateMetadata(this.keyType); diff --git a/src/slang-nodes/MappingKeyType.ts b/src/slang-nodes/MappingKeyType.ts index 06f1087e5..c6a1eff92 100644 --- a/src/slang-nodes/MappingKeyType.ts +++ b/src/slang-nodes/MappingKeyType.ts @@ -5,14 +5,18 @@ import { SlangNode } from './SlangNode.js'; import { ElementaryType } from './ElementaryType.js'; import { IdentifierPath } from './IdentifierPath.js'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.d.ts'; + function createNonterminalVariant( - variant: ast.MappingKeyType['variant'] + variant: ast.MappingKeyType['variant'], + options: ParserOptions ): MappingKeyType['variant'] { if (variant instanceof ast.ElementaryType) { - return extractVariant(new ElementaryType(variant)); + return extractVariant(new ElementaryType(variant, options)); } if (variant instanceof ast.IdentifierPath) { - return new IdentifierPath(variant); + return new IdentifierPath(variant, options); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -23,10 +27,10 @@ export class MappingKeyType extends SlangNode { variant: ElementaryType['variant'] | IdentifierPath; - constructor(ast: ast.MappingKeyType) { - super(ast); + constructor(ast: ast.MappingKeyType, options: ParserOptions) { + super(ast, options); - this.variant = createNonterminalVariant(ast.variant); + this.variant = createNonterminalVariant(ast.variant, options); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/MappingType.ts b/src/slang-nodes/MappingType.ts index ba5fa8a87..fff5ae752 100644 --- a/src/slang-nodes/MappingType.ts +++ b/src/slang-nodes/MappingType.ts @@ -16,9 +16,9 @@ export class MappingType extends SlangNode { valueType: MappingValue; constructor(ast: ast.MappingType, options: ParserOptions) { - super(ast); + super(ast, options); - this.keyType = new MappingKey(ast.keyType); + this.keyType = new MappingKey(ast.keyType, options); this.valueType = new MappingValue(ast.valueType, options); this.updateMetadata(this.keyType, this.valueType); diff --git a/src/slang-nodes/MappingValue.ts b/src/slang-nodes/MappingValue.ts index e22917a21..2f47c7350 100644 --- a/src/slang-nodes/MappingValue.ts +++ b/src/slang-nodes/MappingValue.ts @@ -18,11 +18,11 @@ export class MappingValue extends SlangNode { name?: TerminalNode; constructor(ast: ast.MappingValue, options: ParserOptions) { - super(ast); + super(ast, options); this.typeName = extractVariant(new TypeName(ast.typeName, options)); if (ast.name) { - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); } this.updateMetadata(this.typeName); diff --git a/src/slang-nodes/MemberAccessExpression.ts b/src/slang-nodes/MemberAccessExpression.ts index 42bd7eb38..29bbfd879 100644 --- a/src/slang-nodes/MemberAccessExpression.ts +++ b/src/slang-nodes/MemberAccessExpression.ts @@ -123,10 +123,10 @@ export class MemberAccessExpression extends SlangNode { ast: ast.MemberAccessExpression, options: ParserOptions ) { - super(ast); + super(ast, options); this.operand = extractVariant(new Expression(ast.operand, options)); - this.member = new TerminalNode(ast.member); + this.member = new TerminalNode(ast.member, options); this.updateMetadata(this.operand); } diff --git a/src/slang-nodes/ModifierAttribute.ts b/src/slang-nodes/ModifierAttribute.ts index bc4310c34..c7cda12c9 100644 --- a/src/slang-nodes/ModifierAttribute.ts +++ b/src/slang-nodes/ModifierAttribute.ts @@ -7,21 +7,23 @@ import { OverrideSpecifier } from './OverrideSpecifier.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.d.ts'; export class ModifierAttribute extends SlangNode { readonly kind = NonterminalKind.ModifierAttribute; variant: OverrideSpecifier | TerminalNode; - constructor(ast: ast.ModifierAttribute) { - super(ast); + constructor(ast: ast.ModifierAttribute, options: ParserOptions) { + 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 OverrideSpecifier(variant); + this.variant = new OverrideSpecifier(variant, options); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ModifierAttributes.ts b/src/slang-nodes/ModifierAttributes.ts index aa8f565c2..86532fb8e 100644 --- a/src/slang-nodes/ModifierAttributes.ts +++ b/src/slang-nodes/ModifierAttributes.ts @@ -6,8 +6,9 @@ import { SlangNode } from './SlangNode.js'; import { ModifierAttribute } from './ModifierAttribute.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'; const { line } = doc.builders; @@ -16,11 +17,11 @@ export class ModifierAttributes extends SlangNode { items: ModifierAttribute['variant'][]; - constructor(ast: ast.ModifierAttributes) { - super(ast, true); + constructor(ast: ast.ModifierAttributes, options: ParserOptions) { + super(ast, options, true); this.items = ast.items.map((item) => - extractVariant(new ModifierAttribute(item)) + extractVariant(new ModifierAttribute(item, options)) ); this.items.sort(sortFunctionAttributes); diff --git a/src/slang-nodes/ModifierDefinition.ts b/src/slang-nodes/ModifierDefinition.ts index d668f397c..5de6d8424 100644 --- a/src/slang-nodes/ModifierDefinition.ts +++ b/src/slang-nodes/ModifierDefinition.ts @@ -25,13 +25,13 @@ export class ModifierDefinition extends SlangNode { body: FunctionBody['variant']; constructor(ast: ast.ModifierDefinition, options: ParserOptions) { - super(ast); + super(ast, options); - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); if (ast.parameters) { this.parameters = new ParametersDeclaration(ast.parameters, options); } - this.attributes = new ModifierAttributes(ast.attributes); + this.attributes = new ModifierAttributes(ast.attributes, options); this.body = extractVariant(new FunctionBody(ast.body, options)); this.updateMetadata(this.parameters, this.attributes, this.body); diff --git a/src/slang-nodes/ModifierInvocation.ts b/src/slang-nodes/ModifierInvocation.ts index 378a43e34..01adc8629 100644 --- a/src/slang-nodes/ModifierInvocation.ts +++ b/src/slang-nodes/ModifierInvocation.ts @@ -17,9 +17,9 @@ export class ModifierInvocation extends SlangNode { arguments?: ArgumentsDeclaration['variant']; constructor(ast: ast.ModifierInvocation, options: ParserOptions) { - super(ast); + super(ast, options); - this.name = new IdentifierPath(ast.name); + this.name = new IdentifierPath(ast.name, options); if (ast.arguments) { this.arguments = extractVariant( new ArgumentsDeclaration(ast.arguments, options) diff --git a/src/slang-nodes/MultiplicativeExpression.ts b/src/slang-nodes/MultiplicativeExpression.ts index 551f4fcd4..aa641181d 100644 --- a/src/slang-nodes/MultiplicativeExpression.ts +++ b/src/slang-nodes/MultiplicativeExpression.ts @@ -42,7 +42,7 @@ export class MultiplicativeExpression extends SlangNode { ast: ast.MultiplicativeExpression, options: ParserOptions ) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/NamedArgument.ts b/src/slang-nodes/NamedArgument.ts index 70e030578..a31daa75c 100644 --- a/src/slang-nodes/NamedArgument.ts +++ b/src/slang-nodes/NamedArgument.ts @@ -17,9 +17,9 @@ export class NamedArgument extends SlangNode { value: Expression['variant']; constructor(ast: ast.NamedArgument, options: ParserOptions) { - super(ast); + super(ast, 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.value); diff --git a/src/slang-nodes/NamedArgumentGroup.ts b/src/slang-nodes/NamedArgumentGroup.ts index 1441edc2f..0e63397d4 100644 --- a/src/slang-nodes/NamedArgumentGroup.ts +++ b/src/slang-nodes/NamedArgumentGroup.ts @@ -13,7 +13,7 @@ export class NamedArgumentGroup extends SlangNode { arguments: NamedArguments; constructor(ast: ast.NamedArgumentGroup, options: ParserOptions) { - super(ast); + super(ast, options); this.arguments = new NamedArguments(ast.arguments, options); diff --git a/src/slang-nodes/NamedArguments.ts b/src/slang-nodes/NamedArguments.ts index 316ce49a1..c802346a1 100644 --- a/src/slang-nodes/NamedArguments.ts +++ b/src/slang-nodes/NamedArguments.ts @@ -17,7 +17,7 @@ export class NamedArguments extends SlangNode { items: NamedArgument[]; constructor(ast: ast.NamedArguments, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new NamedArgument(item, options)); } diff --git a/src/slang-nodes/NamedArgumentsDeclaration.ts b/src/slang-nodes/NamedArgumentsDeclaration.ts index be06eb4c7..7a16c11b9 100644 --- a/src/slang-nodes/NamedArgumentsDeclaration.ts +++ b/src/slang-nodes/NamedArgumentsDeclaration.ts @@ -16,7 +16,7 @@ export class NamedArgumentsDeclaration extends SlangNode { ast: ast.NamedArgumentsDeclaration, options: ParserOptions ) { - super(ast); + super(ast, options); if (ast.arguments) { this.arguments = new NamedArgumentGroup(ast.arguments, options); diff --git a/src/slang-nodes/NamedImport.ts b/src/slang-nodes/NamedImport.ts index d03a3f47f..79305244f 100644 --- a/src/slang-nodes/NamedImport.ts +++ b/src/slang-nodes/NamedImport.ts @@ -16,9 +16,9 @@ export class NamedImport extends SlangNode { path: StringLiteral; constructor(ast: ast.NamedImport, options: ParserOptions) { - super(ast); + super(ast, options); - this.alias = new ImportAlias(ast.alias); + this.alias = new ImportAlias(ast.alias, options); this.path = new StringLiteral(ast.path, options); this.updateMetadata(this.alias, this.path); diff --git a/src/slang-nodes/NewExpression.ts b/src/slang-nodes/NewExpression.ts index e022c17fd..fb69eb4a6 100644 --- a/src/slang-nodes/NewExpression.ts +++ b/src/slang-nodes/NewExpression.ts @@ -14,7 +14,7 @@ export class NewExpression extends SlangNode { typeName: TypeName['variant']; constructor(ast: ast.NewExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.typeName = extractVariant(new TypeName(ast.typeName, options)); diff --git a/src/slang-nodes/NumberUnit.ts b/src/slang-nodes/NumberUnit.ts index 6bfb73f81..b66b7a1bc 100644 --- a/src/slang-nodes/NumberUnit.ts +++ b/src/slang-nodes/NumberUnit.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 NumberUnit extends SlangNode { readonly kind = NonterminalKind.NumberUnit; variant: string; - constructor(ast: ast.NumberUnit) { - super(ast); + constructor(ast: ast.NumberUnit, options: ParserOptions) { + super(ast, options); this.variant = ast.variant.unparse(); } diff --git a/src/slang-nodes/OrExpression.ts b/src/slang-nodes/OrExpression.ts index a47872e92..05c530a4b 100644 --- a/src/slang-nodes/OrExpression.ts +++ b/src/slang-nodes/OrExpression.ts @@ -22,7 +22,7 @@ export class OrExpression extends SlangNode { rightOperand: Expression['variant']; constructor(ast: ast.OrExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/OverridePaths.ts b/src/slang-nodes/OverridePaths.ts index 6f8e328b0..d7685461c 100644 --- a/src/slang-nodes/OverridePaths.ts +++ b/src/slang-nodes/OverridePaths.ts @@ -4,18 +4,19 @@ import { SlangNode } from './SlangNode.js'; import { IdentifierPath } from './IdentifierPath.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 OverridePaths extends SlangNode { readonly kind = NonterminalKind.OverridePaths; items: IdentifierPath[]; - constructor(ast: ast.OverridePaths) { - super(ast, true); + constructor(ast: ast.OverridePaths, options: ParserOptions) { + super(ast, options, true); - this.items = ast.items.map((item) => new IdentifierPath(item)); + this.items = ast.items.map((item) => new IdentifierPath(item, options)); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slang-nodes/OverridePathsDeclaration.ts b/src/slang-nodes/OverridePathsDeclaration.ts index 8335f117f..20f41f6f4 100644 --- a/src/slang-nodes/OverridePathsDeclaration.ts +++ b/src/slang-nodes/OverridePathsDeclaration.ts @@ -3,18 +3,22 @@ import { SlangNode } from './SlangNode.js'; import { OverridePaths } from './OverridePaths.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 OverridePathsDeclaration extends SlangNode { readonly kind = NonterminalKind.OverridePathsDeclaration; paths: OverridePaths; - constructor(ast: ast.OverridePathsDeclaration) { - super(ast); + constructor( + ast: ast.OverridePathsDeclaration, + options: ParserOptions + ) { + super(ast, options); - this.paths = new OverridePaths(ast.paths); + this.paths = new OverridePaths(ast.paths, options); this.updateMetadata(this.paths); } diff --git a/src/slang-nodes/OverrideSpecifier.ts b/src/slang-nodes/OverrideSpecifier.ts index fe6971762..ce47e76ab 100644 --- a/src/slang-nodes/OverrideSpecifier.ts +++ b/src/slang-nodes/OverrideSpecifier.ts @@ -3,19 +3,20 @@ import { SlangNode } from './SlangNode.js'; import { OverridePathsDeclaration } from './OverridePathsDeclaration.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 OverrideSpecifier extends SlangNode { readonly kind = NonterminalKind.OverrideSpecifier; overridden?: OverridePathsDeclaration; - constructor(ast: ast.OverrideSpecifier) { - super(ast); + constructor(ast: ast.OverrideSpecifier, options: ParserOptions) { + super(ast, options); if (ast.overridden) { - this.overridden = new OverridePathsDeclaration(ast.overridden); + this.overridden = new OverridePathsDeclaration(ast.overridden, options); } this.updateMetadata(this.overridden); diff --git a/src/slang-nodes/Parameter.ts b/src/slang-nodes/Parameter.ts index f2a6c3b9a..c7aa705c5 100644 --- a/src/slang-nodes/Parameter.ts +++ b/src/slang-nodes/Parameter.ts @@ -24,14 +24,14 @@ export class Parameter extends SlangNode { name?: TerminalNode; constructor(ast: ast.Parameter, options: ParserOptions) { - super(ast); + super(ast, options); this.typeName = extractVariant(new TypeName(ast.typeName, options)); if (ast.storageLocation) { - this.storageLocation = new StorageLocation(ast.storageLocation); + this.storageLocation = new StorageLocation(ast.storageLocation, options); } if (ast.name) { - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); } this.updateMetadata(this.typeName, this.storageLocation); diff --git a/src/slang-nodes/Parameters.ts b/src/slang-nodes/Parameters.ts index 186899fc5..be937ad82 100644 --- a/src/slang-nodes/Parameters.ts +++ b/src/slang-nodes/Parameters.ts @@ -16,7 +16,7 @@ export class Parameters extends SlangNode { items: Parameter[]; constructor(ast: ast.Parameters, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new Parameter(item, options)); } diff --git a/src/slang-nodes/ParametersDeclaration.ts b/src/slang-nodes/ParametersDeclaration.ts index e5ad58c55..e24dd18c9 100644 --- a/src/slang-nodes/ParametersDeclaration.ts +++ b/src/slang-nodes/ParametersDeclaration.ts @@ -13,7 +13,7 @@ export class ParametersDeclaration extends SlangNode { parameters: Parameters; constructor(ast: ast.ParametersDeclaration, options: ParserOptions) { - super(ast); + super(ast, options); this.parameters = new Parameters(ast.parameters, options); diff --git a/src/slang-nodes/PathImport.ts b/src/slang-nodes/PathImport.ts index 83a031a05..cde6b75ec 100644 --- a/src/slang-nodes/PathImport.ts +++ b/src/slang-nodes/PathImport.ts @@ -16,11 +16,11 @@ export class PathImport extends SlangNode { alias?: ImportAlias; constructor(ast: ast.PathImport, options: ParserOptions) { - super(ast); + super(ast, options); this.path = new StringLiteral(ast.path, options); if (ast.alias) { - this.alias = new ImportAlias(ast.alias); + this.alias = new ImportAlias(ast.alias, options); } this.updateMetadata(this.path, this.alias); diff --git a/src/slang-nodes/PositionalArguments.ts b/src/slang-nodes/PositionalArguments.ts index 01e1b3374..6f9b36180 100644 --- a/src/slang-nodes/PositionalArguments.ts +++ b/src/slang-nodes/PositionalArguments.ts @@ -17,7 +17,7 @@ export class PositionalArguments extends SlangNode { items: Expression['variant'][]; constructor(ast: ast.PositionalArguments, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new Expression(item, options)) diff --git a/src/slang-nodes/PositionalArgumentsDeclaration.ts b/src/slang-nodes/PositionalArgumentsDeclaration.ts index 8337c9e21..8c60f20f5 100644 --- a/src/slang-nodes/PositionalArgumentsDeclaration.ts +++ b/src/slang-nodes/PositionalArgumentsDeclaration.ts @@ -19,7 +19,7 @@ export class PositionalArgumentsDeclaration extends SlangNode { ast: ast.PositionalArgumentsDeclaration, options: ParserOptions ) { - super(ast); + super(ast, options); this.arguments = new PositionalArguments(ast.arguments, options); diff --git a/src/slang-nodes/PostfixExpression.ts b/src/slang-nodes/PostfixExpression.ts index 4a5060237..0a3e31696 100644 --- a/src/slang-nodes/PostfixExpression.ts +++ b/src/slang-nodes/PostfixExpression.ts @@ -16,7 +16,7 @@ export class PostfixExpression extends SlangNode { operator: string; constructor(ast: ast.PostfixExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.operand = extractVariant(new Expression(ast.operand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/Pragma.ts b/src/slang-nodes/Pragma.ts index 276555fe1..83e8a9ecd 100644 --- a/src/slang-nodes/Pragma.ts +++ b/src/slang-nodes/Pragma.ts @@ -13,13 +13,13 @@ function createNonterminalVariant( options: ParserOptions ): Pragma['variant'] { if (variant instanceof ast.AbicoderPragma) { - return new AbicoderPragma(variant); + return new AbicoderPragma(variant, options); } if (variant instanceof ast.ExperimentalPragma) { return new ExperimentalPragma(variant, options); } if (variant instanceof ast.VersionPragma) { - return new VersionPragma(variant); + return new VersionPragma(variant, options); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -31,7 +31,7 @@ export class Pragma extends SlangNode { variant: AbicoderPragma | ExperimentalPragma | VersionPragma; constructor(ast: ast.Pragma, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/PragmaDirective.ts b/src/slang-nodes/PragmaDirective.ts index 3a928e7f7..cb1435f0b 100644 --- a/src/slang-nodes/PragmaDirective.ts +++ b/src/slang-nodes/PragmaDirective.ts @@ -14,7 +14,7 @@ export class PragmaDirective extends SlangNode { pragma: Pragma['variant']; constructor(ast: ast.PragmaDirective, options: ParserOptions) { - super(ast); + super(ast, options); this.pragma = extractVariant(new Pragma(ast.pragma, options)); diff --git a/src/slang-nodes/PrefixExpression.ts b/src/slang-nodes/PrefixExpression.ts index ee398b57b..278ea8663 100644 --- a/src/slang-nodes/PrefixExpression.ts +++ b/src/slang-nodes/PrefixExpression.ts @@ -16,7 +16,7 @@ export class PrefixExpression extends SlangNode { operand: Expression['variant']; constructor(ast: ast.PrefixExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.operator = ast.operator.unparse(); this.operand = extractVariant(new Expression(ast.operand, options)); diff --git a/src/slang-nodes/ReceiveFunctionAttribute.ts b/src/slang-nodes/ReceiveFunctionAttribute.ts index 608df0894..06facdb8b 100644 --- a/src/slang-nodes/ReceiveFunctionAttribute.ts +++ b/src/slang-nodes/ReceiveFunctionAttribute.ts @@ -19,7 +19,7 @@ function createNonterminalVariant( return new ModifierInvocation(variant, options); } if (variant instanceof ast.OverrideSpecifier) { - return new OverrideSpecifier(variant); + return new OverrideSpecifier(variant, options); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -34,11 +34,11 @@ export class ReceiveFunctionAttribute extends SlangNode { ast: ast.ReceiveFunctionAttribute, options: ParserOptions ) { - 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 = createNonterminalVariant(variant, options); diff --git a/src/slang-nodes/ReceiveFunctionAttributes.ts b/src/slang-nodes/ReceiveFunctionAttributes.ts index 75c22e3e1..cb63cabb0 100644 --- a/src/slang-nodes/ReceiveFunctionAttributes.ts +++ b/src/slang-nodes/ReceiveFunctionAttributes.ts @@ -21,7 +21,7 @@ export class ReceiveFunctionAttributes extends SlangNode { ast: ast.ReceiveFunctionAttributes, options: ParserOptions ) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new ReceiveFunctionAttribute(item, options)) diff --git a/src/slang-nodes/ReceiveFunctionDefinition.ts b/src/slang-nodes/ReceiveFunctionDefinition.ts index 27aa54698..7a6ba763c 100644 --- a/src/slang-nodes/ReceiveFunctionDefinition.ts +++ b/src/slang-nodes/ReceiveFunctionDefinition.ts @@ -24,7 +24,7 @@ export class ReceiveFunctionDefinition extends SlangNode { ast: ast.ReceiveFunctionDefinition, options: ParserOptions ) { - super(ast); + super(ast, options); this.parameters = new ParametersDeclaration(ast.parameters, options); this.attributes = new ReceiveFunctionAttributes(ast.attributes, options); diff --git a/src/slang-nodes/ReturnStatement.ts b/src/slang-nodes/ReturnStatement.ts index 655a6f8ac..a38d7c208 100644 --- a/src/slang-nodes/ReturnStatement.ts +++ b/src/slang-nodes/ReturnStatement.ts @@ -15,7 +15,7 @@ export class ReturnStatement extends SlangNode { expression?: Expression['variant']; constructor(ast: ast.ReturnStatement, options: ParserOptions) { - super(ast); + super(ast, options); if (ast.expression) { this.expression = extractVariant(new Expression(ast.expression, options)); diff --git a/src/slang-nodes/ReturnsDeclaration.ts b/src/slang-nodes/ReturnsDeclaration.ts index c95c36be3..bb81cf7e9 100644 --- a/src/slang-nodes/ReturnsDeclaration.ts +++ b/src/slang-nodes/ReturnsDeclaration.ts @@ -16,7 +16,7 @@ export class ReturnsDeclaration extends SlangNode { variables: ParametersDeclaration; constructor(ast: ast.ReturnsDeclaration, options: ParserOptions) { - super(ast); + super(ast, options); this.variables = new ParametersDeclaration(ast.variables, options); diff --git a/src/slang-nodes/RevertStatement.ts b/src/slang-nodes/RevertStatement.ts index cbbf5f010..4aa479f8a 100644 --- a/src/slang-nodes/RevertStatement.ts +++ b/src/slang-nodes/RevertStatement.ts @@ -18,10 +18,10 @@ export class RevertStatement extends SlangNode { arguments: ArgumentsDeclaration['variant']; constructor(ast: ast.RevertStatement, options: ParserOptions) { - super(ast); + super(ast, options); if (ast.error) { - this.error = new IdentifierPath(ast.error); + this.error = new IdentifierPath(ast.error, options); } this.arguments = extractVariant( new ArgumentsDeclaration(ast.arguments, options) diff --git a/src/slang-nodes/ShiftExpression.ts b/src/slang-nodes/ShiftExpression.ts index d1326f9b2..d6c215b91 100644 --- a/src/slang-nodes/ShiftExpression.ts +++ b/src/slang-nodes/ShiftExpression.ts @@ -44,7 +44,7 @@ export class ShiftExpression extends SlangNode { rightOperand: Expression['variant']; constructor(ast: ast.ShiftExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.leftOperand = extractVariant(new Expression(ast.leftOperand, options)); this.operator = ast.operator.unparse(); diff --git a/src/slang-nodes/SimpleVersionLiteral.ts b/src/slang-nodes/SimpleVersionLiteral.ts index 4e65775d0..09b2de39c 100644 --- a/src/slang-nodes/SimpleVersionLiteral.ts +++ b/src/slang-nodes/SimpleVersionLiteral.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.ts'; export class SimpleVersionLiteral extends SlangNode { readonly kind = NonterminalKind.SimpleVersionLiteral; items: string[]; - constructor(ast: ast.SimpleVersionLiteral) { - super(ast, true); + constructor(ast: ast.SimpleVersionLiteral, options: ParserOptions) { + super(ast, options, true); this.items = ast.items.map((item) => item.unparse()); } diff --git a/src/slang-nodes/SlangNode.ts b/src/slang-nodes/SlangNode.ts index dee54a031..c3cf8d7bd 100644 --- a/src/slang-nodes/SlangNode.ts +++ b/src/slang-nodes/SlangNode.ts @@ -8,21 +8,15 @@ import { MultiLineNatSpecComment } from '../slang-nodes/MultiLineNatSpecComment. import { SingleLineComment } from '../slang-nodes/SingleLineComment.js'; import { SingleLineNatSpecComment } from '../slang-nodes/SingleLineNatSpecComment.js'; -import type { Comment, StrictAstNode } from '../slang-nodes/types.d.ts'; +import type { ParserOptions } from 'prettier'; +import type { + AstNode, + Comment, + StrictAstNode +} from '../slang-nodes/types.d.ts'; import type { AstLocation, SlangAstNode } from '../types.d.ts'; import type { TerminalNode } from './TerminalNode.js'; -const offsets = new Map(); -const comments: Comment[] = []; - -export function clearOffsets(): void { - offsets.clear(); -} - -export function clearComments(): Comment[] { - return comments.splice(0); -} - function reversedIterator(children: T[]): Iterable { return { [Symbol.iterator](): Iterator { @@ -44,10 +38,11 @@ export class SlangNode { constructor( ast: SlangAstNode | SlangTerminalNode, + options: ParserOptions, enclosePeripheralComments = false ) { if (ast instanceof SlangTerminalNode) { - const offset = offsets.get(ast.id) || 0; + const offset = options._prettier_solidity_offsets.get(ast.id) || 0; this.loc = { start: offset, end: offset + ast.textLength.utf16, @@ -58,7 +53,7 @@ export class SlangNode { } const cst = ast.cst; - const initialOffset = offsets.get(cst.id) || 0; + const initialOffset = options._prettier_solidity_offsets.get(cst.id) || 0; let offset = initialOffset; let triviaLength = 0; let leadingOffset; @@ -78,7 +73,7 @@ export class SlangNode { ) { // Also tracking TerminalNodes since some variants that were not // Identifier or YulIdentifier but were upgraded to TerminalNode - offsets.set(node.id, offset); + options._prettier_solidity_offsets.set(node.id, offset); // We assign the `leadingOffset` only once. leadingOffset ??= triviaLength; // Since this is a non trivia node, we reset the accumulated length @@ -90,16 +85,24 @@ export class SlangNode { // offset, it's hard to separate these responsibilities into different // functions without doing the iteration twice. case TerminalKind.MultiLineComment: - comments.push(new MultiLineComment(node, offset)); + options._prettier_solidity_comments.push( + new MultiLineComment(node, offset) + ); break; case TerminalKind.MultiLineNatSpecComment: - comments.push(new MultiLineNatSpecComment(node, offset)); + options._prettier_solidity_comments.push( + new MultiLineNatSpecComment(node, offset) + ); break; case TerminalKind.SingleLineComment: - comments.push(new SingleLineComment(node, offset)); + options._prettier_solidity_comments.push( + new SingleLineComment(node, offset) + ); break; case TerminalKind.SingleLineNatSpecComment: - comments.push(new SingleLineNatSpecComment(node, offset)); + options._prettier_solidity_comments.push( + new SingleLineNatSpecComment(node, offset) + ); break; } // We accumulate the trivia length diff --git a/src/slang-nodes/SourceUnit.ts b/src/slang-nodes/SourceUnit.ts index e87006064..971fef8d1 100644 --- a/src/slang-nodes/SourceUnit.ts +++ b/src/slang-nodes/SourceUnit.ts @@ -16,7 +16,7 @@ export class SourceUnit extends SlangNode { members: SourceUnitMembers; constructor(ast: ast.SourceUnit, options: ParserOptions) { - super(ast); + super(ast, options); this.members = new SourceUnitMembers(ast.members, options); diff --git a/src/slang-nodes/SourceUnitMember.ts b/src/slang-nodes/SourceUnitMember.ts index aeeb129aa..e33a3e1a9 100644 --- a/src/slang-nodes/SourceUnitMember.ts +++ b/src/slang-nodes/SourceUnitMember.ts @@ -41,7 +41,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.FunctionDefinition) { return new FunctionDefinition(variant, options); @@ -53,7 +53,7 @@ function createNonterminalVariant( return new ErrorDefinition(variant, options); } if (variant instanceof ast.UserDefinedValueTypeDefinition) { - return new UserDefinedValueTypeDefinition(variant); + return new UserDefinedValueTypeDefinition(variant, options); } if (variant instanceof ast.UsingDirective) { return new UsingDirective(variant, options); @@ -84,7 +84,7 @@ export class SourceUnitMember extends SlangNode { | EventDefinition; constructor(ast: ast.SourceUnitMember, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/SourceUnitMembers.ts b/src/slang-nodes/SourceUnitMembers.ts index 62347cd32..0d92c6ea4 100644 --- a/src/slang-nodes/SourceUnitMembers.ts +++ b/src/slang-nodes/SourceUnitMembers.ts @@ -15,7 +15,7 @@ export class SourceUnitMembers extends SlangNode { items: SourceUnitMember['variant'][]; constructor(ast: ast.SourceUnitMembers, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new SourceUnitMember(item, options)) diff --git a/src/slang-nodes/StateVariableAttribute.ts b/src/slang-nodes/StateVariableAttribute.ts index 4cfa43602..208bf9d72 100644 --- a/src/slang-nodes/StateVariableAttribute.ts +++ b/src/slang-nodes/StateVariableAttribute.ts @@ -7,21 +7,26 @@ import { OverrideSpecifier } from './OverrideSpecifier.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.d.ts'; export class StateVariableAttribute extends SlangNode { readonly kind = NonterminalKind.StateVariableAttribute; variant: OverrideSpecifier | TerminalNode; - constructor(ast: ast.StateVariableAttribute) { - super(ast); + constructor( + ast: ast.StateVariableAttribute, + options: ParserOptions + ) { + 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 OverrideSpecifier(variant); + this.variant = new OverrideSpecifier(variant, options); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/StateVariableAttributes.ts b/src/slang-nodes/StateVariableAttributes.ts index 30b596c72..38dc540cc 100644 --- a/src/slang-nodes/StateVariableAttributes.ts +++ b/src/slang-nodes/StateVariableAttributes.ts @@ -6,8 +6,9 @@ import { SlangNode } from './SlangNode.js'; import { StateVariableAttribute } from './StateVariableAttribute.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'; const { line } = doc.builders; @@ -16,11 +17,14 @@ export class StateVariableAttributes extends SlangNode { items: StateVariableAttribute['variant'][]; - constructor(ast: ast.StateVariableAttributes) { - super(ast, true); + constructor( + ast: ast.StateVariableAttributes, + options: ParserOptions + ) { + super(ast, options, true); this.items = ast.items.map((item) => - extractVariant(new StateVariableAttribute(item)) + extractVariant(new StateVariableAttribute(item, options)) ); this.items.sort(sortFunctionAttributes); diff --git a/src/slang-nodes/StateVariableDefinition.ts b/src/slang-nodes/StateVariableDefinition.ts index a4f5d34fd..959262a99 100644 --- a/src/slang-nodes/StateVariableDefinition.ts +++ b/src/slang-nodes/StateVariableDefinition.ts @@ -30,11 +30,11 @@ export class StateVariableDefinition extends SlangNode { ast: ast.StateVariableDefinition, options: ParserOptions ) { - super(ast); + super(ast, options); this.typeName = extractVariant(new TypeName(ast.typeName, options)); - this.attributes = new StateVariableAttributes(ast.attributes); - this.name = new TerminalNode(ast.name); + this.attributes = new StateVariableAttributes(ast.attributes, options); + this.name = new TerminalNode(ast.name, options); if (ast.value) { this.value = new StateVariableDefinitionValue(ast.value, options); } diff --git a/src/slang-nodes/StateVariableDefinitionValue.ts b/src/slang-nodes/StateVariableDefinitionValue.ts index c634956b8..4e8d155df 100644 --- a/src/slang-nodes/StateVariableDefinitionValue.ts +++ b/src/slang-nodes/StateVariableDefinitionValue.ts @@ -18,7 +18,7 @@ export class StateVariableDefinitionValue extends SlangNode { ast: ast.StateVariableDefinitionValue, options: ParserOptions ) { - super(ast); + super(ast, options); this.value = extractVariant(new Expression(ast.value, options)); diff --git a/src/slang-nodes/Statement.ts b/src/slang-nodes/Statement.ts index efc3c95f0..07b8a60a2 100644 --- a/src/slang-nodes/Statement.ts +++ b/src/slang-nodes/Statement.ts @@ -48,16 +48,16 @@ function createNonterminalVariant( return new DoWhileStatement(variant, options); } if (variant instanceof ast.ContinueStatement) { - return new ContinueStatement(variant); + return new ContinueStatement(variant, options); } if (variant instanceof ast.BreakStatement) { - return new BreakStatement(variant); + return new BreakStatement(variant, options); } if (variant instanceof ast.ReturnStatement) { return new ReturnStatement(variant, options); } if (variant instanceof ast.ThrowStatement) { - return new ThrowStatement(variant); + return new ThrowStatement(variant, options); } if (variant instanceof ast.EmitStatement) { return new EmitStatement(variant, options); @@ -104,7 +104,7 @@ export class Statement extends SlangNode { | UncheckedBlock; constructor(ast: ast.Statement, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/Statements.ts b/src/slang-nodes/Statements.ts index 004822df4..f56828607 100644 --- a/src/slang-nodes/Statements.ts +++ b/src/slang-nodes/Statements.ts @@ -19,7 +19,7 @@ export class Statements extends SlangNode { items: Statement['variant'][]; constructor(ast: ast.Statements, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new Statement(item, options)) diff --git a/src/slang-nodes/StorageLayoutSpecifier.ts b/src/slang-nodes/StorageLayoutSpecifier.ts index 8fcce6a07..9600241ee 100644 --- a/src/slang-nodes/StorageLayoutSpecifier.ts +++ b/src/slang-nodes/StorageLayoutSpecifier.ts @@ -21,7 +21,7 @@ export class StorageLayoutSpecifier extends SlangNode { ast: ast.StorageLayoutSpecifier, options: ParserOptions ) { - super(ast); + super(ast, options); this.expression = extractVariant(new Expression(ast.expression, options)); diff --git a/src/slang-nodes/StorageLocation.ts b/src/slang-nodes/StorageLocation.ts index 64d048a03..05ea0b103 100644 --- a/src/slang-nodes/StorageLocation.ts +++ b/src/slang-nodes/StorageLocation.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 StorageLocation extends SlangNode { readonly kind = NonterminalKind.StorageLocation; variant: string; - constructor(ast: ast.StorageLocation) { - super(ast); + constructor(ast: ast.StorageLocation, options: ParserOptions) { + super(ast, options); this.variant = ast.variant.unparse(); } diff --git a/src/slang-nodes/StringExpression.ts b/src/slang-nodes/StringExpression.ts index d51d5ed88..e253aa544 100644 --- a/src/slang-nodes/StringExpression.ts +++ b/src/slang-nodes/StringExpression.ts @@ -44,7 +44,7 @@ export class StringExpression extends SlangNode { | UnicodeStringLiterals; constructor(ast: ast.StringExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/StringLiteral.ts b/src/slang-nodes/StringLiteral.ts index aee53e230..ff2e0e42f 100644 --- a/src/slang-nodes/StringLiteral.ts +++ b/src/slang-nodes/StringLiteral.ts @@ -12,7 +12,7 @@ export class StringLiteral extends SlangNode { variant: string; constructor(ast: ast.StringLiteral, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = ast.variant.unparse(); diff --git a/src/slang-nodes/StringLiterals.ts b/src/slang-nodes/StringLiterals.ts index 88ed51322..7222f4241 100644 --- a/src/slang-nodes/StringLiterals.ts +++ b/src/slang-nodes/StringLiterals.ts @@ -16,7 +16,7 @@ export class StringLiterals extends SlangNode { items: StringLiteral[]; constructor(ast: ast.StringLiterals, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new StringLiteral(item, options)); } diff --git a/src/slang-nodes/StructDefinition.ts b/src/slang-nodes/StructDefinition.ts index 474f6fe87..0c6dbb4d7 100644 --- a/src/slang-nodes/StructDefinition.ts +++ b/src/slang-nodes/StructDefinition.ts @@ -16,9 +16,9 @@ export class StructDefinition extends SlangNode { members: StructMembers; constructor(ast: ast.StructDefinition, options: ParserOptions) { - super(ast); + super(ast, options); - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); this.members = new StructMembers(ast.members, options); this.updateMetadata(this.members); diff --git a/src/slang-nodes/StructMember.ts b/src/slang-nodes/StructMember.ts index bfc8fa75b..3045e17f0 100644 --- a/src/slang-nodes/StructMember.ts +++ b/src/slang-nodes/StructMember.ts @@ -17,10 +17,10 @@ export class StructMember extends SlangNode { name: TerminalNode; constructor(ast: ast.StructMember, options: ParserOptions) { - 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.updateMetadata(this.typeName); } diff --git a/src/slang-nodes/StructMembers.ts b/src/slang-nodes/StructMembers.ts index 0acd4c606..69f708d36 100644 --- a/src/slang-nodes/StructMembers.ts +++ b/src/slang-nodes/StructMembers.ts @@ -17,7 +17,7 @@ export class StructMembers extends SlangNode { items: StructMember[]; constructor(ast: ast.StructMembers, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new StructMember(item, options)); } diff --git a/src/slang-nodes/TerminalNode.ts b/src/slang-nodes/TerminalNode.ts index 3ff299eb0..b67f12994 100644 --- a/src/slang-nodes/TerminalNode.ts +++ b/src/slang-nodes/TerminalNode.ts @@ -4,15 +4,16 @@ import type { TerminalNode as SlangTerminalNode, TerminalKind } from '@nomicfoundation/slang/cst'; -import type { Doc } from 'prettier'; +import type { Doc, ParserOptions } from 'prettier'; +import type { AstNode } from './types.ts'; export class TerminalNode extends SlangNode { kind: TerminalKind; value: string; - constructor(ast: SlangTerminalNode) { - super(ast); + constructor(ast: SlangTerminalNode, options: ParserOptions) { + super(ast, options); this.kind = ast.kind; this.value = ast.unparse(); diff --git a/src/slang-nodes/ThrowStatement.ts b/src/slang-nodes/ThrowStatement.ts index c59252f59..58728bf7e 100644 --- a/src/slang-nodes/ThrowStatement.ts +++ b/src/slang-nodes/ThrowStatement.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.ts'; export class ThrowStatement extends SlangNode { readonly kind = NonterminalKind.ThrowStatement; - constructor(ast: ast.ThrowStatement) { - super(ast); + constructor(ast: ast.ThrowStatement, options: ParserOptions) { + super(ast, options); } print(): Doc { diff --git a/src/slang-nodes/TryStatement.ts b/src/slang-nodes/TryStatement.ts index c9f048bc8..28ea39f5f 100644 --- a/src/slang-nodes/TryStatement.ts +++ b/src/slang-nodes/TryStatement.ts @@ -28,7 +28,7 @@ export class TryStatement extends SlangNode { catchClauses: CatchClauses; constructor(ast: ast.TryStatement, options: ParserOptions) { - super(ast); + super(ast, options); this.expression = extractVariant(new Expression(ast.expression, options)); if (ast.returns) { diff --git a/src/slang-nodes/TupleDeconstructionElement.ts b/src/slang-nodes/TupleDeconstructionElement.ts index 4a6c0493d..768acaa92 100644 --- a/src/slang-nodes/TupleDeconstructionElement.ts +++ b/src/slang-nodes/TupleDeconstructionElement.ts @@ -17,7 +17,7 @@ export class TupleDeconstructionElement extends SlangNode { ast: ast.TupleDeconstructionElement, options: ParserOptions ) { - super(ast); + super(ast, options); if (ast.member) { this.member = extractVariant(new TupleMember(ast.member, options)); diff --git a/src/slang-nodes/TupleDeconstructionElements.ts b/src/slang-nodes/TupleDeconstructionElements.ts index da147d272..f70603c0c 100644 --- a/src/slang-nodes/TupleDeconstructionElements.ts +++ b/src/slang-nodes/TupleDeconstructionElements.ts @@ -17,7 +17,7 @@ export class TupleDeconstructionElements extends SlangNode { ast: ast.TupleDeconstructionElements, options: ParserOptions ) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map( (item) => new TupleDeconstructionElement(item, options) diff --git a/src/slang-nodes/TupleDeconstructionStatement.ts b/src/slang-nodes/TupleDeconstructionStatement.ts index 2d286a20f..7d9c5e4a5 100644 --- a/src/slang-nodes/TupleDeconstructionStatement.ts +++ b/src/slang-nodes/TupleDeconstructionStatement.ts @@ -23,7 +23,7 @@ export class TupleDeconstructionStatement extends SlangNode { ast: ast.TupleDeconstructionStatement, options: ParserOptions ) { - super(ast); + super(ast, options); this.varKeyword = ast.varKeyword?.unparse(); this.elements = new TupleDeconstructionElements(ast.elements, options); diff --git a/src/slang-nodes/TupleExpression.ts b/src/slang-nodes/TupleExpression.ts index 42b284d34..b980ac330 100644 --- a/src/slang-nodes/TupleExpression.ts +++ b/src/slang-nodes/TupleExpression.ts @@ -13,7 +13,7 @@ export class TupleExpression extends SlangNode { items: TupleValues; constructor(ast: ast.TupleExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.items = new TupleValues(ast.items, options); } diff --git a/src/slang-nodes/TupleMember.ts b/src/slang-nodes/TupleMember.ts index e3361c478..dfed9158c 100644 --- a/src/slang-nodes/TupleMember.ts +++ b/src/slang-nodes/TupleMember.ts @@ -15,7 +15,7 @@ function createNonterminalVariant( return new TypedTupleMember(variant, options); } if (variant instanceof ast.UntypedTupleMember) { - return new UntypedTupleMember(variant); + return new UntypedTupleMember(variant, options); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -27,7 +27,7 @@ export class TupleMember extends SlangNode { variant: TypedTupleMember | UntypedTupleMember; constructor(ast: ast.TupleMember, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/TupleValue.ts b/src/slang-nodes/TupleValue.ts index 0411f5c66..09b09fe1e 100644 --- a/src/slang-nodes/TupleValue.ts +++ b/src/slang-nodes/TupleValue.ts @@ -14,7 +14,7 @@ export class TupleValue extends SlangNode { expression?: Expression['variant']; constructor(ast: ast.TupleValue, options: ParserOptions) { - super(ast); + super(ast, options); if (ast.expression) { this.expression = extractVariant(new Expression(ast.expression, options)); diff --git a/src/slang-nodes/TupleValues.ts b/src/slang-nodes/TupleValues.ts index 916f267b9..c25d46e96 100644 --- a/src/slang-nodes/TupleValues.ts +++ b/src/slang-nodes/TupleValues.ts @@ -17,7 +17,7 @@ export class TupleValues extends SlangNode { items: TupleValue[]; constructor(ast: ast.TupleValues, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => new TupleValue(item, options)); } diff --git a/src/slang-nodes/TypeExpression.ts b/src/slang-nodes/TypeExpression.ts index 14d87f050..5f8491ddd 100644 --- a/src/slang-nodes/TypeExpression.ts +++ b/src/slang-nodes/TypeExpression.ts @@ -14,7 +14,7 @@ export class TypeExpression extends SlangNode { typeName: TypeName['variant']; constructor(ast: ast.TypeExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.typeName = extractVariant(new TypeName(ast.typeName, options)); diff --git a/src/slang-nodes/TypeName.ts b/src/slang-nodes/TypeName.ts index a04ee7639..c841ccb5f 100644 --- a/src/slang-nodes/TypeName.ts +++ b/src/slang-nodes/TypeName.ts @@ -25,10 +25,10 @@ function createNonterminalVariant( return new MappingType(variant, options); } if (variant instanceof ast.ElementaryType) { - return extractVariant(new ElementaryType(variant)); + return extractVariant(new ElementaryType(variant, options)); } if (variant instanceof ast.IdentifierPath) { - return new IdentifierPath(variant); + return new IdentifierPath(variant, options); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -45,7 +45,7 @@ export class TypeName extends SlangNode { | IdentifierPath; constructor(ast: ast.TypeName, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/TypedTupleMember.ts b/src/slang-nodes/TypedTupleMember.ts index 2cf82bd72..bb9181d93 100644 --- a/src/slang-nodes/TypedTupleMember.ts +++ b/src/slang-nodes/TypedTupleMember.ts @@ -21,13 +21,13 @@ export class TypedTupleMember extends SlangNode { name: TerminalNode; constructor(ast: ast.TypedTupleMember, options: ParserOptions) { - super(ast); + super(ast, options); this.typeName = extractVariant(new TypeName(ast.typeName, options)); if (ast.storageLocation) { - this.storageLocation = new StorageLocation(ast.storageLocation); + this.storageLocation = new StorageLocation(ast.storageLocation, options); } - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); this.updateMetadata(this.typeName, this.storageLocation); } diff --git a/src/slang-nodes/UncheckedBlock.ts b/src/slang-nodes/UncheckedBlock.ts index 45721725f..a9ca5cbb6 100644 --- a/src/slang-nodes/UncheckedBlock.ts +++ b/src/slang-nodes/UncheckedBlock.ts @@ -13,7 +13,7 @@ export class UncheckedBlock extends SlangNode { block: Block; constructor(ast: ast.UncheckedBlock, options: ParserOptions) { - super(ast); + super(ast, options); this.block = new Block(ast.block, options); diff --git a/src/slang-nodes/UnicodeStringLiteral.ts b/src/slang-nodes/UnicodeStringLiteral.ts index 68144b674..2661db34e 100644 --- a/src/slang-nodes/UnicodeStringLiteral.ts +++ b/src/slang-nodes/UnicodeStringLiteral.ts @@ -12,7 +12,7 @@ export class UnicodeStringLiteral extends SlangNode { variant: string; constructor(ast: ast.UnicodeStringLiteral, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = ast.variant.unparse(); diff --git a/src/slang-nodes/UnicodeStringLiterals.ts b/src/slang-nodes/UnicodeStringLiterals.ts index 3faadae22..fa3f9c0ac 100644 --- a/src/slang-nodes/UnicodeStringLiterals.ts +++ b/src/slang-nodes/UnicodeStringLiterals.ts @@ -16,7 +16,7 @@ export class UnicodeStringLiterals extends SlangNode { items: UnicodeStringLiteral[]; constructor(ast: ast.UnicodeStringLiterals, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map( (item) => new UnicodeStringLiteral(item, options) diff --git a/src/slang-nodes/UnnamedFunctionAttribute.ts b/src/slang-nodes/UnnamedFunctionAttribute.ts index caaf4e447..1f3de0bed 100644 --- a/src/slang-nodes/UnnamedFunctionAttribute.ts +++ b/src/slang-nodes/UnnamedFunctionAttribute.ts @@ -19,11 +19,11 @@ export class UnnamedFunctionAttribute extends SlangNode { ast: ast.UnnamedFunctionAttribute, options: ParserOptions ) { - 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); diff --git a/src/slang-nodes/UnnamedFunctionAttributes.ts b/src/slang-nodes/UnnamedFunctionAttributes.ts index 52ceb3ff0..5a73cbc21 100644 --- a/src/slang-nodes/UnnamedFunctionAttributes.ts +++ b/src/slang-nodes/UnnamedFunctionAttributes.ts @@ -21,7 +21,7 @@ export class UnnamedFunctionAttributes extends SlangNode { ast: ast.UnnamedFunctionAttributes, options: ParserOptions ) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new UnnamedFunctionAttribute(item, options)) diff --git a/src/slang-nodes/UnnamedFunctionDefinition.ts b/src/slang-nodes/UnnamedFunctionDefinition.ts index 71a0c8414..22af27f41 100644 --- a/src/slang-nodes/UnnamedFunctionDefinition.ts +++ b/src/slang-nodes/UnnamedFunctionDefinition.ts @@ -24,7 +24,7 @@ export class UnnamedFunctionDefinition extends SlangNode { ast: ast.UnnamedFunctionDefinition, options: ParserOptions ) { - super(ast); + super(ast, options); this.parameters = new ParametersDeclaration(ast.parameters, options); this.attributes = new UnnamedFunctionAttributes(ast.attributes, options); diff --git a/src/slang-nodes/UntypedTupleMember.ts b/src/slang-nodes/UntypedTupleMember.ts index 3220fe913..411dce9a9 100644 --- a/src/slang-nodes/UntypedTupleMember.ts +++ b/src/slang-nodes/UntypedTupleMember.ts @@ -5,8 +5,9 @@ import { StorageLocation } from './StorageLocation.js'; import { TerminalNode } from './TerminalNode.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.ts'; export class UntypedTupleMember extends SlangNode { readonly kind = NonterminalKind.UntypedTupleMember; @@ -15,13 +16,13 @@ export class UntypedTupleMember extends SlangNode { name: TerminalNode; - constructor(ast: ast.UntypedTupleMember) { - super(ast); + constructor(ast: ast.UntypedTupleMember, options: ParserOptions) { + super(ast, options); if (ast.storageLocation) { - this.storageLocation = new StorageLocation(ast.storageLocation); + this.storageLocation = new StorageLocation(ast.storageLocation, options); } - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); this.updateMetadata(this.storageLocation); } diff --git a/src/slang-nodes/UserDefinedValueTypeDefinition.ts b/src/slang-nodes/UserDefinedValueTypeDefinition.ts index a9e5ea8c5..56bee7d24 100644 --- a/src/slang-nodes/UserDefinedValueTypeDefinition.ts +++ b/src/slang-nodes/UserDefinedValueTypeDefinition.ts @@ -5,8 +5,9 @@ import { TerminalNode } from './TerminalNode.js'; import { ElementaryType } from './ElementaryType.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.ts'; export class UserDefinedValueTypeDefinition extends SlangNode { readonly kind = NonterminalKind.UserDefinedValueTypeDefinition; @@ -15,11 +16,14 @@ export class UserDefinedValueTypeDefinition extends SlangNode { valueType: ElementaryType['variant']; - constructor(ast: ast.UserDefinedValueTypeDefinition) { - super(ast); + constructor( + ast: ast.UserDefinedValueTypeDefinition, + options: ParserOptions + ) { + super(ast, options); - this.name = new TerminalNode(ast.name); - this.valueType = extractVariant(new ElementaryType(ast.valueType)); + this.name = new TerminalNode(ast.name, options); + this.valueType = extractVariant(new ElementaryType(ast.valueType, options)); this.updateMetadata(this.valueType); } diff --git a/src/slang-nodes/UsingAlias.ts b/src/slang-nodes/UsingAlias.ts index f1823b6c4..0d09fd75e 100644 --- a/src/slang-nodes/UsingAlias.ts +++ b/src/slang-nodes/UsingAlias.ts @@ -3,18 +3,19 @@ import { SlangNode } from './SlangNode.js'; import { UsingOperator } from './UsingOperator.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.ts'; export class UsingAlias extends SlangNode { readonly kind = NonterminalKind.UsingAlias; operator: UsingOperator; - constructor(ast: ast.UsingAlias) { - super(ast); + constructor(ast: ast.UsingAlias, options: ParserOptions) { + super(ast, options); - this.operator = new UsingOperator(ast.operator); + this.operator = new UsingOperator(ast.operator, options); this.updateMetadata(this.operator); } diff --git a/src/slang-nodes/UsingClause.ts b/src/slang-nodes/UsingClause.ts index 38e951b20..dd0edd36e 100644 --- a/src/slang-nodes/UsingClause.ts +++ b/src/slang-nodes/UsingClause.ts @@ -4,14 +4,18 @@ import { SlangNode } from './SlangNode.js'; import { IdentifierPath } from './IdentifierPath.js'; import { UsingDeconstruction } from './UsingDeconstruction.js'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.ts'; + function createNonterminalVariant( - variant: ast.UsingClause['variant'] + variant: ast.UsingClause['variant'], + options: ParserOptions ): UsingClause['variant'] { if (variant instanceof ast.IdentifierPath) { - return new IdentifierPath(variant); + return new IdentifierPath(variant, options); } if (variant instanceof ast.UsingDeconstruction) { - return new UsingDeconstruction(variant); + return new UsingDeconstruction(variant, options); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -22,10 +26,10 @@ export class UsingClause extends SlangNode { variant: IdentifierPath | UsingDeconstruction; - constructor(ast: ast.UsingClause) { - super(ast); + constructor(ast: ast.UsingClause, options: ParserOptions) { + super(ast, options); - this.variant = createNonterminalVariant(ast.variant); + this.variant = createNonterminalVariant(ast.variant, options); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/UsingDeconstruction.ts b/src/slang-nodes/UsingDeconstruction.ts index 940290fc1..72b4f531e 100644 --- a/src/slang-nodes/UsingDeconstruction.ts +++ b/src/slang-nodes/UsingDeconstruction.ts @@ -3,18 +3,19 @@ import { SlangNode } from './SlangNode.js'; import { UsingDeconstructionSymbols } from './UsingDeconstructionSymbols.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.ts'; export class UsingDeconstruction extends SlangNode { readonly kind = NonterminalKind.UsingDeconstruction; symbols: UsingDeconstructionSymbols; - constructor(ast: ast.UsingDeconstruction) { - super(ast); + constructor(ast: ast.UsingDeconstruction, options: ParserOptions) { + super(ast, options); - this.symbols = new UsingDeconstructionSymbols(ast.symbols); + this.symbols = new UsingDeconstructionSymbols(ast.symbols, options); this.updateMetadata(this.symbols); } diff --git a/src/slang-nodes/UsingDeconstructionSymbol.ts b/src/slang-nodes/UsingDeconstructionSymbol.ts index 6158ee528..00246653e 100644 --- a/src/slang-nodes/UsingDeconstructionSymbol.ts +++ b/src/slang-nodes/UsingDeconstructionSymbol.ts @@ -4,8 +4,9 @@ import { IdentifierPath } from './IdentifierPath.js'; import { UsingAlias } from './UsingAlias.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.ts'; export class UsingDeconstructionSymbol extends SlangNode { readonly kind = NonterminalKind.UsingDeconstructionSymbol; @@ -14,12 +15,15 @@ export class UsingDeconstructionSymbol extends SlangNode { alias?: UsingAlias; - constructor(ast: ast.UsingDeconstructionSymbol) { - super(ast); + constructor( + ast: ast.UsingDeconstructionSymbol, + options: ParserOptions + ) { + super(ast, options); - this.name = new IdentifierPath(ast.name); + this.name = new IdentifierPath(ast.name, options); if (ast.alias) { - this.alias = new UsingAlias(ast.alias); + this.alias = new UsingAlias(ast.alias, options); } this.updateMetadata(this.name, this.alias); diff --git a/src/slang-nodes/UsingDeconstructionSymbols.ts b/src/slang-nodes/UsingDeconstructionSymbols.ts index aad43cbc5..6682eb420 100644 --- a/src/slang-nodes/UsingDeconstructionSymbols.ts +++ b/src/slang-nodes/UsingDeconstructionSymbols.ts @@ -16,10 +16,15 @@ export class UsingDeconstructionSymbols extends SlangNode { items: UsingDeconstructionSymbol[]; - constructor(ast: ast.UsingDeconstructionSymbols) { - super(ast, true); + constructor( + ast: ast.UsingDeconstructionSymbols, + options: ParserOptions + ) { + super(ast, options, true); - this.items = ast.items.map((item) => new UsingDeconstructionSymbol(item)); + this.items = ast.items.map( + (item) => new UsingDeconstructionSymbol(item, options) + ); } print( diff --git a/src/slang-nodes/UsingDirective.ts b/src/slang-nodes/UsingDirective.ts index 10f1789a8..72e44c83f 100644 --- a/src/slang-nodes/UsingDirective.ts +++ b/src/slang-nodes/UsingDirective.ts @@ -19,9 +19,9 @@ export class UsingDirective extends SlangNode { globalKeyword?: string; constructor(ast: ast.UsingDirective, options: ParserOptions) { - super(ast); + super(ast, options); - this.clause = extractVariant(new UsingClause(ast.clause)); + this.clause = extractVariant(new UsingClause(ast.clause, options)); this.target = extractVariant(new UsingTarget(ast.target, options)); this.globalKeyword = ast.globalKeyword?.unparse(); diff --git a/src/slang-nodes/UsingOperator.ts b/src/slang-nodes/UsingOperator.ts index 48cbbe861..4111af352 100644 --- a/src/slang-nodes/UsingOperator.ts +++ b/src/slang-nodes/UsingOperator.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.ts'; export class UsingOperator extends SlangNode { readonly kind = NonterminalKind.UsingOperator; variant: string; - constructor(ast: ast.UsingOperator) { - super(ast); + constructor(ast: ast.UsingOperator, options: ParserOptions) { + super(ast, options); this.variant = ast.variant.unparse(); } diff --git a/src/slang-nodes/UsingTarget.ts b/src/slang-nodes/UsingTarget.ts index 74d07e770..cb665aeab 100644 --- a/src/slang-nodes/UsingTarget.ts +++ b/src/slang-nodes/UsingTarget.ts @@ -17,11 +17,11 @@ export class UsingTarget extends SlangNode { variant: TypeName['variant'] | TerminalNode; constructor(ast: ast.UsingTarget, options: ParserOptions) { - 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 = extractVariant(new TypeName(variant, options)); diff --git a/src/slang-nodes/VariableDeclarationStatement.ts b/src/slang-nodes/VariableDeclarationStatement.ts index b777d637f..bc8515af0 100644 --- a/src/slang-nodes/VariableDeclarationStatement.ts +++ b/src/slang-nodes/VariableDeclarationStatement.ts @@ -30,15 +30,15 @@ export class VariableDeclarationStatement extends SlangNode { ast: ast.VariableDeclarationStatement, options: ParserOptions ) { - super(ast); + super(ast, options); this.variableType = extractVariant( new VariableDeclarationType(ast.variableType, options) ); if (ast.storageLocation) { - this.storageLocation = new StorageLocation(ast.storageLocation); + this.storageLocation = new StorageLocation(ast.storageLocation, options); } - this.name = new TerminalNode(ast.name); + this.name = new TerminalNode(ast.name, options); if (ast.value) { this.value = new VariableDeclarationValue(ast.value, options); } diff --git a/src/slang-nodes/VariableDeclarationType.ts b/src/slang-nodes/VariableDeclarationType.ts index 99bfff663..f65034fac 100644 --- a/src/slang-nodes/VariableDeclarationType.ts +++ b/src/slang-nodes/VariableDeclarationType.ts @@ -20,11 +20,11 @@ export class VariableDeclarationType extends SlangNode { ast: ast.VariableDeclarationType, options: ParserOptions ) { - 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 = extractVariant(new TypeName(variant, options)); diff --git a/src/slang-nodes/VariableDeclarationValue.ts b/src/slang-nodes/VariableDeclarationValue.ts index 1306002ca..6a2ea52eb 100644 --- a/src/slang-nodes/VariableDeclarationValue.ts +++ b/src/slang-nodes/VariableDeclarationValue.ts @@ -17,7 +17,7 @@ export class VariableDeclarationValue extends SlangNode { ast: ast.VariableDeclarationValue, options: ParserOptions ) { - super(ast); + super(ast, options); this.expression = extractVariant(new Expression(ast.expression, options)); diff --git a/src/slang-nodes/VersionExpression.ts b/src/slang-nodes/VersionExpression.ts index d0661724d..9ae49ffa0 100644 --- a/src/slang-nodes/VersionExpression.ts +++ b/src/slang-nodes/VersionExpression.ts @@ -4,14 +4,18 @@ import { SlangNode } from './SlangNode.js'; import { VersionRange } from './VersionRange.js'; import { VersionTerm } from './VersionTerm.js'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.ts'; + function createNonterminalVariant( - variant: ast.VersionExpression['variant'] + variant: ast.VersionExpression['variant'], + options: ParserOptions ): VersionExpression['variant'] { if (variant instanceof ast.VersionRange) { - return new VersionRange(variant); + return new VersionRange(variant, options); } if (variant instanceof ast.VersionTerm) { - return new VersionTerm(variant); + return new VersionTerm(variant, options); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -22,10 +26,10 @@ export class VersionExpression extends SlangNode { variant: VersionRange | VersionTerm; - constructor(ast: ast.VersionExpression) { - super(ast); + constructor(ast: ast.VersionExpression, options: ParserOptions) { + super(ast, options); - this.variant = createNonterminalVariant(ast.variant); + this.variant = createNonterminalVariant(ast.variant, options); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/VersionExpressionSet.ts b/src/slang-nodes/VersionExpressionSet.ts index 25d58d6c6..fe2e61d61 100644 --- a/src/slang-nodes/VersionExpressionSet.ts +++ b/src/slang-nodes/VersionExpressionSet.ts @@ -5,8 +5,9 @@ import { SlangNode } from './SlangNode.js'; import { VersionExpression } from './VersionExpression.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.ts'; const { join } = doc.builders; @@ -15,11 +16,11 @@ export class VersionExpressionSet extends SlangNode { items: VersionExpression['variant'][]; - constructor(ast: ast.VersionExpressionSet) { - super(ast, true); + constructor(ast: ast.VersionExpressionSet, options: ParserOptions) { + super(ast, options, true); this.items = ast.items.map((item) => - extractVariant(new VersionExpression(item)) + extractVariant(new VersionExpression(item, options)) ); } diff --git a/src/slang-nodes/VersionExpressionSets.ts b/src/slang-nodes/VersionExpressionSets.ts index 4a7e2f317..057a29431 100644 --- a/src/slang-nodes/VersionExpressionSets.ts +++ b/src/slang-nodes/VersionExpressionSets.ts @@ -4,8 +4,9 @@ import { SlangNode } from './SlangNode.js'; import { VersionExpressionSet } from './VersionExpressionSet.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.ts'; const { join } = doc.builders; @@ -14,10 +15,12 @@ export class VersionExpressionSets extends SlangNode { items: VersionExpressionSet[]; - constructor(ast: ast.VersionExpressionSets) { - super(ast, true); + constructor(ast: ast.VersionExpressionSets, options: ParserOptions) { + super(ast, options, true); - this.items = ast.items.map((item) => new VersionExpressionSet(item)); + this.items = ast.items.map( + (item) => new VersionExpressionSet(item, options) + ); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slang-nodes/VersionLiteral.ts b/src/slang-nodes/VersionLiteral.ts index 6d13cfb2a..8d5b03cbd 100644 --- a/src/slang-nodes/VersionLiteral.ts +++ b/src/slang-nodes/VersionLiteral.ts @@ -7,21 +7,23 @@ import { SimpleVersionLiteral } from './SimpleVersionLiteral.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.ts'; export class VersionLiteral extends SlangNode { readonly kind = NonterminalKind.VersionLiteral; variant: SimpleVersionLiteral | TerminalNode; - constructor(ast: ast.VersionLiteral) { - super(ast); + constructor(ast: ast.VersionLiteral, options: ParserOptions) { + 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 SimpleVersionLiteral(variant); + this.variant = new SimpleVersionLiteral(variant, options); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/VersionOperator.ts b/src/slang-nodes/VersionOperator.ts index a94a213f0..bfe505bb8 100644 --- a/src/slang-nodes/VersionOperator.ts +++ b/src/slang-nodes/VersionOperator.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.ts'; export class VersionOperator extends SlangNode { readonly kind = NonterminalKind.VersionOperator; variant: string; - constructor(ast: ast.VersionOperator) { - super(ast); + constructor(ast: ast.VersionOperator, options: ParserOptions) { + super(ast, options); this.variant = ast.variant.unparse(); } diff --git a/src/slang-nodes/VersionPragma.ts b/src/slang-nodes/VersionPragma.ts index 3f7fecf86..30face561 100644 --- a/src/slang-nodes/VersionPragma.ts +++ b/src/slang-nodes/VersionPragma.ts @@ -3,18 +3,19 @@ import { SlangNode } from './SlangNode.js'; import { VersionExpressionSets } from './VersionExpressionSets.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.ts'; export class VersionPragma extends SlangNode { readonly kind = NonterminalKind.VersionPragma; sets: VersionExpressionSets; - constructor(ast: ast.VersionPragma) { - super(ast); + constructor(ast: ast.VersionPragma, options: ParserOptions) { + super(ast, options); - this.sets = new VersionExpressionSets(ast.sets); + this.sets = new VersionExpressionSets(ast.sets, options); this.updateMetadata(this.sets); } diff --git a/src/slang-nodes/VersionRange.ts b/src/slang-nodes/VersionRange.ts index 9da999c9c..a03effe26 100644 --- a/src/slang-nodes/VersionRange.ts +++ b/src/slang-nodes/VersionRange.ts @@ -4,8 +4,9 @@ import { SlangNode } from './SlangNode.js'; import { VersionLiteral } from './VersionLiteral.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.ts'; export class VersionRange extends SlangNode { readonly kind = NonterminalKind.VersionRange; @@ -14,11 +15,11 @@ export class VersionRange extends SlangNode { end: VersionLiteral['variant']; - constructor(ast: ast.VersionRange) { - super(ast); + constructor(ast: ast.VersionRange, options: ParserOptions) { + super(ast, options); - this.start = extractVariant(new VersionLiteral(ast.start)); - this.end = extractVariant(new VersionLiteral(ast.end)); + this.start = extractVariant(new VersionLiteral(ast.start, options)); + this.end = extractVariant(new VersionLiteral(ast.end, options)); this.updateMetadata(this.start, this.end); } diff --git a/src/slang-nodes/VersionTerm.ts b/src/slang-nodes/VersionTerm.ts index e4a2dfc02..bb1b42290 100644 --- a/src/slang-nodes/VersionTerm.ts +++ b/src/slang-nodes/VersionTerm.ts @@ -5,8 +5,9 @@ import { VersionOperator } from './VersionOperator.js'; import { VersionLiteral } from './VersionLiteral.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.ts'; export class VersionTerm extends SlangNode { readonly kind = NonterminalKind.VersionTerm; @@ -15,13 +16,13 @@ export class VersionTerm extends SlangNode { literal: VersionLiteral['variant']; - constructor(ast: ast.VersionTerm) { - super(ast); + constructor(ast: ast.VersionTerm, options: ParserOptions) { + super(ast, options); if (ast.operator) { - this.operator = new VersionOperator(ast.operator); + this.operator = new VersionOperator(ast.operator, options); } - this.literal = extractVariant(new VersionLiteral(ast.literal)); + this.literal = extractVariant(new VersionLiteral(ast.literal, options)); this.updateMetadata(this.operator, this.literal); } diff --git a/src/slang-nodes/WhileStatement.ts b/src/slang-nodes/WhileStatement.ts index ccbd35772..9d65a4a34 100644 --- a/src/slang-nodes/WhileStatement.ts +++ b/src/slang-nodes/WhileStatement.ts @@ -19,7 +19,7 @@ export class WhileStatement extends SlangNode { body: Statement['variant']; constructor(ast: ast.WhileStatement, options: ParserOptions) { - super(ast); + super(ast, options); this.condition = extractVariant(new Expression(ast.condition, options)); this.body = extractVariant(new Statement(ast.body, options)); diff --git a/src/slang-nodes/YulArguments.ts b/src/slang-nodes/YulArguments.ts index 1309f3f1b..a8c528d18 100644 --- a/src/slang-nodes/YulArguments.ts +++ b/src/slang-nodes/YulArguments.ts @@ -15,7 +15,7 @@ export class YulArguments extends SlangNode { items: YulExpression['variant'][]; constructor(ast: ast.YulArguments, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new YulExpression(item, options)) diff --git a/src/slang-nodes/YulAssignmentOperator.ts b/src/slang-nodes/YulAssignmentOperator.ts index e23ebed1b..4a9012a74 100644 --- a/src/slang-nodes/YulAssignmentOperator.ts +++ b/src/slang-nodes/YulAssignmentOperator.ts @@ -7,21 +7,23 @@ import { YulColonAndEqual } from './YulColonAndEqual.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.ts'; export class YulAssignmentOperator extends SlangNode { readonly kind = NonterminalKind.YulAssignmentOperator; variant: YulColonAndEqual | TerminalNode; - constructor(ast: ast.YulAssignmentOperator) { - super(ast); + constructor(ast: ast.YulAssignmentOperator, options: ParserOptions) { + 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 YulColonAndEqual(variant); + this.variant = new YulColonAndEqual(variant, options); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/YulBlock.ts b/src/slang-nodes/YulBlock.ts index 7b80d6829..6328b510f 100644 --- a/src/slang-nodes/YulBlock.ts +++ b/src/slang-nodes/YulBlock.ts @@ -13,7 +13,7 @@ export class YulBlock extends SlangNode { statements: YulStatements; constructor(ast: ast.YulBlock, options: ParserOptions) { - super(ast); + super(ast, options); this.statements = new YulStatements(ast.statements, options); diff --git a/src/slang-nodes/YulBreakStatement.ts b/src/slang-nodes/YulBreakStatement.ts index 96a48843c..5a72ca6a0 100644 --- a/src/slang-nodes/YulBreakStatement.ts +++ b/src/slang-nodes/YulBreakStatement.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.ts'; export class YulBreakStatement extends SlangNode { readonly kind = NonterminalKind.YulBreakStatement; - constructor(ast: ast.YulBreakStatement) { - super(ast); + constructor(ast: ast.YulBreakStatement, options: ParserOptions) { + super(ast, options); } print(): Doc { diff --git a/src/slang-nodes/YulColonAndEqual.ts b/src/slang-nodes/YulColonAndEqual.ts index 3e9f49d2f..e36ed52de 100644 --- a/src/slang-nodes/YulColonAndEqual.ts +++ b/src/slang-nodes/YulColonAndEqual.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.ts'; export class YulColonAndEqual extends SlangNode { readonly kind = NonterminalKind.YulColonAndEqual; - constructor(ast: ast.YulColonAndEqual) { - super(ast); + constructor(ast: ast.YulColonAndEqual, options: ParserOptions) { + super(ast, options); } print(): Doc { diff --git a/src/slang-nodes/YulContinueStatement.ts b/src/slang-nodes/YulContinueStatement.ts index 93bbd3eb2..12a2b5563 100644 --- a/src/slang-nodes/YulContinueStatement.ts +++ b/src/slang-nodes/YulContinueStatement.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.ts'; export class YulContinueStatement extends SlangNode { readonly kind = NonterminalKind.YulContinueStatement; - constructor(ast: ast.YulContinueStatement) { - super(ast); + constructor(ast: ast.YulContinueStatement, options: ParserOptions) { + super(ast, options); } print(): Doc { diff --git a/src/slang-nodes/YulDefaultCase.ts b/src/slang-nodes/YulDefaultCase.ts index 9768042a0..610a4887b 100644 --- a/src/slang-nodes/YulDefaultCase.ts +++ b/src/slang-nodes/YulDefaultCase.ts @@ -13,7 +13,7 @@ export class YulDefaultCase extends SlangNode { body: YulBlock; constructor(ast: ast.YulDefaultCase, options: ParserOptions) { - super(ast); + super(ast, options); this.body = new YulBlock(ast.body, options); diff --git a/src/slang-nodes/YulEqualAndColon.ts b/src/slang-nodes/YulEqualAndColon.ts index eac4d384d..32db429eb 100644 --- a/src/slang-nodes/YulEqualAndColon.ts +++ b/src/slang-nodes/YulEqualAndColon.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.ts'; export class YulEqualAndColon extends SlangNode { readonly kind = NonterminalKind.YulEqualAndColon; - constructor(ast: ast.YulEqualAndColon) { - super(ast); + constructor(ast: ast.YulEqualAndColon, options: ParserOptions) { + super(ast, options); } print(): Doc { diff --git a/src/slang-nodes/YulExpression.ts b/src/slang-nodes/YulExpression.ts index dd697cc5c..69965e536 100644 --- a/src/slang-nodes/YulExpression.ts +++ b/src/slang-nodes/YulExpression.ts @@ -20,7 +20,7 @@ function createNonterminalVariant( return extractVariant(new YulLiteral(variant, options)); } if (variant instanceof ast.YulPath) { - return new YulPath(variant); + return new YulPath(variant, options); } const exhaustiveCheck: never = variant; throw new Error(`Unexpected variant: ${JSON.stringify(exhaustiveCheck)}`); @@ -32,7 +32,7 @@ export class YulExpression extends SlangNode { variant: YulFunctionCallExpression | YulLiteral['variant'] | YulPath; constructor(ast: ast.YulExpression, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/YulForStatement.ts b/src/slang-nodes/YulForStatement.ts index 1fdeb2b85..4f9c9923e 100644 --- a/src/slang-nodes/YulForStatement.ts +++ b/src/slang-nodes/YulForStatement.ts @@ -24,7 +24,7 @@ export class YulForStatement extends SlangNode { body: YulBlock; constructor(ast: ast.YulForStatement, options: ParserOptions) { - super(ast); + super(ast, options); this.initialization = new YulBlock(ast.initialization, options); this.condition = extractVariant(new YulExpression(ast.condition, options)); diff --git a/src/slang-nodes/YulFunctionCallExpression.ts b/src/slang-nodes/YulFunctionCallExpression.ts index 6b5f5bc4f..7cd0672f0 100644 --- a/src/slang-nodes/YulFunctionCallExpression.ts +++ b/src/slang-nodes/YulFunctionCallExpression.ts @@ -20,7 +20,7 @@ export class YulFunctionCallExpression extends SlangNode { ast: ast.YulFunctionCallExpression, options: ParserOptions ) { - super(ast); + super(ast, options); this.operand = extractVariant(new YulExpression(ast.operand, options)); this.arguments = new YulArguments(ast.arguments, options); diff --git a/src/slang-nodes/YulFunctionDefinition.ts b/src/slang-nodes/YulFunctionDefinition.ts index ce30edbbc..6aca8fc9c 100644 --- a/src/slang-nodes/YulFunctionDefinition.ts +++ b/src/slang-nodes/YulFunctionDefinition.ts @@ -22,12 +22,12 @@ export class YulFunctionDefinition extends SlangNode { body: YulBlock; constructor(ast: ast.YulFunctionDefinition, options: ParserOptions) { - super(ast); + super(ast, options); - this.name = new TerminalNode(ast.name); - this.parameters = new YulParametersDeclaration(ast.parameters); + this.name = new TerminalNode(ast.name, options); + this.parameters = new YulParametersDeclaration(ast.parameters, options); if (ast.returns) { - this.returns = new YulReturnsDeclaration(ast.returns); + this.returns = new YulReturnsDeclaration(ast.returns, options); } this.body = new YulBlock(ast.body, options); diff --git a/src/slang-nodes/YulIfStatement.ts b/src/slang-nodes/YulIfStatement.ts index 5be71f59e..25fd34da2 100644 --- a/src/slang-nodes/YulIfStatement.ts +++ b/src/slang-nodes/YulIfStatement.ts @@ -17,7 +17,7 @@ export class YulIfStatement extends SlangNode { body: YulBlock; constructor(ast: ast.YulIfStatement, options: ParserOptions) { - super(ast); + super(ast, options); this.condition = extractVariant(new YulExpression(ast.condition, options)); this.body = new YulBlock(ast.body, options); diff --git a/src/slang-nodes/YulLabel.ts b/src/slang-nodes/YulLabel.ts index a9d6b47ce..1293b2cdf 100644 --- a/src/slang-nodes/YulLabel.ts +++ b/src/slang-nodes/YulLabel.ts @@ -4,8 +4,9 @@ import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.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.ts'; const { dedent, line } = doc.builders; @@ -14,10 +15,10 @@ export class YulLabel extends SlangNode { label: TerminalNode; - constructor(ast: ast.YulLabel) { - super(ast); + constructor(ast: ast.YulLabel, options: ParserOptions) { + super(ast, options); - this.label = new TerminalNode(ast.label); + this.label = new TerminalNode(ast.label, options); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slang-nodes/YulLeaveStatement.ts b/src/slang-nodes/YulLeaveStatement.ts index eccf192b8..1e05b369f 100644 --- a/src/slang-nodes/YulLeaveStatement.ts +++ b/src/slang-nodes/YulLeaveStatement.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.ts'; export class YulLeaveStatement extends SlangNode { readonly kind = NonterminalKind.YulLeaveStatement; - constructor(ast: ast.YulLeaveStatement) { - super(ast); + constructor(ast: ast.YulLeaveStatement, options: ParserOptions) { + super(ast, options); } print(): Doc { diff --git a/src/slang-nodes/YulLiteral.ts b/src/slang-nodes/YulLiteral.ts index a14f8ee5b..fe1c4ce46 100644 --- a/src/slang-nodes/YulLiteral.ts +++ b/src/slang-nodes/YulLiteral.ts @@ -31,11 +31,11 @@ export class YulLiteral extends SlangNode { variant: HexStringLiteral | StringLiteral | TerminalNode; constructor(ast: ast.YulLiteral, options: ParserOptions) { - 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 = createNonterminalVariant(variant, options); diff --git a/src/slang-nodes/YulParameters.ts b/src/slang-nodes/YulParameters.ts index 435ddc110..7de700602 100644 --- a/src/slang-nodes/YulParameters.ts +++ b/src/slang-nodes/YulParameters.ts @@ -4,18 +4,19 @@ import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.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.ts'; export class YulParameters extends SlangNode { readonly kind = NonterminalKind.YulParameters; items: TerminalNode[]; - constructor(ast: ast.YulParameters) { - super(ast, true); + constructor(ast: ast.YulParameters, options: ParserOptions) { + super(ast, options, true); - this.items = ast.items.map((item) => new TerminalNode(item)); + this.items = ast.items.map((item) => new TerminalNode(item, options)); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slang-nodes/YulParametersDeclaration.ts b/src/slang-nodes/YulParametersDeclaration.ts index 1f283930f..8781d40ce 100644 --- a/src/slang-nodes/YulParametersDeclaration.ts +++ b/src/slang-nodes/YulParametersDeclaration.ts @@ -3,18 +3,22 @@ import { SlangNode } from './SlangNode.js'; import { YulParameters } from './YulParameters.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.ts'; export class YulParametersDeclaration extends SlangNode { readonly kind = NonterminalKind.YulParametersDeclaration; parameters: YulParameters; - constructor(ast: ast.YulParametersDeclaration) { - super(ast); + constructor( + ast: ast.YulParametersDeclaration, + options: ParserOptions + ) { + super(ast, options); - this.parameters = new YulParameters(ast.parameters); + this.parameters = new YulParameters(ast.parameters, options); this.updateMetadata(this.parameters); } diff --git a/src/slang-nodes/YulPath.ts b/src/slang-nodes/YulPath.ts index 137cbee6a..f13b548b9 100644 --- a/src/slang-nodes/YulPath.ts +++ b/src/slang-nodes/YulPath.ts @@ -4,8 +4,9 @@ import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.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.ts'; const { join } = doc.builders; @@ -14,10 +15,10 @@ export class YulPath extends SlangNode { items: TerminalNode[]; - constructor(ast: ast.YulPath) { - super(ast, true); + constructor(ast: ast.YulPath, options: ParserOptions) { + super(ast, options, true); - this.items = ast.items.map((item) => new TerminalNode(item)); + this.items = ast.items.map((item) => new TerminalNode(item, options)); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slang-nodes/YulPaths.ts b/src/slang-nodes/YulPaths.ts index f655df8e9..a9f718ddc 100644 --- a/src/slang-nodes/YulPaths.ts +++ b/src/slang-nodes/YulPaths.ts @@ -4,8 +4,9 @@ import { SlangNode } from './SlangNode.js'; import { YulPath } from './YulPath.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.ts'; const { join } = doc.builders; @@ -14,10 +15,10 @@ export class YulPaths extends SlangNode { items: YulPath[]; - constructor(ast: ast.YulPaths) { - super(ast, true); + constructor(ast: ast.YulPaths, options: ParserOptions) { + super(ast, options, true); - this.items = ast.items.map((item) => new YulPath(item)); + this.items = ast.items.map((item) => new YulPath(item, options)); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slang-nodes/YulReturnsDeclaration.ts b/src/slang-nodes/YulReturnsDeclaration.ts index a000de91d..cdceb59b4 100644 --- a/src/slang-nodes/YulReturnsDeclaration.ts +++ b/src/slang-nodes/YulReturnsDeclaration.ts @@ -5,8 +5,9 @@ import { SlangNode } from './SlangNode.js'; import { YulVariableNames } from './YulVariableNames.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.ts'; const { line } = doc.builders; @@ -15,10 +16,10 @@ export class YulReturnsDeclaration extends SlangNode { variables: YulVariableNames; - constructor(ast: ast.YulReturnsDeclaration) { - super(ast); + constructor(ast: ast.YulReturnsDeclaration, options: ParserOptions) { + super(ast, options); - this.variables = new YulVariableNames(ast.variables); + this.variables = new YulVariableNames(ast.variables, options); this.updateMetadata(this.variables); } diff --git a/src/slang-nodes/YulStackAssignmentOperator.ts b/src/slang-nodes/YulStackAssignmentOperator.ts index 0318ae8bf..8c90f5134 100644 --- a/src/slang-nodes/YulStackAssignmentOperator.ts +++ b/src/slang-nodes/YulStackAssignmentOperator.ts @@ -7,21 +7,26 @@ import { YulEqualAndColon } from './YulEqualAndColon.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; +import type { ParserOptions } from 'prettier'; +import type { AstNode } from './types.ts'; export class YulStackAssignmentOperator extends SlangNode { readonly kind = NonterminalKind.YulStackAssignmentOperator; variant: YulEqualAndColon | TerminalNode; - constructor(ast: ast.YulStackAssignmentOperator) { - super(ast); + constructor( + ast: ast.YulStackAssignmentOperator, + options: ParserOptions + ) { + 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 YulEqualAndColon(variant); + this.variant = new YulEqualAndColon(variant, options); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/YulStackAssignmentStatement.ts b/src/slang-nodes/YulStackAssignmentStatement.ts index e2bd99982..b52529503 100644 --- a/src/slang-nodes/YulStackAssignmentStatement.ts +++ b/src/slang-nodes/YulStackAssignmentStatement.ts @@ -7,8 +7,9 @@ import { YulStackAssignmentOperator } from './YulStackAssignmentOperator.js'; import { TerminalNode } from './TerminalNode.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.ts'; const { line } = doc.builders; @@ -19,13 +20,16 @@ export class YulStackAssignmentStatement extends SlangNode { variable: TerminalNode; - constructor(ast: ast.YulStackAssignmentStatement) { - super(ast); + constructor( + ast: ast.YulStackAssignmentStatement, + options: ParserOptions + ) { + super(ast, options); this.assignment = extractVariant( - new YulStackAssignmentOperator(ast.assignment) + new YulStackAssignmentOperator(ast.assignment, options) ); - this.variable = new TerminalNode(ast.variable); + this.variable = new TerminalNode(ast.variable, options); this.updateMetadata(this.assignment); } diff --git a/src/slang-nodes/YulStatement.ts b/src/slang-nodes/YulStatement.ts index 88a693eb7..de1de3f5b 100644 --- a/src/slang-nodes/YulStatement.ts +++ b/src/slang-nodes/YulStatement.ts @@ -36,7 +36,7 @@ function createNonterminalVariant( return new YulVariableAssignmentStatement(variant, options); } if (variant instanceof ast.YulStackAssignmentStatement) { - return new YulStackAssignmentStatement(variant); + return new YulStackAssignmentStatement(variant, options); } if (variant instanceof ast.YulIfStatement) { return new YulIfStatement(variant, options); @@ -48,16 +48,16 @@ function createNonterminalVariant( return new YulSwitchStatement(variant, options); } if (variant instanceof ast.YulLeaveStatement) { - return new YulLeaveStatement(variant); + return new YulLeaveStatement(variant, options); } if (variant instanceof ast.YulBreakStatement) { - return new YulBreakStatement(variant); + return new YulBreakStatement(variant, options); } if (variant instanceof ast.YulContinueStatement) { - return new YulContinueStatement(variant); + return new YulContinueStatement(variant, options); } if (variant instanceof ast.YulLabel) { - return new YulLabel(variant); + return new YulLabel(variant, options); } if (variant instanceof ast.YulExpression) { return extractVariant(new YulExpression(variant, options)); @@ -85,7 +85,7 @@ export class YulStatement extends SlangNode { | YulExpression['variant']; constructor(ast: ast.YulStatement, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/YulStatements.ts b/src/slang-nodes/YulStatements.ts index 6744f1e9b..9b0d35923 100644 --- a/src/slang-nodes/YulStatements.ts +++ b/src/slang-nodes/YulStatements.ts @@ -19,7 +19,7 @@ export class YulStatements extends SlangNode { items: YulStatement['variant'][]; constructor(ast: ast.YulStatements, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new YulStatement(item, options)) diff --git a/src/slang-nodes/YulSwitchCase.ts b/src/slang-nodes/YulSwitchCase.ts index aaba336e4..680cbce33 100644 --- a/src/slang-nodes/YulSwitchCase.ts +++ b/src/slang-nodes/YulSwitchCase.ts @@ -27,7 +27,7 @@ export class YulSwitchCase extends SlangNode { variant: YulDefaultCase | YulValueCase; constructor(ast: ast.YulSwitchCase, options: ParserOptions) { - super(ast); + super(ast, options); this.variant = createNonterminalVariant(ast.variant, options); diff --git a/src/slang-nodes/YulSwitchCases.ts b/src/slang-nodes/YulSwitchCases.ts index 0b0d672b2..4dc08f5dd 100644 --- a/src/slang-nodes/YulSwitchCases.ts +++ b/src/slang-nodes/YulSwitchCases.ts @@ -17,7 +17,7 @@ export class YulSwitchCases extends SlangNode { items: YulSwitchCase['variant'][]; constructor(ast: ast.YulSwitchCases, options: ParserOptions) { - super(ast, true); + super(ast, options, true); this.items = ast.items.map((item) => extractVariant(new YulSwitchCase(item, options)) diff --git a/src/slang-nodes/YulSwitchStatement.ts b/src/slang-nodes/YulSwitchStatement.ts index 319fa26be..aa0aa8a47 100644 --- a/src/slang-nodes/YulSwitchStatement.ts +++ b/src/slang-nodes/YulSwitchStatement.ts @@ -20,7 +20,7 @@ export class YulSwitchStatement extends SlangNode { cases: YulSwitchCases; constructor(ast: ast.YulSwitchStatement, options: ParserOptions) { - super(ast); + super(ast, options); this.expression = extractVariant( new YulExpression(ast.expression, options) diff --git a/src/slang-nodes/YulValueCase.ts b/src/slang-nodes/YulValueCase.ts index 7a8c43c18..6e6e39ff1 100644 --- a/src/slang-nodes/YulValueCase.ts +++ b/src/slang-nodes/YulValueCase.ts @@ -17,7 +17,7 @@ export class YulValueCase extends SlangNode { body: YulBlock; constructor(ast: ast.YulValueCase, options: ParserOptions) { - super(ast); + super(ast, options); this.value = extractVariant(new YulLiteral(ast.value, options)); this.body = new YulBlock(ast.body, options); diff --git a/src/slang-nodes/YulVariableAssignmentStatement.ts b/src/slang-nodes/YulVariableAssignmentStatement.ts index df314159a..53997dd22 100644 --- a/src/slang-nodes/YulVariableAssignmentStatement.ts +++ b/src/slang-nodes/YulVariableAssignmentStatement.ts @@ -26,10 +26,12 @@ export class YulVariableAssignmentStatement extends SlangNode { ast: ast.YulVariableAssignmentStatement, options: ParserOptions ) { - super(ast); + super(ast, options); - this.variables = new YulPaths(ast.variables); - this.assignment = extractVariant(new YulAssignmentOperator(ast.assignment)); + this.variables = new YulPaths(ast.variables, options); + this.assignment = extractVariant( + new YulAssignmentOperator(ast.assignment, options) + ); this.expression = extractVariant( new YulExpression(ast.expression, options) ); diff --git a/src/slang-nodes/YulVariableDeclarationStatement.ts b/src/slang-nodes/YulVariableDeclarationStatement.ts index d95766e6f..db6ed665e 100644 --- a/src/slang-nodes/YulVariableDeclarationStatement.ts +++ b/src/slang-nodes/YulVariableDeclarationStatement.ts @@ -20,9 +20,9 @@ export class YulVariableDeclarationStatement extends SlangNode { ast: ast.YulVariableDeclarationStatement, options: ParserOptions ) { - super(ast); + super(ast, options); - this.variables = new YulVariableNames(ast.variables); + this.variables = new YulVariableNames(ast.variables, options); if (ast.value) { this.value = new YulVariableDeclarationValue(ast.value, options); } diff --git a/src/slang-nodes/YulVariableDeclarationValue.ts b/src/slang-nodes/YulVariableDeclarationValue.ts index 9a249df21..5ff259db8 100644 --- a/src/slang-nodes/YulVariableDeclarationValue.ts +++ b/src/slang-nodes/YulVariableDeclarationValue.ts @@ -20,9 +20,11 @@ export class YulVariableDeclarationValue extends SlangNode { ast: ast.YulVariableDeclarationValue, options: ParserOptions ) { - super(ast); + super(ast, options); - this.assignment = extractVariant(new YulAssignmentOperator(ast.assignment)); + this.assignment = extractVariant( + new YulAssignmentOperator(ast.assignment, options) + ); this.expression = extractVariant( new YulExpression(ast.expression, options) ); diff --git a/src/slang-nodes/YulVariableNames.ts b/src/slang-nodes/YulVariableNames.ts index 823302471..020fb0aa5 100644 --- a/src/slang-nodes/YulVariableNames.ts +++ b/src/slang-nodes/YulVariableNames.ts @@ -5,8 +5,9 @@ import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.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'; const { line } = doc.builders; @@ -15,10 +16,10 @@ export class YulVariableNames extends SlangNode { items: TerminalNode[]; - constructor(ast: ast.YulVariableNames) { - super(ast, true); + constructor(ast: ast.YulVariableNames, options: ParserOptions) { + super(ast, options, true); - this.items = ast.items.map((item) => new TerminalNode(item)); + this.items = ast.items.map((item) => new TerminalNode(item, options)); } print(path: AstPath, print: PrintFunction): Doc { diff --git a/src/slangSolidityParser.ts b/src/slangSolidityParser.ts index 408e7bdfd..26d40714c 100644 --- a/src/slangSolidityParser.ts +++ b/src/slangSolidityParser.ts @@ -1,6 +1,5 @@ // https://prettier.io/docs/en/plugins.html#parsers import { SourceUnit as SlangSourceUnit } from '@nomicfoundation/slang/ast'; -import { clearComments, clearOffsets } from './slang-nodes/SlangNode.js'; import { createParser } from './slang-utils/create-parser.js'; import { SourceUnit } from './slang-nodes/SourceUnit.js'; @@ -15,6 +14,8 @@ export default function parse( // We update the compiler version by the inferred one. options.compiler = parser.languageVersion; + options._prettier_solidity_offsets = new Map(); + options._prettier_solidity_comments = []; const parsed = new SourceUnit( new SlangSourceUnit(parseOutput.tree.asNonterminalNode()), options @@ -22,7 +23,8 @@ export default function parse( // Because of comments being extracted like a Russian doll, the order needs // to be fixed at the end. - parsed.comments = clearComments().sort((a, b) => a.loc.start - b.loc.start); - clearOffsets(); + parsed.comments = options._prettier_solidity_comments.sort( + (a, b) => a.loc.start - b.loc.start + ); return parsed; } diff --git a/src/types.d.ts b/src/types.d.ts index 5193b7b15..bd601f297 100644 --- a/src/types.d.ts +++ b/src/types.d.ts @@ -1,11 +1,13 @@ import type * as ast from '@nomicfoundation/slang/ast'; import type { AstPath, Doc } from 'prettier'; -import type { AstNode } from './slang-nodes/types.d.ts'; +import type { AstNode, Comment } from './slang-nodes/types.d.ts'; // Adding our own options to prettier's `ParserOptions` interface. declare module 'prettier' { interface ParserOptions { compiler: string; + _prettier_solidity_offsets: Map; + _prettier_solidity_comments: Comment[]; } } From f938f70c4e5fc44a4f2046a752a306ed37506a7e Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 28 Jan 2026 21:23:33 -0300 Subject: [PATCH 2/2] fixing extensions --- src/slang-nodes/AbicoderPragma.ts | 2 +- src/slang-nodes/AbicoderVersion.ts | 2 +- src/slang-nodes/AddressType.ts | 2 +- src/slang-nodes/BreakStatement.ts | 2 +- src/slang-nodes/ContinueStatement.ts | 2 +- src/slang-nodes/DecimalNumberExpression.ts | 2 +- src/slang-nodes/ElementaryType.ts | 2 +- src/slang-nodes/SimpleVersionLiteral.ts | 2 +- src/slang-nodes/TerminalNode.ts | 2 +- src/slang-nodes/ThrowStatement.ts | 2 +- src/slang-nodes/UntypedTupleMember.ts | 2 +- src/slang-nodes/UserDefinedValueTypeDefinition.ts | 2 +- src/slang-nodes/UsingAlias.ts | 2 +- src/slang-nodes/UsingClause.ts | 2 +- src/slang-nodes/UsingDeconstruction.ts | 2 +- src/slang-nodes/UsingDeconstructionSymbol.ts | 2 +- src/slang-nodes/UsingOperator.ts | 2 +- src/slang-nodes/VersionExpression.ts | 2 +- src/slang-nodes/VersionExpressionSet.ts | 2 +- src/slang-nodes/VersionExpressionSets.ts | 2 +- src/slang-nodes/VersionLiteral.ts | 2 +- src/slang-nodes/VersionOperator.ts | 2 +- src/slang-nodes/VersionPragma.ts | 2 +- src/slang-nodes/VersionRange.ts | 2 +- src/slang-nodes/VersionTerm.ts | 2 +- src/slang-nodes/YulAssignmentOperator.ts | 2 +- src/slang-nodes/YulBreakStatement.ts | 2 +- src/slang-nodes/YulColonAndEqual.ts | 2 +- src/slang-nodes/YulContinueStatement.ts | 2 +- src/slang-nodes/YulEqualAndColon.ts | 2 +- src/slang-nodes/YulLabel.ts | 2 +- src/slang-nodes/YulLeaveStatement.ts | 2 +- src/slang-nodes/YulParameters.ts | 2 +- src/slang-nodes/YulParametersDeclaration.ts | 2 +- src/slang-nodes/YulPath.ts | 2 +- src/slang-nodes/YulPaths.ts | 2 +- src/slang-nodes/YulReturnsDeclaration.ts | 2 +- src/slang-nodes/YulStackAssignmentOperator.ts | 2 +- src/slang-nodes/YulStackAssignmentStatement.ts | 2 +- src/slang-utils/extract-variant.ts | 2 +- 40 files changed, 40 insertions(+), 40 deletions(-) diff --git a/src/slang-nodes/AbicoderPragma.ts b/src/slang-nodes/AbicoderPragma.ts index 3f2e9b05e..e8b48aad2 100644 --- a/src/slang-nodes/AbicoderPragma.ts +++ b/src/slang-nodes/AbicoderPragma.ts @@ -5,7 +5,7 @@ import { AbicoderVersion } from './AbicoderVersion.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class AbicoderPragma extends SlangNode { readonly kind = NonterminalKind.AbicoderPragma; diff --git a/src/slang-nodes/AbicoderVersion.ts b/src/slang-nodes/AbicoderVersion.ts index 4a3a55091..7f0da1dae 100644 --- a/src/slang-nodes/AbicoderVersion.ts +++ b/src/slang-nodes/AbicoderVersion.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class AbicoderVersion extends SlangNode { readonly kind = NonterminalKind.AbicoderVersion; diff --git a/src/slang-nodes/AddressType.ts b/src/slang-nodes/AddressType.ts index f4d66cfa0..3fbbac815 100644 --- a/src/slang-nodes/AddressType.ts +++ b/src/slang-nodes/AddressType.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class AddressType extends SlangNode { readonly kind = NonterminalKind.AddressType; diff --git a/src/slang-nodes/BreakStatement.ts b/src/slang-nodes/BreakStatement.ts index 532ff0ae0..4267e90d5 100644 --- a/src/slang-nodes/BreakStatement.ts +++ b/src/slang-nodes/BreakStatement.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class BreakStatement extends SlangNode { readonly kind = NonterminalKind.BreakStatement; diff --git a/src/slang-nodes/ContinueStatement.ts b/src/slang-nodes/ContinueStatement.ts index d9e0400a3..8a5742916 100644 --- a/src/slang-nodes/ContinueStatement.ts +++ b/src/slang-nodes/ContinueStatement.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class ContinueStatement extends SlangNode { readonly kind = NonterminalKind.ContinueStatement; diff --git a/src/slang-nodes/DecimalNumberExpression.ts b/src/slang-nodes/DecimalNumberExpression.ts index 6ef5d26be..9d1755ee1 100644 --- a/src/slang-nodes/DecimalNumberExpression.ts +++ b/src/slang-nodes/DecimalNumberExpression.ts @@ -6,7 +6,7 @@ import { NumberUnit } from './NumberUnit.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class DecimalNumberExpression extends SlangNode { readonly kind = NonterminalKind.DecimalNumberExpression; diff --git a/src/slang-nodes/ElementaryType.ts b/src/slang-nodes/ElementaryType.ts index a23a39669..30ff902ec 100644 --- a/src/slang-nodes/ElementaryType.ts +++ b/src/slang-nodes/ElementaryType.ts @@ -8,7 +8,7 @@ import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class ElementaryType extends SlangNode { readonly kind = NonterminalKind.ElementaryType; diff --git a/src/slang-nodes/SimpleVersionLiteral.ts b/src/slang-nodes/SimpleVersionLiteral.ts index 09b2de39c..f9ecf9647 100644 --- a/src/slang-nodes/SimpleVersionLiteral.ts +++ b/src/slang-nodes/SimpleVersionLiteral.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class SimpleVersionLiteral extends SlangNode { readonly kind = NonterminalKind.SimpleVersionLiteral; diff --git a/src/slang-nodes/TerminalNode.ts b/src/slang-nodes/TerminalNode.ts index b67f12994..07a067fc9 100644 --- a/src/slang-nodes/TerminalNode.ts +++ b/src/slang-nodes/TerminalNode.ts @@ -5,7 +5,7 @@ import type { TerminalKind } from '@nomicfoundation/slang/cst'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class TerminalNode extends SlangNode { kind: TerminalKind; diff --git a/src/slang-nodes/ThrowStatement.ts b/src/slang-nodes/ThrowStatement.ts index 58728bf7e..8ff6361bc 100644 --- a/src/slang-nodes/ThrowStatement.ts +++ b/src/slang-nodes/ThrowStatement.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class ThrowStatement extends SlangNode { readonly kind = NonterminalKind.ThrowStatement; diff --git a/src/slang-nodes/UntypedTupleMember.ts b/src/slang-nodes/UntypedTupleMember.ts index 411dce9a9..118e663aa 100644 --- a/src/slang-nodes/UntypedTupleMember.ts +++ b/src/slang-nodes/UntypedTupleMember.ts @@ -7,7 +7,7 @@ import { TerminalNode } from './TerminalNode.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class UntypedTupleMember extends SlangNode { readonly kind = NonterminalKind.UntypedTupleMember; diff --git a/src/slang-nodes/UserDefinedValueTypeDefinition.ts b/src/slang-nodes/UserDefinedValueTypeDefinition.ts index 56bee7d24..297909f6f 100644 --- a/src/slang-nodes/UserDefinedValueTypeDefinition.ts +++ b/src/slang-nodes/UserDefinedValueTypeDefinition.ts @@ -7,7 +7,7 @@ import { ElementaryType } from './ElementaryType.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class UserDefinedValueTypeDefinition extends SlangNode { readonly kind = NonterminalKind.UserDefinedValueTypeDefinition; diff --git a/src/slang-nodes/UsingAlias.ts b/src/slang-nodes/UsingAlias.ts index 0d09fd75e..39f0bc740 100644 --- a/src/slang-nodes/UsingAlias.ts +++ b/src/slang-nodes/UsingAlias.ts @@ -5,7 +5,7 @@ import { UsingOperator } from './UsingOperator.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class UsingAlias extends SlangNode { readonly kind = NonterminalKind.UsingAlias; diff --git a/src/slang-nodes/UsingClause.ts b/src/slang-nodes/UsingClause.ts index dd0edd36e..86abb68d1 100644 --- a/src/slang-nodes/UsingClause.ts +++ b/src/slang-nodes/UsingClause.ts @@ -5,7 +5,7 @@ import { IdentifierPath } from './IdentifierPath.js'; import { UsingDeconstruction } from './UsingDeconstruction.js'; import type { ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; function createNonterminalVariant( variant: ast.UsingClause['variant'], diff --git a/src/slang-nodes/UsingDeconstruction.ts b/src/slang-nodes/UsingDeconstruction.ts index 72b4f531e..31ddf953f 100644 --- a/src/slang-nodes/UsingDeconstruction.ts +++ b/src/slang-nodes/UsingDeconstruction.ts @@ -5,7 +5,7 @@ import { UsingDeconstructionSymbols } from './UsingDeconstructionSymbols.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class UsingDeconstruction extends SlangNode { readonly kind = NonterminalKind.UsingDeconstruction; diff --git a/src/slang-nodes/UsingDeconstructionSymbol.ts b/src/slang-nodes/UsingDeconstructionSymbol.ts index 00246653e..0306fadf0 100644 --- a/src/slang-nodes/UsingDeconstructionSymbol.ts +++ b/src/slang-nodes/UsingDeconstructionSymbol.ts @@ -6,7 +6,7 @@ import { UsingAlias } from './UsingAlias.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class UsingDeconstructionSymbol extends SlangNode { readonly kind = NonterminalKind.UsingDeconstructionSymbol; diff --git a/src/slang-nodes/UsingOperator.ts b/src/slang-nodes/UsingOperator.ts index 4111af352..d91998e95 100644 --- a/src/slang-nodes/UsingOperator.ts +++ b/src/slang-nodes/UsingOperator.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class UsingOperator extends SlangNode { readonly kind = NonterminalKind.UsingOperator; diff --git a/src/slang-nodes/VersionExpression.ts b/src/slang-nodes/VersionExpression.ts index 9ae49ffa0..2c91197cc 100644 --- a/src/slang-nodes/VersionExpression.ts +++ b/src/slang-nodes/VersionExpression.ts @@ -5,7 +5,7 @@ import { VersionRange } from './VersionRange.js'; import { VersionTerm } from './VersionTerm.js'; import type { ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; function createNonterminalVariant( variant: ast.VersionExpression['variant'], diff --git a/src/slang-nodes/VersionExpressionSet.ts b/src/slang-nodes/VersionExpressionSet.ts index fe2e61d61..e9fe4f502 100644 --- a/src/slang-nodes/VersionExpressionSet.ts +++ b/src/slang-nodes/VersionExpressionSet.ts @@ -7,7 +7,7 @@ import { VersionExpression } from './VersionExpression.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; const { join } = doc.builders; diff --git a/src/slang-nodes/VersionExpressionSets.ts b/src/slang-nodes/VersionExpressionSets.ts index 057a29431..5bb742ed5 100644 --- a/src/slang-nodes/VersionExpressionSets.ts +++ b/src/slang-nodes/VersionExpressionSets.ts @@ -6,7 +6,7 @@ import { VersionExpressionSet } from './VersionExpressionSet.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; const { join } = doc.builders; diff --git a/src/slang-nodes/VersionLiteral.ts b/src/slang-nodes/VersionLiteral.ts index 8d5b03cbd..9fbb9f826 100644 --- a/src/slang-nodes/VersionLiteral.ts +++ b/src/slang-nodes/VersionLiteral.ts @@ -8,7 +8,7 @@ import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class VersionLiteral extends SlangNode { readonly kind = NonterminalKind.VersionLiteral; diff --git a/src/slang-nodes/VersionOperator.ts b/src/slang-nodes/VersionOperator.ts index bfe505bb8..ec8aeea98 100644 --- a/src/slang-nodes/VersionOperator.ts +++ b/src/slang-nodes/VersionOperator.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class VersionOperator extends SlangNode { readonly kind = NonterminalKind.VersionOperator; diff --git a/src/slang-nodes/VersionPragma.ts b/src/slang-nodes/VersionPragma.ts index 30face561..0474f428f 100644 --- a/src/slang-nodes/VersionPragma.ts +++ b/src/slang-nodes/VersionPragma.ts @@ -5,7 +5,7 @@ import { VersionExpressionSets } from './VersionExpressionSets.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class VersionPragma extends SlangNode { readonly kind = NonterminalKind.VersionPragma; diff --git a/src/slang-nodes/VersionRange.ts b/src/slang-nodes/VersionRange.ts index a03effe26..6c7347855 100644 --- a/src/slang-nodes/VersionRange.ts +++ b/src/slang-nodes/VersionRange.ts @@ -6,7 +6,7 @@ import { VersionLiteral } from './VersionLiteral.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class VersionRange extends SlangNode { readonly kind = NonterminalKind.VersionRange; diff --git a/src/slang-nodes/VersionTerm.ts b/src/slang-nodes/VersionTerm.ts index bb1b42290..0c752afaf 100644 --- a/src/slang-nodes/VersionTerm.ts +++ b/src/slang-nodes/VersionTerm.ts @@ -7,7 +7,7 @@ import { VersionLiteral } from './VersionLiteral.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class VersionTerm extends SlangNode { readonly kind = NonterminalKind.VersionTerm; diff --git a/src/slang-nodes/YulAssignmentOperator.ts b/src/slang-nodes/YulAssignmentOperator.ts index 4a9012a74..841325033 100644 --- a/src/slang-nodes/YulAssignmentOperator.ts +++ b/src/slang-nodes/YulAssignmentOperator.ts @@ -8,7 +8,7 @@ import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class YulAssignmentOperator extends SlangNode { readonly kind = NonterminalKind.YulAssignmentOperator; diff --git a/src/slang-nodes/YulBreakStatement.ts b/src/slang-nodes/YulBreakStatement.ts index 5a72ca6a0..018bbaced 100644 --- a/src/slang-nodes/YulBreakStatement.ts +++ b/src/slang-nodes/YulBreakStatement.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class YulBreakStatement extends SlangNode { readonly kind = NonterminalKind.YulBreakStatement; diff --git a/src/slang-nodes/YulColonAndEqual.ts b/src/slang-nodes/YulColonAndEqual.ts index e36ed52de..bf5f5073b 100644 --- a/src/slang-nodes/YulColonAndEqual.ts +++ b/src/slang-nodes/YulColonAndEqual.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class YulColonAndEqual extends SlangNode { readonly kind = NonterminalKind.YulColonAndEqual; diff --git a/src/slang-nodes/YulContinueStatement.ts b/src/slang-nodes/YulContinueStatement.ts index 12a2b5563..a863df3d2 100644 --- a/src/slang-nodes/YulContinueStatement.ts +++ b/src/slang-nodes/YulContinueStatement.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class YulContinueStatement extends SlangNode { readonly kind = NonterminalKind.YulContinueStatement; diff --git a/src/slang-nodes/YulEqualAndColon.ts b/src/slang-nodes/YulEqualAndColon.ts index 32db429eb..fd2df0461 100644 --- a/src/slang-nodes/YulEqualAndColon.ts +++ b/src/slang-nodes/YulEqualAndColon.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class YulEqualAndColon extends SlangNode { readonly kind = NonterminalKind.YulEqualAndColon; diff --git a/src/slang-nodes/YulLabel.ts b/src/slang-nodes/YulLabel.ts index 1293b2cdf..42c28cf39 100644 --- a/src/slang-nodes/YulLabel.ts +++ b/src/slang-nodes/YulLabel.ts @@ -6,7 +6,7 @@ import { TerminalNode } from './TerminalNode.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; const { dedent, line } = doc.builders; diff --git a/src/slang-nodes/YulLeaveStatement.ts b/src/slang-nodes/YulLeaveStatement.ts index 1e05b369f..32b8ad2c4 100644 --- a/src/slang-nodes/YulLeaveStatement.ts +++ b/src/slang-nodes/YulLeaveStatement.ts @@ -3,7 +3,7 @@ import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { Doc, ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class YulLeaveStatement extends SlangNode { readonly kind = NonterminalKind.YulLeaveStatement; diff --git a/src/slang-nodes/YulParameters.ts b/src/slang-nodes/YulParameters.ts index 7de700602..b8e9a06c3 100644 --- a/src/slang-nodes/YulParameters.ts +++ b/src/slang-nodes/YulParameters.ts @@ -6,7 +6,7 @@ import { TerminalNode } from './TerminalNode.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class YulParameters extends SlangNode { readonly kind = NonterminalKind.YulParameters; diff --git a/src/slang-nodes/YulParametersDeclaration.ts b/src/slang-nodes/YulParametersDeclaration.ts index 8781d40ce..f9c7f120f 100644 --- a/src/slang-nodes/YulParametersDeclaration.ts +++ b/src/slang-nodes/YulParametersDeclaration.ts @@ -5,7 +5,7 @@ import { YulParameters } from './YulParameters.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class YulParametersDeclaration extends SlangNode { readonly kind = NonterminalKind.YulParametersDeclaration; diff --git a/src/slang-nodes/YulPath.ts b/src/slang-nodes/YulPath.ts index f13b548b9..c853b66b5 100644 --- a/src/slang-nodes/YulPath.ts +++ b/src/slang-nodes/YulPath.ts @@ -6,7 +6,7 @@ import { TerminalNode } from './TerminalNode.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; const { join } = doc.builders; diff --git a/src/slang-nodes/YulPaths.ts b/src/slang-nodes/YulPaths.ts index a9f718ddc..0737751b9 100644 --- a/src/slang-nodes/YulPaths.ts +++ b/src/slang-nodes/YulPaths.ts @@ -6,7 +6,7 @@ import { YulPath } from './YulPath.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; const { join } = doc.builders; diff --git a/src/slang-nodes/YulReturnsDeclaration.ts b/src/slang-nodes/YulReturnsDeclaration.ts index cdceb59b4..13088c854 100644 --- a/src/slang-nodes/YulReturnsDeclaration.ts +++ b/src/slang-nodes/YulReturnsDeclaration.ts @@ -7,7 +7,7 @@ import { YulVariableNames } from './YulVariableNames.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; const { line } = doc.builders; diff --git a/src/slang-nodes/YulStackAssignmentOperator.ts b/src/slang-nodes/YulStackAssignmentOperator.ts index 8c90f5134..c625cf2ab 100644 --- a/src/slang-nodes/YulStackAssignmentOperator.ts +++ b/src/slang-nodes/YulStackAssignmentOperator.ts @@ -8,7 +8,7 @@ import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; import type { ParserOptions } from 'prettier'; -import type { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; export class YulStackAssignmentOperator extends SlangNode { readonly kind = NonterminalKind.YulStackAssignmentOperator; diff --git a/src/slang-nodes/YulStackAssignmentStatement.ts b/src/slang-nodes/YulStackAssignmentStatement.ts index b52529503..3f4a95eb6 100644 --- a/src/slang-nodes/YulStackAssignmentStatement.ts +++ b/src/slang-nodes/YulStackAssignmentStatement.ts @@ -9,7 +9,7 @@ import { TerminalNode } from './TerminalNode.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 { AstNode } from './types.ts'; +import type { AstNode } from './types.d.ts'; const { line } = doc.builders; diff --git a/src/slang-utils/extract-variant.ts b/src/slang-utils/extract-variant.ts index 4ded9b6e4..5abce7b1e 100644 --- a/src/slang-utils/extract-variant.ts +++ b/src/slang-utils/extract-variant.ts @@ -1,4 +1,4 @@ -import type { StrictPolymorphicNode } from '../slang-nodes/types.ts'; +import type { StrictPolymorphicNode } from '../slang-nodes/types.d.ts'; export function extractVariant({ variant,