From 27ccf55c74cf1a633d40eaa6fd49681ec22d3f04 Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 22 Apr 2026 15:54:54 -0400 Subject: [PATCH 1/4] parser options should be a part of collected metadata to standardise all constructor signatures and depollute the class instantiations --- src/slang-nodes/AdditiveExpression.ts | 10 +++---- src/slang-nodes/AndExpression.ts | 10 +++---- src/slang-nodes/ArgumentsDeclaration.ts | 10 ++----- src/slang-nodes/ArrayExpression.ts | 11 +++----- src/slang-nodes/ArrayTypeName.ts | 17 +++--------- src/slang-nodes/ArrayValues.ts | 11 +++----- src/slang-nodes/AssemblyFlags.ts | 13 +++------ src/slang-nodes/AssemblyFlagsDeclaration.ts | 11 +++----- src/slang-nodes/AssemblyStatement.ts | 15 ++++------- src/slang-nodes/AssignmentExpression.ts | 13 +++------ src/slang-nodes/BitwiseAndExpression.ts | 10 +++---- src/slang-nodes/BitwiseOrExpression.ts | 10 +++---- src/slang-nodes/BitwiseXorExpression.ts | 10 +++---- src/slang-nodes/Block.ts | 11 +++----- src/slang-nodes/CallOptions.ts | 10 ++----- src/slang-nodes/CallOptionsExpression.ts | 15 +++-------- src/slang-nodes/CatchClause.ts | 13 +++------ src/slang-nodes/CatchClauseError.ts | 15 +++-------- src/slang-nodes/CatchClauses.ts | 13 +++------ src/slang-nodes/ConditionalExpression.ts | 16 ++++------- src/slang-nodes/ConstantDefinition.ts | 15 +++-------- src/slang-nodes/ConstructorAttribute.ts | 10 ++----- src/slang-nodes/ConstructorAttributes.ts | 11 +++----- src/slang-nodes/ConstructorDefinition.ts | 23 ++++------------ src/slang-nodes/ContractDefinition.ts | 19 ++++--------- src/slang-nodes/ContractMember.ts | 10 ++----- src/slang-nodes/ContractMembers.ts | 8 ++---- src/slang-nodes/ContractSpecifier.ts | 10 ++----- src/slang-nodes/ContractSpecifiers.ts | 11 +++----- src/slang-nodes/DoWhileStatement.ts | 15 +++-------- src/slang-nodes/ElseBranch.ts | 11 +++----- src/slang-nodes/EmitStatement.ts | 11 +++----- src/slang-nodes/EqualityExpression.ts | 10 +++---- src/slang-nodes/ErrorDefinition.ts | 15 +++-------- src/slang-nodes/ErrorParameter.ts | 13 +++------ src/slang-nodes/ErrorParameters.ts | 13 +++------ src/slang-nodes/ErrorParametersDeclaration.ts | 8 +++--- src/slang-nodes/EventDefinition.ts | 15 +++-------- src/slang-nodes/EventParameter.ts | 13 +++------ src/slang-nodes/EventParameters.ts | 13 +++------ src/slang-nodes/EventParametersDeclaration.ts | 8 +++--- src/slang-nodes/ExperimentalFeature.ts | 10 ++----- src/slang-nodes/ExperimentalPragma.ts | 11 +++----- src/slang-nodes/ExponentiationExpression.ts | 10 +++---- src/slang-nodes/Expression.ts | 10 ++----- src/slang-nodes/ExpressionStatement.ts | 13 +++------ src/slang-nodes/FallbackFunctionAttribute.ts | 7 ++--- src/slang-nodes/FallbackFunctionAttributes.ts | 8 +++--- src/slang-nodes/FallbackFunctionDefinition.ts | 22 +++++---------- src/slang-nodes/ForStatement.ts | 19 +++++-------- src/slang-nodes/ForStatementCondition.ts | 10 ++----- src/slang-nodes/ForStatementInitialization.ts | 7 ++--- src/slang-nodes/FunctionAttribute.ts | 10 ++----- src/slang-nodes/FunctionAttributes.ts | 11 +++----- src/slang-nodes/FunctionBody.ts | 10 ++----- src/slang-nodes/FunctionCallExpression.ts | 15 +++-------- src/slang-nodes/FunctionDefinition.ts | 27 +++++-------------- src/slang-nodes/FunctionType.ts | 17 +++--------- src/slang-nodes/HexStringLiteral.ts | 11 +++----- src/slang-nodes/HexStringLiterals.ts | 13 +++------ src/slang-nodes/IfStatement.ts | 17 ++++-------- src/slang-nodes/ImportClause.ts | 10 ++----- src/slang-nodes/ImportDeconstruction.ts | 11 +++----- src/slang-nodes/ImportDirective.ts | 13 +++------ src/slang-nodes/IndexAccessEnd.ts | 11 +++----- src/slang-nodes/IndexAccessExpression.ts | 19 ++++--------- src/slang-nodes/InequalityExpression.ts | 10 +++---- src/slang-nodes/InheritanceSpecifier.ts | 11 +++----- src/slang-nodes/InheritanceType.ts | 11 +++----- src/slang-nodes/InheritanceTypes.ts | 13 +++------ src/slang-nodes/InterfaceDefinition.ts | 17 +++--------- src/slang-nodes/InterfaceMembers.ts | 8 ++---- src/slang-nodes/LibraryDefinition.ts | 13 +++------ src/slang-nodes/LibraryMembers.ts | 8 ++---- src/slang-nodes/MappingType.ts | 11 +++----- src/slang-nodes/MappingValue.ts | 13 +++------ src/slang-nodes/MemberAccessExpression.ts | 12 +++------ src/slang-nodes/ModifierDefinition.ts | 17 +++--------- src/slang-nodes/ModifierInvocation.ts | 11 +++----- src/slang-nodes/MultiplicativeExpression.ts | 10 +++---- src/slang-nodes/NamedArgument.ts | 11 +++----- src/slang-nodes/NamedArgumentGroup.ts | 11 +++----- src/slang-nodes/NamedArguments.ts | 10 ++----- src/slang-nodes/NamedArgumentsDeclaration.ts | 12 +++------ src/slang-nodes/NamedImport.ts | 11 +++----- src/slang-nodes/NewExpression.ts | 13 +++------ src/slang-nodes/OrExpression.ts | 10 +++---- src/slang-nodes/Parameter.ts | 13 +++------ src/slang-nodes/Parameters.ts | 10 ++----- src/slang-nodes/ParametersDeclaration.ts | 11 +++----- src/slang-nodes/PathImport.ts | 11 +++----- src/slang-nodes/PositionalArguments.ts | 8 ++---- .../PositionalArgumentsDeclaration.ts | 8 +++--- src/slang-nodes/PostfixExpression.ts | 13 +++------ src/slang-nodes/Pragma.ts | 10 ++----- src/slang-nodes/PragmaDirective.ts | 11 +++----- src/slang-nodes/PrefixExpression.ts | 13 +++------ src/slang-nodes/ReceiveFunctionAttribute.ts | 10 ++----- src/slang-nodes/ReceiveFunctionAttributes.ts | 8 +++--- src/slang-nodes/ReceiveFunctionDefinition.ts | 20 ++++---------- src/slang-nodes/ReturnStatement.ts | 8 ++---- src/slang-nodes/ReturnsDeclaration.ts | 15 +++-------- src/slang-nodes/RevertStatement.ts | 11 +++----- src/slang-nodes/ShiftExpression.ts | 10 +++---- src/slang-nodes/SourceUnit.ts | 8 ++---- src/slang-nodes/SourceUnitMember.ts | 10 ++----- src/slang-nodes/SourceUnitMembers.ts | 8 ++---- src/slang-nodes/StateVariableDefinition.ts | 19 +++---------- .../StateVariableDefinitionValue.ts | 8 +++--- src/slang-nodes/Statement.ts | 12 +++------ src/slang-nodes/Statements.ts | 8 ++---- src/slang-nodes/StorageLayoutSpecifier.ts | 13 +++------ src/slang-nodes/StringExpression.ts | 10 ++----- src/slang-nodes/StringLiteral.ts | 11 +++----- src/slang-nodes/StringLiterals.ts | 13 +++------ src/slang-nodes/StructDefinition.ts | 11 +++----- src/slang-nodes/StructMember.ts | 13 +++------ src/slang-nodes/StructMembers.ts | 13 +++------ src/slang-nodes/TryStatement.ts | 19 +++++-------- src/slang-nodes/TupleDeconstructionElement.ts | 10 +++---- .../TupleDeconstructionElements.ts | 8 +++--- .../TupleDeconstructionStatement.ts | 16 +++-------- src/slang-nodes/TupleExpression.ts | 11 +++----- src/slang-nodes/TupleMember.ts | 10 ++----- src/slang-nodes/TupleValue.ts | 11 +++----- src/slang-nodes/TupleValues.ts | 13 +++------ src/slang-nodes/TypeExpression.ts | 13 +++------ src/slang-nodes/TypeName.ts | 10 ++----- src/slang-nodes/TypedTupleMember.ts | 13 +++------ src/slang-nodes/UncheckedBlock.ts | 11 +++----- src/slang-nodes/UnicodeStringLiteral.ts | 11 +++----- src/slang-nodes/UnicodeStringLiterals.ts | 11 +++----- src/slang-nodes/UnnamedFunctionAttribute.ts | 10 ++----- src/slang-nodes/UnnamedFunctionAttributes.ts | 8 +++--- src/slang-nodes/UnnamedFunctionDefinition.ts | 20 ++++---------- src/slang-nodes/UsingDirective.ts | 13 +++------ src/slang-nodes/UsingTarget.ts | 10 ++----- .../VariableDeclarationStatement.ts | 10 +++---- src/slang-nodes/VariableDeclarationType.ts | 10 ++----- src/slang-nodes/VariableDeclarationValue.ts | 13 +++------ src/slang-nodes/WhileStatement.ts | 15 +++-------- src/slang-nodes/YulArguments.ts | 11 +++----- src/slang-nodes/YulBlock.ts | 11 +++----- src/slang-nodes/YulDefaultCase.ts | 11 +++----- src/slang-nodes/YulExpression.ts | 10 ++----- src/slang-nodes/YulForStatement.ts | 17 +++++------- src/slang-nodes/YulFunctionCallExpression.ts | 12 +++------ src/slang-nodes/YulFunctionDefinition.ts | 11 +++----- src/slang-nodes/YulIfStatement.ts | 13 +++------ src/slang-nodes/YulLiteral.ts | 10 ++----- src/slang-nodes/YulStatement.ts | 12 +++------ src/slang-nodes/YulStatements.ts | 8 ++---- src/slang-nodes/YulSwitchCase.ts | 10 ++----- src/slang-nodes/YulSwitchCases.ts | 11 +++----- src/slang-nodes/YulSwitchStatement.ts | 13 +++------ src/slang-nodes/YulValueCase.ts | 13 +++------ .../YulVariableAssignmentStatement.ts | 8 +++--- .../YulVariableDeclarationStatement.ts | 12 +++------ .../YulVariableDeclarationValue.ts | 8 +++--- .../create-nonterminal-variant-creator.ts | 12 ++++----- src/slangSolidityParser.ts | 3 +-- src/types.d.ts | 3 ++- 162 files changed, 501 insertions(+), 1412 deletions(-) diff --git a/src/slang-nodes/AdditiveExpression.ts b/src/slang-nodes/AdditiveExpression.ts index 36d2d55c9..587e5deb3 100644 --- a/src/slang-nodes/AdditiveExpression.ts +++ b/src/slang-nodes/AdditiveExpression.ts @@ -35,19 +35,15 @@ export class AdditiveExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.AdditiveExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.AdditiveExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/AndExpression.ts b/src/slang-nodes/AndExpression.ts index 457a32db6..15942e849 100644 --- a/src/slang-nodes/AndExpression.ts +++ b/src/slang-nodes/AndExpression.ts @@ -18,19 +18,15 @@ export class AndExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.AndExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.AndExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/ArgumentsDeclaration.ts b/src/slang-nodes/ArgumentsDeclaration.ts index 0f3bd614c..27cf09ef5 100644 --- a/src/slang-nodes/ArgumentsDeclaration.ts +++ b/src/slang-nodes/ArgumentsDeclaration.ts @@ -5,9 +5,7 @@ import { SlangNode } from './SlangNode.js'; import { PositionalArgumentsDeclaration } from './PositionalArgumentsDeclaration.js'; import { NamedArgumentsDeclaration } from './NamedArgumentsDeclaration.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.ArgumentsDeclaration, @@ -22,14 +20,10 @@ export class ArgumentsDeclaration extends SlangNode { variant: PositionalArgumentsDeclaration | NamedArgumentsDeclaration; - constructor( - ast: ast.ArgumentsDeclaration, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ArgumentsDeclaration, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ArrayExpression.ts b/src/slang-nodes/ArrayExpression.ts index 16f62faa6..61a127e70 100644 --- a/src/slang-nodes/ArrayExpression.ts +++ b/src/slang-nodes/ArrayExpression.ts @@ -3,23 +3,18 @@ import { SlangNode } from './SlangNode.js'; import { ArrayValues } from './ArrayValues.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ArrayExpression extends SlangNode { readonly kind = NonterminalKind.ArrayExpression; items: ArrayValues; - constructor( - ast: ast.ArrayExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ArrayExpression, collected: CollectedMetadata) { super(ast, collected); - this.items = new ArrayValues(ast.items, collected, options); + this.items = new ArrayValues(ast.items, collected); this.updateMetadata(this.items); } diff --git a/src/slang-nodes/ArrayTypeName.ts b/src/slang-nodes/ArrayTypeName.ts index ee8a1ddee..afbbd54ac 100644 --- a/src/slang-nodes/ArrayTypeName.ts +++ b/src/slang-nodes/ArrayTypeName.ts @@ -5,9 +5,8 @@ import { TypeName } from './TypeName.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ArrayTypeName extends SlangNode { readonly kind = NonterminalKind.ArrayTypeName; @@ -16,20 +15,12 @@ export class ArrayTypeName extends SlangNode { index?: Expression['variant']; - constructor( - ast: ast.ArrayTypeName, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ArrayTypeName, collected: CollectedMetadata) { super(ast, collected); - this.operand = extractVariant( - new TypeName(ast.operand, collected, options) - ); + this.operand = extractVariant(new TypeName(ast.operand, collected)); if (ast.index) { - this.index = extractVariant( - new Expression(ast.index, collected, options) - ); + this.index = extractVariant(new Expression(ast.index, collected)); } this.updateMetadata(this.operand, this.index); diff --git a/src/slang-nodes/ArrayValues.ts b/src/slang-nodes/ArrayValues.ts index 4c60e7038..7f75f0d1a 100644 --- a/src/slang-nodes/ArrayValues.ts +++ b/src/slang-nodes/ArrayValues.ts @@ -5,24 +5,19 @@ import { SlangNode } from './SlangNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ArrayValues extends SlangNode { readonly kind = NonterminalKind.ArrayValues; items: Expression['variant'][]; - constructor( - ast: ast.ArrayValues, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ArrayValues, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new Expression(item, collected, options)) + extractVariant(new Expression(item, collected)) ); } diff --git a/src/slang-nodes/AssemblyFlags.ts b/src/slang-nodes/AssemblyFlags.ts index aebe6682d..3feb821e4 100644 --- a/src/slang-nodes/AssemblyFlags.ts +++ b/src/slang-nodes/AssemblyFlags.ts @@ -4,25 +4,18 @@ import { SlangNode } from './SlangNode.js'; import { StringLiteral } from './StringLiteral.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class AssemblyFlags extends SlangNode { readonly kind = NonterminalKind.AssemblyFlags; items: StringLiteral[]; - constructor( - ast: ast.AssemblyFlags, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.AssemblyFlags, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new StringLiteral(item, collected, options) - ); + this.items = ast.items.map((item) => new StringLiteral(item, collected)); } print(print: PrintFunction, path: AstPath): Doc { diff --git a/src/slang-nodes/AssemblyFlagsDeclaration.ts b/src/slang-nodes/AssemblyFlagsDeclaration.ts index 8cee9a1f9..924dae386 100644 --- a/src/slang-nodes/AssemblyFlagsDeclaration.ts +++ b/src/slang-nodes/AssemblyFlagsDeclaration.ts @@ -3,23 +3,18 @@ import { SlangNode } from './SlangNode.js'; import { AssemblyFlags } from './AssemblyFlags.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class AssemblyFlagsDeclaration extends SlangNode { readonly kind = NonterminalKind.AssemblyFlagsDeclaration; flags: AssemblyFlags; - constructor( - ast: ast.AssemblyFlagsDeclaration, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.AssemblyFlagsDeclaration, collected: CollectedMetadata) { super(ast, collected); - this.flags = new AssemblyFlags(ast.flags, collected, options); + this.flags = new AssemblyFlags(ast.flags, collected); this.updateMetadata(this.flags); } diff --git a/src/slang-nodes/AssemblyStatement.ts b/src/slang-nodes/AssemblyStatement.ts index f1e1d8950..d82eb242c 100644 --- a/src/slang-nodes/AssemblyStatement.ts +++ b/src/slang-nodes/AssemblyStatement.ts @@ -6,9 +6,8 @@ import { AssemblyFlagsDeclaration } from './AssemblyFlagsDeclaration.js'; import { YulBlock } from './YulBlock.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class AssemblyStatement extends SlangNode { readonly kind = NonterminalKind.AssemblyStatement; @@ -19,20 +18,16 @@ export class AssemblyStatement extends SlangNode { body: YulBlock; - constructor( - ast: ast.AssemblyStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.AssemblyStatement, collected: CollectedMetadata) { super(ast, collected); if (ast.label) { - this.label = new StringLiteral(ast.label, collected, options); + this.label = new StringLiteral(ast.label, collected); } if (ast.flags) { - this.flags = new AssemblyFlagsDeclaration(ast.flags, collected, options); + this.flags = new AssemblyFlagsDeclaration(ast.flags, collected); } - this.body = new YulBlock(ast.body, collected, options); + this.body = new YulBlock(ast.body, collected); this.updateMetadata(this.label, this.flags, this.body); } diff --git a/src/slang-nodes/AssignmentExpression.ts b/src/slang-nodes/AssignmentExpression.ts index 68fe94173..c10a5f9fc 100644 --- a/src/slang-nodes/AssignmentExpression.ts +++ b/src/slang-nodes/AssignmentExpression.ts @@ -5,9 +5,8 @@ import { SlangNode } from './SlangNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class AssignmentExpression extends SlangNode { readonly kind = NonterminalKind.AssignmentExpression; @@ -18,19 +17,15 @@ export class AssignmentExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.AssignmentExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.AssignmentExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/BitwiseAndExpression.ts b/src/slang-nodes/BitwiseAndExpression.ts index 1dd312e7c..e4142aed7 100644 --- a/src/slang-nodes/BitwiseAndExpression.ts +++ b/src/slang-nodes/BitwiseAndExpression.ts @@ -31,19 +31,15 @@ export class BitwiseAndExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.BitwiseAndExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.BitwiseAndExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/BitwiseOrExpression.ts b/src/slang-nodes/BitwiseOrExpression.ts index 38371ee1d..572789492 100644 --- a/src/slang-nodes/BitwiseOrExpression.ts +++ b/src/slang-nodes/BitwiseOrExpression.ts @@ -41,19 +41,15 @@ export class BitwiseOrExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.BitwiseOrExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.BitwiseOrExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/BitwiseXorExpression.ts b/src/slang-nodes/BitwiseXorExpression.ts index 220b1f4a1..e17efb95c 100644 --- a/src/slang-nodes/BitwiseXorExpression.ts +++ b/src/slang-nodes/BitwiseXorExpression.ts @@ -31,19 +31,15 @@ export class BitwiseXorExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.BitwiseXorExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.BitwiseXorExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/Block.ts b/src/slang-nodes/Block.ts index 368188803..80c198010 100644 --- a/src/slang-nodes/Block.ts +++ b/src/slang-nodes/Block.ts @@ -3,23 +3,18 @@ import { SlangNode } from './SlangNode.js'; import { Statements } from './Statements.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class Block extends SlangNode { readonly kind = NonterminalKind.Block; statements: Statements; - constructor( - ast: ast.Block, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.Block, collected: CollectedMetadata) { super(ast, collected); - this.statements = new Statements(ast.statements, collected, options); + this.statements = new Statements(ast.statements, collected); this.updateMetadata(this.statements); } diff --git a/src/slang-nodes/CallOptions.ts b/src/slang-nodes/CallOptions.ts index f8f2c7ae5..5dfca92c4 100644 --- a/src/slang-nodes/CallOptions.ts +++ b/src/slang-nodes/CallOptions.ts @@ -16,16 +16,10 @@ export class CallOptions extends SlangNode { items: NamedArgument[]; - constructor( - ast: ast.CallOptions, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.CallOptions, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new NamedArgument(item, collected, options) - ); + this.items = ast.items.map((item) => new NamedArgument(item, collected)); } print( diff --git a/src/slang-nodes/CallOptionsExpression.ts b/src/slang-nodes/CallOptionsExpression.ts index d4f3b36e1..80042045a 100644 --- a/src/slang-nodes/CallOptionsExpression.ts +++ b/src/slang-nodes/CallOptionsExpression.ts @@ -5,9 +5,8 @@ import { Expression } from './Expression.js'; import { CallOptions } from './CallOptions.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class CallOptionsExpression extends SlangNode { readonly kind = NonterminalKind.CallOptionsExpression; @@ -16,17 +15,11 @@ export class CallOptionsExpression extends SlangNode { options: CallOptions; - constructor( - ast: ast.CallOptionsExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.CallOptionsExpression, collected: CollectedMetadata) { super(ast, collected); - this.operand = extractVariant( - new Expression(ast.operand, collected, options) - ); - this.options = new CallOptions(ast.options, collected, options); + this.operand = extractVariant(new Expression(ast.operand, collected)); + this.options = new CallOptions(ast.options, collected); this.updateMetadata(this.operand, this.options); } diff --git a/src/slang-nodes/CatchClause.ts b/src/slang-nodes/CatchClause.ts index 06422b031..d7d907133 100644 --- a/src/slang-nodes/CatchClause.ts +++ b/src/slang-nodes/CatchClause.ts @@ -4,9 +4,8 @@ import { CatchClauseError } from './CatchClauseError.js'; import { Block } from './Block.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class CatchClause extends SlangNode { readonly kind = NonterminalKind.CatchClause; @@ -15,17 +14,13 @@ export class CatchClause extends SlangNode { body: Block; - constructor( - ast: ast.CatchClause, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.CatchClause, collected: CollectedMetadata) { super(ast, collected); if (ast.error) { - this.error = new CatchClauseError(ast.error, collected, options); + this.error = new CatchClauseError(ast.error, collected); } - this.body = new Block(ast.body, collected, options); + this.body = new Block(ast.body, collected); this.updateMetadata(this.error, this.body); } diff --git a/src/slang-nodes/CatchClauseError.ts b/src/slang-nodes/CatchClauseError.ts index 88019555c..4b05f05ba 100644 --- a/src/slang-nodes/CatchClauseError.ts +++ b/src/slang-nodes/CatchClauseError.ts @@ -5,9 +5,8 @@ import { TerminalNode } from './TerminalNode.js'; import { ParametersDeclaration } from './ParametersDeclaration.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { group } = doc.builders; @@ -18,21 +17,13 @@ export class CatchClauseError extends SlangNode { parameters: ParametersDeclaration; - constructor( - ast: ast.CatchClauseError, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.CatchClauseError, collected: CollectedMetadata) { super(ast, collected); if (ast.name) { this.name = new TerminalNode(ast.name, collected); } - this.parameters = new ParametersDeclaration( - ast.parameters, - collected, - options - ); + this.parameters = new ParametersDeclaration(ast.parameters, collected); this.updateMetadata(this.parameters); } diff --git a/src/slang-nodes/CatchClauses.ts b/src/slang-nodes/CatchClauses.ts index 12be56552..34f4664ce 100644 --- a/src/slang-nodes/CatchClauses.ts +++ b/src/slang-nodes/CatchClauses.ts @@ -4,9 +4,8 @@ import { SlangNode } from './SlangNode.js'; import { CatchClause } from './CatchClause.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { join } = doc.builders; @@ -15,16 +14,10 @@ export class CatchClauses extends SlangNode { items: CatchClause[]; - constructor( - ast: ast.CatchClauses, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.CatchClauses, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new CatchClause(item, collected, options) - ); + this.items = ast.items.map((item) => new CatchClause(item, collected)); this.updateMetadata(...this.items); } diff --git a/src/slang-nodes/ConditionalExpression.ts b/src/slang-nodes/ConditionalExpression.ts index 0fed3fb3e..0bc9d7219 100644 --- a/src/slang-nodes/ConditionalExpression.ts +++ b/src/slang-nodes/ConditionalExpression.ts @@ -114,21 +114,15 @@ export class ConditionalExpression extends SlangNode { falseExpression: Expression['variant']; - constructor( - ast: ast.ConditionalExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ConditionalExpression, collected: CollectedMetadata) { super(ast, collected); - this.operand = extractVariant( - new Expression(ast.operand, collected, options) - ); + this.operand = extractVariant(new Expression(ast.operand, collected)); this.trueExpression = extractVariant( - new Expression(ast.trueExpression, collected, options) + new Expression(ast.trueExpression, collected) ); this.falseExpression = extractVariant( - new Expression(ast.falseExpression, collected, options) + new Expression(ast.falseExpression, collected) ); this.updateMetadata( @@ -137,7 +131,7 @@ export class ConditionalExpression extends SlangNode { this.falseExpression ); - if (options.experimentalTernaries) { + if (collected.options.experimentalTernaries) { // We can remove parentheses only because we are sure that the // `condition` must be a single `bool` value. const operandLoc = this.operand.loc; diff --git a/src/slang-nodes/ConstantDefinition.ts b/src/slang-nodes/ConstantDefinition.ts index 5a2cfa2f1..db5bbf5c4 100644 --- a/src/slang-nodes/ConstantDefinition.ts +++ b/src/slang-nodes/ConstantDefinition.ts @@ -7,9 +7,8 @@ import { TerminalNode } from './TerminalNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ConstantDefinition extends SlangNode { readonly kind = NonterminalKind.ConstantDefinition; @@ -20,18 +19,12 @@ export class ConstantDefinition extends SlangNode { value: Expression['variant']; - constructor( - ast: ast.ConstantDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ConstantDefinition, collected: CollectedMetadata) { super(ast, collected); - this.typeName = extractVariant( - new TypeName(ast.typeName, collected, options) - ); + this.typeName = extractVariant(new TypeName(ast.typeName, collected)); this.name = new TerminalNode(ast.name, collected); - this.value = extractVariant(new Expression(ast.value, collected, options)); + this.value = extractVariant(new Expression(ast.value, collected)); this.updateMetadata(this.typeName, this.value); } diff --git a/src/slang-nodes/ConstructorAttribute.ts b/src/slang-nodes/ConstructorAttribute.ts index 30a37f5af..d62254bce 100644 --- a/src/slang-nodes/ConstructorAttribute.ts +++ b/src/slang-nodes/ConstructorAttribute.ts @@ -7,20 +7,14 @@ import { ModifierInvocation } from './ModifierInvocation.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ConstructorAttribute extends SlangNode { readonly kind = NonterminalKind.ConstructorAttribute; variant: ModifierInvocation | TerminalNode; - constructor( - ast: ast.ConstructorAttribute, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ConstructorAttribute, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -28,7 +22,7 @@ export class ConstructorAttribute extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = new ModifierInvocation(variant, collected, options); + this.variant = new ModifierInvocation(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ConstructorAttributes.ts b/src/slang-nodes/ConstructorAttributes.ts index f24edf5b0..e1a502b90 100644 --- a/src/slang-nodes/ConstructorAttributes.ts +++ b/src/slang-nodes/ConstructorAttributes.ts @@ -6,9 +6,8 @@ import { SlangNode } from './SlangNode.js'; import { ConstructorAttribute } from './ConstructorAttribute.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { line } = doc.builders; @@ -17,15 +16,11 @@ export class ConstructorAttributes extends SlangNode { items: ConstructorAttribute['variant'][]; - constructor( - ast: ast.ConstructorAttributes, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ConstructorAttributes, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new ConstructorAttribute(item, collected, options)) + extractVariant(new ConstructorAttribute(item, collected)) ); this.items.sort(sortFunctionAttributes); diff --git a/src/slang-nodes/ConstructorDefinition.ts b/src/slang-nodes/ConstructorDefinition.ts index 03c921112..da5326d7b 100644 --- a/src/slang-nodes/ConstructorDefinition.ts +++ b/src/slang-nodes/ConstructorDefinition.ts @@ -6,9 +6,8 @@ import { ConstructorAttributes } from './ConstructorAttributes.js'; import { Block } from './Block.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ConstructorDefinition extends SlangNode { readonly kind = NonterminalKind.ConstructorDefinition; @@ -19,24 +18,12 @@ export class ConstructorDefinition extends SlangNode { body: Block; - constructor( - ast: ast.ConstructorDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ConstructorDefinition, collected: CollectedMetadata) { super(ast, collected); - this.parameters = new ParametersDeclaration( - ast.parameters, - collected, - options - ); - this.attributes = new ConstructorAttributes( - ast.attributes, - collected, - options - ); - this.body = new Block(ast.body, collected, options); + this.parameters = new ParametersDeclaration(ast.parameters, collected); + this.attributes = new ConstructorAttributes(ast.attributes, collected); + this.body = new Block(ast.body, collected); this.updateMetadata(this.parameters, this.attributes, this.body); } diff --git a/src/slang-nodes/ContractDefinition.ts b/src/slang-nodes/ContractDefinition.ts index d601632a9..2a32d9617 100644 --- a/src/slang-nodes/ContractDefinition.ts +++ b/src/slang-nodes/ContractDefinition.ts @@ -7,9 +7,8 @@ import { ContractSpecifiers } from './ContractSpecifiers.js'; import { ContractMembers } from './ContractMembers.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { group, line } = doc.builders; @@ -24,21 +23,13 @@ export class ContractDefinition extends SlangNode { members: ContractMembers; - constructor( - ast: ast.ContractDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ContractDefinition, collected: CollectedMetadata) { super(ast, collected); this.abstractKeyword = ast.abstractKeyword?.unparse(); this.name = new TerminalNode(ast.name, collected); - this.specifiers = new ContractSpecifiers( - ast.specifiers, - collected, - options - ); - this.members = new ContractMembers(ast.members, collected, options); + this.specifiers = new ContractSpecifiers(ast.specifiers, collected); + this.members = new ContractMembers(ast.members, collected); this.updateMetadata(this.specifiers, this.members); @@ -46,7 +37,7 @@ export class ContractDefinition extends SlangNode { // the same name as the contract. // So we delegate to the parents the responsibility of cleaning the // arguments of modifier invocations. - if (!satisfies(options.compiler, '>=0.5.0')) { + if (!satisfies(collected.options.compiler, '>=0.5.0')) { for (const member of this.members.items) { if ( member.kind === NonterminalKind.FunctionDefinition && diff --git a/src/slang-nodes/ContractMember.ts b/src/slang-nodes/ContractMember.ts index 41aae250f..bd77912b1 100644 --- a/src/slang-nodes/ContractMember.ts +++ b/src/slang-nodes/ContractMember.ts @@ -16,9 +16,7 @@ import { StateVariableDefinition } from './StateVariableDefinition.js'; import { ErrorDefinition } from './ErrorDefinition.js'; import { UserDefinedValueTypeDefinition } from './UserDefinedValueTypeDefinition.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.ContractMember, @@ -57,14 +55,10 @@ export class ContractMember extends SlangNode { | ErrorDefinition | UserDefinedValueTypeDefinition; - constructor( - ast: ast.ContractMember, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ContractMember, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ContractMembers.ts b/src/slang-nodes/ContractMembers.ts index 440510529..adb27a939 100644 --- a/src/slang-nodes/ContractMembers.ts +++ b/src/slang-nodes/ContractMembers.ts @@ -18,15 +18,11 @@ export class ContractMembers extends SlangNode { items: ContractMember['variant'][]; - constructor( - ast: ast.ContractMembers, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ContractMembers, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new ContractMember(item, collected, options)) + extractVariant(new ContractMember(item, collected)) ); } diff --git a/src/slang-nodes/ContractSpecifier.ts b/src/slang-nodes/ContractSpecifier.ts index 40195d77f..e07b1fc39 100644 --- a/src/slang-nodes/ContractSpecifier.ts +++ b/src/slang-nodes/ContractSpecifier.ts @@ -5,9 +5,7 @@ import { SlangNode } from './SlangNode.js'; import { InheritanceSpecifier } from './InheritanceSpecifier.js'; import { StorageLayoutSpecifier } from './StorageLayoutSpecifier.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.ContractSpecifier, @@ -22,14 +20,10 @@ export class ContractSpecifier extends SlangNode { variant: InheritanceSpecifier | StorageLayoutSpecifier; - constructor( - ast: ast.ContractSpecifier, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ContractSpecifier, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ContractSpecifiers.ts b/src/slang-nodes/ContractSpecifiers.ts index 819586bbc..09e8f1d9b 100644 --- a/src/slang-nodes/ContractSpecifiers.ts +++ b/src/slang-nodes/ContractSpecifiers.ts @@ -7,9 +7,8 @@ import { SlangNode } from './SlangNode.js'; import { ContractSpecifier } from './ContractSpecifier.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { group, ifBreak, line, softline } = doc.builders; @@ -18,15 +17,11 @@ export class ContractSpecifiers extends SlangNode { items: ContractSpecifier['variant'][]; - constructor( - ast: ast.ContractSpecifiers, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ContractSpecifiers, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new ContractSpecifier(item, collected, options)) + extractVariant(new ContractSpecifier(item, collected)) ); this.items.sort(sortContractSpecifiers); diff --git a/src/slang-nodes/DoWhileStatement.ts b/src/slang-nodes/DoWhileStatement.ts index c4766fc7e..d68c21172 100644 --- a/src/slang-nodes/DoWhileStatement.ts +++ b/src/slang-nodes/DoWhileStatement.ts @@ -7,9 +7,8 @@ import { Statement } from './Statement.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { line } = doc.builders; @@ -20,17 +19,11 @@ export class DoWhileStatement extends SlangNode { condition: Expression['variant']; - constructor( - ast: ast.DoWhileStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.DoWhileStatement, collected: CollectedMetadata) { super(ast, collected); - this.body = extractVariant(new Statement(ast.body, collected, options)); - this.condition = extractVariant( - new Expression(ast.condition, collected, options) - ); + this.body = extractVariant(new Statement(ast.body, collected)); + this.condition = extractVariant(new Expression(ast.condition, collected)); this.updateMetadata(this.body, this.condition); } diff --git a/src/slang-nodes/ElseBranch.ts b/src/slang-nodes/ElseBranch.ts index 06819bca8..2ba1c1370 100644 --- a/src/slang-nodes/ElseBranch.ts +++ b/src/slang-nodes/ElseBranch.ts @@ -6,9 +6,8 @@ import { SlangNode } from './SlangNode.js'; import { Statement } from './Statement.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const isIfStatementOrBlock = createKindCheckFunction([ NonterminalKind.Block, @@ -20,14 +19,10 @@ export class ElseBranch extends SlangNode { body: Statement['variant']; - constructor( - ast: ast.ElseBranch, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ElseBranch, collected: CollectedMetadata) { super(ast, collected); - this.body = extractVariant(new Statement(ast.body, collected, options)); + this.body = extractVariant(new Statement(ast.body, collected)); this.updateMetadata(this.body); } diff --git a/src/slang-nodes/EmitStatement.ts b/src/slang-nodes/EmitStatement.ts index bce61520f..6de43b3a9 100644 --- a/src/slang-nodes/EmitStatement.ts +++ b/src/slang-nodes/EmitStatement.ts @@ -5,9 +5,8 @@ import { IdentifierPath } from './IdentifierPath.js'; import { ArgumentsDeclaration } from './ArgumentsDeclaration.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class EmitStatement extends SlangNode { readonly kind = NonterminalKind.EmitStatement; @@ -16,16 +15,12 @@ export class EmitStatement extends SlangNode { arguments: ArgumentsDeclaration['variant']; - constructor( - ast: ast.EmitStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.EmitStatement, collected: CollectedMetadata) { super(ast, collected); this.event = new IdentifierPath(ast.event, collected); this.arguments = extractVariant( - new ArgumentsDeclaration(ast.arguments, collected, options) + new ArgumentsDeclaration(ast.arguments, collected) ); this.updateMetadata(this.event, this.arguments); diff --git a/src/slang-nodes/EqualityExpression.ts b/src/slang-nodes/EqualityExpression.ts index 9bbdce691..bb71e0ec7 100644 --- a/src/slang-nodes/EqualityExpression.ts +++ b/src/slang-nodes/EqualityExpression.ts @@ -29,19 +29,15 @@ export class EqualityExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.EqualityExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.EqualityExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/ErrorDefinition.ts b/src/slang-nodes/ErrorDefinition.ts index 4ed989bbd..bd3520fd9 100644 --- a/src/slang-nodes/ErrorDefinition.ts +++ b/src/slang-nodes/ErrorDefinition.ts @@ -4,9 +4,8 @@ import { TerminalNode } from './TerminalNode.js'; import { ErrorParametersDeclaration } from './ErrorParametersDeclaration.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ErrorDefinition extends SlangNode { readonly kind = NonterminalKind.ErrorDefinition; @@ -15,19 +14,11 @@ export class ErrorDefinition extends SlangNode { members: ErrorParametersDeclaration; - constructor( - ast: ast.ErrorDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ErrorDefinition, collected: CollectedMetadata) { super(ast, collected); this.name = new TerminalNode(ast.name, collected); - this.members = new ErrorParametersDeclaration( - ast.members, - collected, - options - ); + this.members = new ErrorParametersDeclaration(ast.members, collected); this.updateMetadata(this.members); } diff --git a/src/slang-nodes/ErrorParameter.ts b/src/slang-nodes/ErrorParameter.ts index 9e81ec7d1..ab11d63bd 100644 --- a/src/slang-nodes/ErrorParameter.ts +++ b/src/slang-nodes/ErrorParameter.ts @@ -6,9 +6,8 @@ import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ErrorParameter extends SlangNode { readonly kind = NonterminalKind.ErrorParameter; @@ -17,16 +16,10 @@ export class ErrorParameter extends SlangNode { name?: TerminalNode; - constructor( - ast: ast.ErrorParameter, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ErrorParameter, collected: CollectedMetadata) { super(ast, collected); - this.typeName = extractVariant( - new TypeName(ast.typeName, collected, options) - ); + this.typeName = extractVariant(new TypeName(ast.typeName, collected)); if (ast.name) { this.name = new TerminalNode(ast.name, collected); } diff --git a/src/slang-nodes/ErrorParameters.ts b/src/slang-nodes/ErrorParameters.ts index 4daa667e1..be33579cf 100644 --- a/src/slang-nodes/ErrorParameters.ts +++ b/src/slang-nodes/ErrorParameters.ts @@ -4,25 +4,18 @@ import { SlangNode } from './SlangNode.js'; import { ErrorParameter } from './ErrorParameter.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ErrorParameters extends SlangNode { readonly kind = NonterminalKind.ErrorParameters; items: ErrorParameter[]; - constructor( - ast: ast.ErrorParameters, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ErrorParameters, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new ErrorParameter(item, collected, options) - ); + this.items = ast.items.map((item) => new ErrorParameter(item, collected)); } print(print: PrintFunction, path: AstPath): Doc { diff --git a/src/slang-nodes/ErrorParametersDeclaration.ts b/src/slang-nodes/ErrorParametersDeclaration.ts index 8ce8651aa..632fe232b 100644 --- a/src/slang-nodes/ErrorParametersDeclaration.ts +++ b/src/slang-nodes/ErrorParametersDeclaration.ts @@ -3,9 +3,8 @@ import { SlangNode } from './SlangNode.js'; import { ErrorParameters } from './ErrorParameters.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ErrorParametersDeclaration extends SlangNode { readonly kind = NonterminalKind.ErrorParametersDeclaration; @@ -14,12 +13,11 @@ export class ErrorParametersDeclaration extends SlangNode { constructor( ast: ast.ErrorParametersDeclaration, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); - this.parameters = new ErrorParameters(ast.parameters, collected, options); + this.parameters = new ErrorParameters(ast.parameters, collected); this.updateMetadata(this.parameters); } diff --git a/src/slang-nodes/EventDefinition.ts b/src/slang-nodes/EventDefinition.ts index 4af7fdcb2..5fa3b324f 100644 --- a/src/slang-nodes/EventDefinition.ts +++ b/src/slang-nodes/EventDefinition.ts @@ -4,9 +4,8 @@ import { EventParametersDeclaration } from './EventParametersDeclaration.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class EventDefinition extends SlangNode { readonly kind = NonterminalKind.EventDefinition; @@ -17,19 +16,11 @@ export class EventDefinition extends SlangNode { anonymousKeyword?: string; - constructor( - ast: ast.EventDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.EventDefinition, collected: CollectedMetadata) { super(ast, collected); this.name = new TerminalNode(ast.name, collected); - this.parameters = new EventParametersDeclaration( - ast.parameters, - collected, - options - ); + this.parameters = new EventParametersDeclaration(ast.parameters, collected); this.anonymousKeyword = ast.anonymousKeyword?.unparse(); this.updateMetadata(this.parameters); diff --git a/src/slang-nodes/EventParameter.ts b/src/slang-nodes/EventParameter.ts index 997cd5dc9..ff430fc2d 100644 --- a/src/slang-nodes/EventParameter.ts +++ b/src/slang-nodes/EventParameter.ts @@ -6,9 +6,8 @@ import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class EventParameter extends SlangNode { readonly kind = NonterminalKind.EventParameter; @@ -19,16 +18,10 @@ export class EventParameter extends SlangNode { name?: TerminalNode; - constructor( - ast: ast.EventParameter, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.EventParameter, collected: CollectedMetadata) { super(ast, collected); - this.typeName = extractVariant( - new TypeName(ast.typeName, collected, options) - ); + this.typeName = extractVariant(new TypeName(ast.typeName, collected)); this.indexedKeyword = ast.indexedKeyword?.unparse(); if (ast.name) { this.name = new TerminalNode(ast.name, collected); diff --git a/src/slang-nodes/EventParameters.ts b/src/slang-nodes/EventParameters.ts index 6a7877d4a..562af86e3 100644 --- a/src/slang-nodes/EventParameters.ts +++ b/src/slang-nodes/EventParameters.ts @@ -4,25 +4,18 @@ import { SlangNode } from './SlangNode.js'; import { EventParameter } from './EventParameter.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class EventParameters extends SlangNode { readonly kind = NonterminalKind.EventParameters; items: EventParameter[]; - constructor( - ast: ast.EventParameters, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.EventParameters, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new EventParameter(item, collected, options) - ); + this.items = ast.items.map((item) => new EventParameter(item, collected)); } print(print: PrintFunction, path: AstPath): Doc { diff --git a/src/slang-nodes/EventParametersDeclaration.ts b/src/slang-nodes/EventParametersDeclaration.ts index 64d56d942..c7382c69b 100644 --- a/src/slang-nodes/EventParametersDeclaration.ts +++ b/src/slang-nodes/EventParametersDeclaration.ts @@ -3,9 +3,8 @@ import { SlangNode } from './SlangNode.js'; import { EventParameters } from './EventParameters.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class EventParametersDeclaration extends SlangNode { readonly kind = NonterminalKind.EventParametersDeclaration; @@ -14,12 +13,11 @@ export class EventParametersDeclaration extends SlangNode { constructor( ast: ast.EventParametersDeclaration, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); - this.parameters = new EventParameters(ast.parameters, collected, options); + this.parameters = new EventParameters(ast.parameters, collected); this.updateMetadata(this.parameters); } diff --git a/src/slang-nodes/ExperimentalFeature.ts b/src/slang-nodes/ExperimentalFeature.ts index d1e8e136f..cceff26dd 100644 --- a/src/slang-nodes/ExperimentalFeature.ts +++ b/src/slang-nodes/ExperimentalFeature.ts @@ -7,20 +7,14 @@ import { StringLiteral } from './StringLiteral.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ExperimentalFeature extends SlangNode { readonly kind = NonterminalKind.ExperimentalFeature; variant: StringLiteral | TerminalNode; - constructor( - ast: ast.ExperimentalFeature, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ExperimentalFeature, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -28,7 +22,7 @@ export class ExperimentalFeature extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = new StringLiteral(variant, collected, options); + this.variant = new StringLiteral(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ExperimentalPragma.ts b/src/slang-nodes/ExperimentalPragma.ts index 86a2f2964..4cfa0a5b8 100644 --- a/src/slang-nodes/ExperimentalPragma.ts +++ b/src/slang-nodes/ExperimentalPragma.ts @@ -4,24 +4,19 @@ import { SlangNode } from './SlangNode.js'; import { ExperimentalFeature } from './ExperimentalFeature.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ExperimentalPragma extends SlangNode { readonly kind = NonterminalKind.ExperimentalPragma; feature: ExperimentalFeature['variant']; - constructor( - ast: ast.ExperimentalPragma, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ExperimentalPragma, collected: CollectedMetadata) { super(ast, collected); this.feature = extractVariant( - new ExperimentalFeature(ast.feature, collected, options) + new ExperimentalFeature(ast.feature, collected) ); this.updateMetadata(this.feature); diff --git a/src/slang-nodes/ExponentiationExpression.ts b/src/slang-nodes/ExponentiationExpression.ts index 64f09cf7e..8d1fe79df 100644 --- a/src/slang-nodes/ExponentiationExpression.ts +++ b/src/slang-nodes/ExponentiationExpression.ts @@ -46,19 +46,15 @@ export class ExponentiationExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.ExponentiationExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ExponentiationExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/Expression.ts b/src/slang-nodes/Expression.ts index 70827c248..c701efd74 100644 --- a/src/slang-nodes/Expression.ts +++ b/src/slang-nodes/Expression.ts @@ -34,9 +34,7 @@ import { StringExpression } from './StringExpression.js'; import { ElementaryType } from './ElementaryType.js'; import { TerminalNode } from './TerminalNode.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantCreator< ast.Expression, @@ -108,11 +106,7 @@ export class Expression extends SlangNode { | ElementaryType['variant'] | TerminalNode; - constructor( - ast: ast.Expression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.Expression, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -120,7 +114,7 @@ export class Expression extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = createNonterminalVariant(variant, collected, options); + this.variant = createNonterminalVariant(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ExpressionStatement.ts b/src/slang-nodes/ExpressionStatement.ts index 5843953ca..b7ed44e5e 100644 --- a/src/slang-nodes/ExpressionStatement.ts +++ b/src/slang-nodes/ExpressionStatement.ts @@ -4,25 +4,18 @@ import { SlangNode } from './SlangNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ExpressionStatement extends SlangNode { readonly kind = NonterminalKind.ExpressionStatement; expression: Expression['variant']; - constructor( - ast: ast.ExpressionStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ExpressionStatement, collected: CollectedMetadata) { super(ast, collected); - this.expression = extractVariant( - new Expression(ast.expression, collected, options) - ); + this.expression = extractVariant(new Expression(ast.expression, collected)); this.updateMetadata(this.expression); } diff --git a/src/slang-nodes/FallbackFunctionAttribute.ts b/src/slang-nodes/FallbackFunctionAttribute.ts index 0f65ac566..e8c5ed738 100644 --- a/src/slang-nodes/FallbackFunctionAttribute.ts +++ b/src/slang-nodes/FallbackFunctionAttribute.ts @@ -9,9 +9,7 @@ import { ModifierInvocation } from './ModifierInvocation.js'; import { OverrideSpecifier } from './OverrideSpecifier.js'; import { TerminalNode } from './TerminalNode.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.FallbackFunctionAttribute, @@ -28,8 +26,7 @@ export class FallbackFunctionAttribute extends SlangNode { constructor( ast: ast.FallbackFunctionAttribute, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); @@ -38,7 +35,7 @@ export class FallbackFunctionAttribute extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = createNonterminalVariant(variant, collected, options); + this.variant = createNonterminalVariant(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/FallbackFunctionAttributes.ts b/src/slang-nodes/FallbackFunctionAttributes.ts index 5687bc3d4..765a06a89 100644 --- a/src/slang-nodes/FallbackFunctionAttributes.ts +++ b/src/slang-nodes/FallbackFunctionAttributes.ts @@ -6,9 +6,8 @@ import { SlangNode } from './SlangNode.js'; import { FallbackFunctionAttribute } from './FallbackFunctionAttribute.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { line } = doc.builders; @@ -19,13 +18,12 @@ export class FallbackFunctionAttributes extends SlangNode { constructor( ast: ast.FallbackFunctionAttributes, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new FallbackFunctionAttribute(item, collected, options)) + extractVariant(new FallbackFunctionAttribute(item, collected)) ); this.items.sort(sortFunctionAttributes); diff --git a/src/slang-nodes/FallbackFunctionDefinition.ts b/src/slang-nodes/FallbackFunctionDefinition.ts index 4b328474b..b6ecfa598 100644 --- a/src/slang-nodes/FallbackFunctionDefinition.ts +++ b/src/slang-nodes/FallbackFunctionDefinition.ts @@ -8,9 +8,8 @@ import { ReturnsDeclaration } from './ReturnsDeclaration.js'; import { FunctionBody } from './FunctionBody.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class FallbackFunctionDefinition extends SlangNode { readonly kind = NonterminalKind.FallbackFunctionDefinition; @@ -25,25 +24,16 @@ export class FallbackFunctionDefinition extends SlangNode { constructor( ast: ast.FallbackFunctionDefinition, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); - this.parameters = new ParametersDeclaration( - ast.parameters, - collected, - options - ); - this.attributes = new FallbackFunctionAttributes( - ast.attributes, - collected, - options - ); + this.parameters = new ParametersDeclaration(ast.parameters, collected); + this.attributes = new FallbackFunctionAttributes(ast.attributes, collected); if (ast.returns) { - this.returns = new ReturnsDeclaration(ast.returns, collected, options); + this.returns = new ReturnsDeclaration(ast.returns, collected); } - this.body = extractVariant(new FunctionBody(ast.body, collected, options)); + this.body = extractVariant(new FunctionBody(ast.body, collected)); this.updateMetadata( this.parameters, diff --git a/src/slang-nodes/ForStatement.ts b/src/slang-nodes/ForStatement.ts index 36bbf9994..610194112 100644 --- a/src/slang-nodes/ForStatement.ts +++ b/src/slang-nodes/ForStatement.ts @@ -10,9 +10,8 @@ import { Expression } from './Expression.js'; import { Statement } from './Statement.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { line } = doc.builders; @@ -27,25 +26,19 @@ export class ForStatement extends SlangNode { body: Statement['variant']; - constructor( - ast: ast.ForStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ForStatement, collected: CollectedMetadata) { super(ast, collected); this.initialization = extractVariant( - new ForStatementInitialization(ast.initialization, collected, options) + new ForStatementInitialization(ast.initialization, collected) ); this.condition = extractVariant( - new ForStatementCondition(ast.condition, collected, options) + new ForStatementCondition(ast.condition, collected) ); if (ast.iterator) { - this.iterator = extractVariant( - new Expression(ast.iterator, collected, options) - ); + this.iterator = extractVariant(new Expression(ast.iterator, collected)); } - this.body = extractVariant(new Statement(ast.body, collected, options)); + this.body = extractVariant(new Statement(ast.body, collected)); this.updateMetadata( this.initialization, diff --git a/src/slang-nodes/ForStatementCondition.ts b/src/slang-nodes/ForStatementCondition.ts index fc6ebc3b2..051d47c47 100644 --- a/src/slang-nodes/ForStatementCondition.ts +++ b/src/slang-nodes/ForStatementCondition.ts @@ -7,20 +7,14 @@ import { ExpressionStatement } from './ExpressionStatement.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ForStatementCondition extends SlangNode { readonly kind = NonterminalKind.ForStatementCondition; variant: ExpressionStatement | TerminalNode; - constructor( - ast: ast.ForStatementCondition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ForStatementCondition, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -28,7 +22,7 @@ export class ForStatementCondition extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = new ExpressionStatement(variant, collected, options); + this.variant = new ExpressionStatement(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ForStatementInitialization.ts b/src/slang-nodes/ForStatementInitialization.ts index 2ac666ef1..8b6c87cd9 100644 --- a/src/slang-nodes/ForStatementInitialization.ts +++ b/src/slang-nodes/ForStatementInitialization.ts @@ -10,9 +10,7 @@ import { VariableDeclarationStatement } from './VariableDeclarationStatement.js' import { TupleDeconstructionStatement } from './TupleDeconstructionStatement.js'; import { TerminalNode } from './TerminalNode.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.ForStatementInitialization, @@ -34,8 +32,7 @@ export class ForStatementInitialization extends SlangNode { constructor( ast: ast.ForStatementInitialization, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); @@ -44,7 +41,7 @@ export class ForStatementInitialization extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = createNonterminalVariant(variant, collected, options); + this.variant = createNonterminalVariant(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/FunctionAttribute.ts b/src/slang-nodes/FunctionAttribute.ts index cdd628e00..74faf02b0 100644 --- a/src/slang-nodes/FunctionAttribute.ts +++ b/src/slang-nodes/FunctionAttribute.ts @@ -9,9 +9,7 @@ import { ModifierInvocation } from './ModifierInvocation.js'; import { OverrideSpecifier } from './OverrideSpecifier.js'; import { TerminalNode } from './TerminalNode.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.FunctionAttribute, @@ -26,11 +24,7 @@ export class FunctionAttribute extends SlangNode { variant: ModifierInvocation | OverrideSpecifier | TerminalNode; - constructor( - ast: ast.FunctionAttribute, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.FunctionAttribute, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -38,7 +32,7 @@ export class FunctionAttribute extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = createNonterminalVariant(variant, collected, options); + this.variant = createNonterminalVariant(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/FunctionAttributes.ts b/src/slang-nodes/FunctionAttributes.ts index f084b9360..a871e84a0 100644 --- a/src/slang-nodes/FunctionAttributes.ts +++ b/src/slang-nodes/FunctionAttributes.ts @@ -6,9 +6,8 @@ import { SlangNode } from './SlangNode.js'; import { FunctionAttribute } from './FunctionAttribute.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { line } = doc.builders; @@ -17,15 +16,11 @@ export class FunctionAttributes extends SlangNode { items: FunctionAttribute['variant'][]; - constructor( - ast: ast.FunctionAttributes, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.FunctionAttributes, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new FunctionAttribute(item, collected, options)) + extractVariant(new FunctionAttribute(item, collected)) ); this.items.sort(sortFunctionAttributes); diff --git a/src/slang-nodes/FunctionBody.ts b/src/slang-nodes/FunctionBody.ts index f3fbea484..0f4bb2743 100644 --- a/src/slang-nodes/FunctionBody.ts +++ b/src/slang-nodes/FunctionBody.ts @@ -7,20 +7,14 @@ import { Block } from './Block.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class FunctionBody extends SlangNode { readonly kind = NonterminalKind.FunctionBody; variant: Block | TerminalNode; - constructor( - ast: ast.FunctionBody, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.FunctionBody, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -28,7 +22,7 @@ export class FunctionBody extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = new Block(variant, collected, options); + this.variant = new Block(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/FunctionCallExpression.ts b/src/slang-nodes/FunctionCallExpression.ts index bb61022ae..79945a073 100644 --- a/src/slang-nodes/FunctionCallExpression.ts +++ b/src/slang-nodes/FunctionCallExpression.ts @@ -6,9 +6,8 @@ import { Expression } from './Expression.js'; import { ArgumentsDeclaration } from './ArgumentsDeclaration.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class FunctionCallExpression extends SlangNode { readonly kind = NonterminalKind.FunctionCallExpression; @@ -17,18 +16,12 @@ export class FunctionCallExpression extends SlangNode { arguments: ArgumentsDeclaration['variant']; - constructor( - ast: ast.FunctionCallExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.FunctionCallExpression, collected: CollectedMetadata) { super(ast, collected); - this.operand = extractVariant( - new Expression(ast.operand, collected, options) - ); + this.operand = extractVariant(new Expression(ast.operand, collected)); this.arguments = extractVariant( - new ArgumentsDeclaration(ast.arguments, collected, options) + new ArgumentsDeclaration(ast.arguments, collected) ); this.updateMetadata(this.operand, this.arguments); diff --git a/src/slang-nodes/FunctionDefinition.ts b/src/slang-nodes/FunctionDefinition.ts index 543651fec..43b7affc7 100644 --- a/src/slang-nodes/FunctionDefinition.ts +++ b/src/slang-nodes/FunctionDefinition.ts @@ -10,9 +10,8 @@ import { ReturnsDeclaration } from './ReturnsDeclaration.js'; import { FunctionBody } from './FunctionBody.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class FunctionDefinition extends SlangNode { readonly kind = NonterminalKind.FunctionDefinition; @@ -27,28 +26,16 @@ export class FunctionDefinition extends SlangNode { body: FunctionBody['variant']; - constructor( - ast: ast.FunctionDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.FunctionDefinition, collected: CollectedMetadata) { super(ast, collected); this.name = extractVariant(new FunctionName(ast.name, collected)); - this.parameters = new ParametersDeclaration( - ast.parameters, - collected, - options - ); - this.attributes = new FunctionAttributes( - ast.attributes, - collected, - options - ); + this.parameters = new ParametersDeclaration(ast.parameters, collected); + this.attributes = new FunctionAttributes(ast.attributes, collected); if (ast.returns) { - this.returns = new ReturnsDeclaration(ast.returns, collected, options); + this.returns = new ReturnsDeclaration(ast.returns, collected); } - this.body = extractVariant(new FunctionBody(ast.body, collected, options)); + this.body = extractVariant(new FunctionBody(ast.body, collected)); this.updateMetadata( this.name, @@ -62,7 +49,7 @@ export class FunctionDefinition extends SlangNode { // the same name as the contract. // So we delegate to the parents the responsibility of cleaning the // arguments of modifier invocations. - if (satisfies(options.compiler, '>=0.5.0')) { + if (satisfies(collected.options.compiler, '>=0.5.0')) { this.cleanModifierInvocationArguments(); } } diff --git a/src/slang-nodes/FunctionType.ts b/src/slang-nodes/FunctionType.ts index 5b277b927..4793cc13d 100644 --- a/src/slang-nodes/FunctionType.ts +++ b/src/slang-nodes/FunctionType.ts @@ -6,9 +6,8 @@ import { FunctionTypeAttributes } from './FunctionTypeAttributes.js'; import { ReturnsDeclaration } from './ReturnsDeclaration.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class FunctionType extends SlangNode { readonly kind = NonterminalKind.FunctionType; @@ -19,21 +18,13 @@ export class FunctionType extends SlangNode { returns?: ReturnsDeclaration; - constructor( - ast: ast.FunctionType, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.FunctionType, collected: CollectedMetadata) { super(ast, collected); - this.parameters = new ParametersDeclaration( - ast.parameters, - collected, - options - ); + this.parameters = new ParametersDeclaration(ast.parameters, collected); this.attributes = new FunctionTypeAttributes(ast.attributes, collected); if (ast.returns) { - this.returns = new ReturnsDeclaration(ast.returns, collected, options); + this.returns = new ReturnsDeclaration(ast.returns, collected); } this.updateMetadata(this.parameters, this.attributes, this.returns); diff --git a/src/slang-nodes/HexStringLiteral.ts b/src/slang-nodes/HexStringLiteral.ts index d544c7839..ccb8e6a5d 100644 --- a/src/slang-nodes/HexStringLiteral.ts +++ b/src/slang-nodes/HexStringLiteral.ts @@ -3,25 +3,20 @@ import { printString } from '../slang-printers/print-string.js'; import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class HexStringLiteral extends SlangNode { readonly kind = NonterminalKind.HexStringLiteral; variant: string; - constructor( - ast: ast.HexStringLiteral, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.HexStringLiteral, collected: CollectedMetadata) { super(ast, collected); this.variant = ast.variant.unparse(); - this.variant = `hex${printString(this.variant.slice(4, -1), options)}`; + this.variant = `hex${printString(this.variant.slice(4, -1), collected.options)}`; } print(): Doc { diff --git a/src/slang-nodes/HexStringLiterals.ts b/src/slang-nodes/HexStringLiterals.ts index aba2f2a75..4384f5d8c 100644 --- a/src/slang-nodes/HexStringLiterals.ts +++ b/src/slang-nodes/HexStringLiterals.ts @@ -4,9 +4,8 @@ import { SlangNode } from './SlangNode.js'; import { HexStringLiteral } from './HexStringLiteral.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { join, hardline } = doc.builders; @@ -15,16 +14,10 @@ export class HexStringLiterals extends SlangNode { items: HexStringLiteral[]; - constructor( - ast: ast.HexStringLiterals, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.HexStringLiterals, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new HexStringLiteral(item, collected, options) - ); + this.items = ast.items.map((item) => new HexStringLiteral(item, collected)); } print(print: PrintFunction, path: AstPath): Doc { diff --git a/src/slang-nodes/IfStatement.ts b/src/slang-nodes/IfStatement.ts index e4f0a4cd6..b0667f67c 100644 --- a/src/slang-nodes/IfStatement.ts +++ b/src/slang-nodes/IfStatement.ts @@ -10,9 +10,8 @@ import { Statement } from './Statement.js'; import { ElseBranch } from './ElseBranch.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { hardline } = doc.builders; @@ -25,19 +24,13 @@ export class IfStatement extends SlangNode { elseBranch?: ElseBranch; - constructor( - ast: ast.IfStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.IfStatement, collected: CollectedMetadata) { super(ast, collected); - this.condition = extractVariant( - new Expression(ast.condition, collected, options) - ); - this.body = extractVariant(new Statement(ast.body, collected, options)); + this.condition = extractVariant(new Expression(ast.condition, collected)); + this.body = extractVariant(new Statement(ast.body, collected)); if (ast.elseBranch) { - this.elseBranch = new ElseBranch(ast.elseBranch, collected, options); + this.elseBranch = new ElseBranch(ast.elseBranch, collected); } this.updateMetadata(this.condition, this.body, this.elseBranch); diff --git a/src/slang-nodes/ImportClause.ts b/src/slang-nodes/ImportClause.ts index 75724102a..ab30d43fa 100644 --- a/src/slang-nodes/ImportClause.ts +++ b/src/slang-nodes/ImportClause.ts @@ -6,9 +6,7 @@ import { PathImport } from './PathImport.js'; import { NamedImport } from './NamedImport.js'; import { ImportDeconstruction } from './ImportDeconstruction.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.ImportClause, @@ -24,14 +22,10 @@ export class ImportClause extends SlangNode { variant: PathImport | NamedImport | ImportDeconstruction; - constructor( - ast: ast.ImportClause, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ImportClause, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ImportDeconstruction.ts b/src/slang-nodes/ImportDeconstruction.ts index a97eb88f7..607cc2762 100644 --- a/src/slang-nodes/ImportDeconstruction.ts +++ b/src/slang-nodes/ImportDeconstruction.ts @@ -4,9 +4,8 @@ import { ImportDeconstructionSymbols } from './ImportDeconstructionSymbols.js'; import { StringLiteral } from './StringLiteral.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ImportDeconstruction extends SlangNode { readonly kind = NonterminalKind.ImportDeconstruction; @@ -15,15 +14,11 @@ export class ImportDeconstruction extends SlangNode { path: StringLiteral; - constructor( - ast: ast.ImportDeconstruction, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ImportDeconstruction, collected: CollectedMetadata) { super(ast, collected); this.symbols = new ImportDeconstructionSymbols(ast.symbols, collected); - this.path = new StringLiteral(ast.path, collected, options); + this.path = new StringLiteral(ast.path, collected); this.updateMetadata(this.symbols, this.path); } diff --git a/src/slang-nodes/ImportDirective.ts b/src/slang-nodes/ImportDirective.ts index f1ccfb98c..5975a913e 100644 --- a/src/slang-nodes/ImportDirective.ts +++ b/src/slang-nodes/ImportDirective.ts @@ -4,25 +4,18 @@ import { SlangNode } from './SlangNode.js'; import { ImportClause } from './ImportClause.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ImportDirective extends SlangNode { readonly kind = NonterminalKind.ImportDirective; clause: ImportClause['variant']; - constructor( - ast: ast.ImportDirective, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ImportDirective, collected: CollectedMetadata) { super(ast, collected); - this.clause = extractVariant( - new ImportClause(ast.clause, collected, options) - ); + this.clause = extractVariant(new ImportClause(ast.clause, collected)); this.updateMetadata(this.clause); } diff --git a/src/slang-nodes/IndexAccessEnd.ts b/src/slang-nodes/IndexAccessEnd.ts index 2b7b63e16..1c71f376b 100644 --- a/src/slang-nodes/IndexAccessEnd.ts +++ b/src/slang-nodes/IndexAccessEnd.ts @@ -4,24 +4,19 @@ import { SlangNode } from './SlangNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class IndexAccessEnd extends SlangNode { readonly kind = NonterminalKind.IndexAccessEnd; end?: Expression['variant']; - constructor( - ast: ast.IndexAccessEnd, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.IndexAccessEnd, collected: CollectedMetadata) { super(ast, collected); if (ast.end) { - this.end = extractVariant(new Expression(ast.end, collected, options)); + this.end = extractVariant(new Expression(ast.end, collected)); } this.updateMetadata(this.end); diff --git a/src/slang-nodes/IndexAccessExpression.ts b/src/slang-nodes/IndexAccessExpression.ts index 25dbf8575..6f387854a 100644 --- a/src/slang-nodes/IndexAccessExpression.ts +++ b/src/slang-nodes/IndexAccessExpression.ts @@ -7,9 +7,8 @@ import { Expression } from './Expression.js'; import { IndexAccessEnd } from './IndexAccessEnd.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class IndexAccessExpression extends SlangNode { readonly kind = NonterminalKind.IndexAccessExpression; @@ -20,23 +19,15 @@ export class IndexAccessExpression extends SlangNode { end?: IndexAccessEnd; - constructor( - ast: ast.IndexAccessExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.IndexAccessExpression, collected: CollectedMetadata) { super(ast, collected); - this.operand = extractVariant( - new Expression(ast.operand, collected, options) - ); + this.operand = extractVariant(new Expression(ast.operand, collected)); if (ast.start) { - this.start = extractVariant( - new Expression(ast.start, collected, options) - ); + this.start = extractVariant(new Expression(ast.start, collected)); } if (ast.end) { - this.end = new IndexAccessEnd(ast.end, collected, options); + this.end = new IndexAccessEnd(ast.end, collected); } this.updateMetadata(this.operand, this.start, this.end); diff --git a/src/slang-nodes/InequalityExpression.ts b/src/slang-nodes/InequalityExpression.ts index 80bcbf013..350242c2b 100644 --- a/src/slang-nodes/InequalityExpression.ts +++ b/src/slang-nodes/InequalityExpression.ts @@ -27,19 +27,15 @@ export class InequalityExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.InequalityExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.InequalityExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/InheritanceSpecifier.ts b/src/slang-nodes/InheritanceSpecifier.ts index efcad795f..a6aa7ffed 100644 --- a/src/slang-nodes/InheritanceSpecifier.ts +++ b/src/slang-nodes/InheritanceSpecifier.ts @@ -3,23 +3,18 @@ import { SlangNode } from './SlangNode.js'; import { InheritanceTypes } from './InheritanceTypes.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class InheritanceSpecifier extends SlangNode { readonly kind = NonterminalKind.InheritanceSpecifier; types: InheritanceTypes; - constructor( - ast: ast.InheritanceSpecifier, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.InheritanceSpecifier, collected: CollectedMetadata) { super(ast, collected); - this.types = new InheritanceTypes(ast.types, collected, options); + this.types = new InheritanceTypes(ast.types, collected); this.updateMetadata(this.types); } diff --git a/src/slang-nodes/InheritanceType.ts b/src/slang-nodes/InheritanceType.ts index a2cc81e04..612edb5d7 100644 --- a/src/slang-nodes/InheritanceType.ts +++ b/src/slang-nodes/InheritanceType.ts @@ -5,9 +5,8 @@ import { IdentifierPath } from './IdentifierPath.js'; import { ArgumentsDeclaration } from './ArgumentsDeclaration.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class InheritanceType extends SlangNode { readonly kind = NonterminalKind.InheritanceType; @@ -16,17 +15,13 @@ export class InheritanceType extends SlangNode { arguments?: ArgumentsDeclaration['variant']; - constructor( - ast: ast.InheritanceType, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.InheritanceType, collected: CollectedMetadata) { super(ast, collected); this.typeName = new IdentifierPath(ast.typeName, collected); if (ast.arguments) { this.arguments = extractVariant( - new ArgumentsDeclaration(ast.arguments, collected, options) + new ArgumentsDeclaration(ast.arguments, collected) ); } diff --git a/src/slang-nodes/InheritanceTypes.ts b/src/slang-nodes/InheritanceTypes.ts index 011827403..3df44bee8 100644 --- a/src/slang-nodes/InheritanceTypes.ts +++ b/src/slang-nodes/InheritanceTypes.ts @@ -5,9 +5,8 @@ import { SlangNode } from './SlangNode.js'; import { InheritanceType } from './InheritanceType.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { line } = doc.builders; @@ -16,16 +15,10 @@ export class InheritanceTypes extends SlangNode { items: InheritanceType[]; - constructor( - ast: ast.InheritanceTypes, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.InheritanceTypes, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new InheritanceType(item, collected, options) - ); + this.items = ast.items.map((item) => new InheritanceType(item, collected)); } print(print: PrintFunction, path: AstPath): Doc { diff --git a/src/slang-nodes/InterfaceDefinition.ts b/src/slang-nodes/InterfaceDefinition.ts index 9840a900d..94672b12c 100644 --- a/src/slang-nodes/InterfaceDefinition.ts +++ b/src/slang-nodes/InterfaceDefinition.ts @@ -6,9 +6,8 @@ import { InheritanceSpecifier } from './InheritanceSpecifier.js'; import { InterfaceMembers } from './InterfaceMembers.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { group, line } = doc.builders; @@ -21,22 +20,14 @@ export class InterfaceDefinition extends SlangNode { members: InterfaceMembers; - constructor( - ast: ast.InterfaceDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.InterfaceDefinition, collected: CollectedMetadata) { super(ast, collected); this.name = new TerminalNode(ast.name, collected); if (ast.inheritance) { - this.inheritance = new InheritanceSpecifier( - ast.inheritance, - collected, - options - ); + this.inheritance = new InheritanceSpecifier(ast.inheritance, collected); } - this.members = new InterfaceMembers(ast.members, collected, options); + this.members = new InterfaceMembers(ast.members, collected); this.updateMetadata(this.inheritance, this.members); } diff --git a/src/slang-nodes/InterfaceMembers.ts b/src/slang-nodes/InterfaceMembers.ts index 92fb0833c..07001aece 100644 --- a/src/slang-nodes/InterfaceMembers.ts +++ b/src/slang-nodes/InterfaceMembers.ts @@ -18,15 +18,11 @@ export class InterfaceMembers extends SlangNode { items: ContractMember['variant'][]; - constructor( - ast: ast.InterfaceMembers, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.InterfaceMembers, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new ContractMember(item, collected, options)) + extractVariant(new ContractMember(item, collected)) ); } diff --git a/src/slang-nodes/LibraryDefinition.ts b/src/slang-nodes/LibraryDefinition.ts index 06d96c2a8..ded95e455 100644 --- a/src/slang-nodes/LibraryDefinition.ts +++ b/src/slang-nodes/LibraryDefinition.ts @@ -6,9 +6,8 @@ import { TerminalNode } from './TerminalNode.js'; import { LibraryMembers } from './LibraryMembers.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { group, line } = doc.builders; @@ -19,15 +18,11 @@ export class LibraryDefinition extends SlangNode { members: LibraryMembers; - constructor( - ast: ast.LibraryDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.LibraryDefinition, collected: CollectedMetadata) { super(ast, collected); this.name = new TerminalNode(ast.name, collected); - this.members = new LibraryMembers(ast.members, collected, options); + this.members = new LibraryMembers(ast.members, collected); this.updateMetadata(this.members); @@ -35,7 +30,7 @@ export class LibraryDefinition extends SlangNode { // the same name as the contract. // So we delegate to the parents the responsibility of cleaning the // arguments of modifier invocations. - if (!satisfies(options.compiler, '>=0.5.0')) { + if (!satisfies(collected.options.compiler, '>=0.5.0')) { for (const member of this.members.items) { if (member.kind === NonterminalKind.FunctionDefinition) { member.cleanModifierInvocationArguments(); diff --git a/src/slang-nodes/LibraryMembers.ts b/src/slang-nodes/LibraryMembers.ts index fb2f012d7..0210fe204 100644 --- a/src/slang-nodes/LibraryMembers.ts +++ b/src/slang-nodes/LibraryMembers.ts @@ -18,15 +18,11 @@ export class LibraryMembers extends SlangNode { items: ContractMember['variant'][]; - constructor( - ast: ast.LibraryMembers, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.LibraryMembers, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new ContractMember(item, collected, options)) + extractVariant(new ContractMember(item, collected)) ); } diff --git a/src/slang-nodes/MappingType.ts b/src/slang-nodes/MappingType.ts index 819825975..2a5ec4de6 100644 --- a/src/slang-nodes/MappingType.ts +++ b/src/slang-nodes/MappingType.ts @@ -4,9 +4,8 @@ import { MappingKey } from './MappingKey.js'; import { MappingValue } from './MappingValue.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class MappingType extends SlangNode { readonly kind = NonterminalKind.MappingType; @@ -15,15 +14,11 @@ export class MappingType extends SlangNode { valueType: MappingValue; - constructor( - ast: ast.MappingType, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.MappingType, collected: CollectedMetadata) { super(ast, collected); this.keyType = new MappingKey(ast.keyType, collected); - this.valueType = new MappingValue(ast.valueType, collected, options); + this.valueType = new MappingValue(ast.valueType, collected); this.updateMetadata(this.keyType, this.valueType); } diff --git a/src/slang-nodes/MappingValue.ts b/src/slang-nodes/MappingValue.ts index 0df330500..3cd837f0f 100644 --- a/src/slang-nodes/MappingValue.ts +++ b/src/slang-nodes/MappingValue.ts @@ -6,9 +6,8 @@ import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class MappingValue extends SlangNode { readonly kind = NonterminalKind.MappingValue; @@ -17,16 +16,10 @@ export class MappingValue extends SlangNode { name?: TerminalNode; - constructor( - ast: ast.MappingValue, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.MappingValue, collected: CollectedMetadata) { super(ast, collected); - this.typeName = extractVariant( - new TypeName(ast.typeName, collected, options) - ); + this.typeName = extractVariant(new TypeName(ast.typeName, collected)); if (ast.name) { this.name = new TerminalNode(ast.name, collected); } diff --git a/src/slang-nodes/MemberAccessExpression.ts b/src/slang-nodes/MemberAccessExpression.ts index 921283b9a..cc97f126f 100644 --- a/src/slang-nodes/MemberAccessExpression.ts +++ b/src/slang-nodes/MemberAccessExpression.ts @@ -9,7 +9,7 @@ import { Expression } from './Expression.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; import type { ChainableExpression, PrintableNode } from './types.d.ts'; @@ -115,16 +115,10 @@ export class MemberAccessExpression extends SlangNode { member: TerminalNode; - constructor( - ast: ast.MemberAccessExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.MemberAccessExpression, collected: CollectedMetadata) { super(ast, collected); - this.operand = extractVariant( - new Expression(ast.operand, collected, options) - ); + this.operand = extractVariant(new Expression(ast.operand, collected)); this.member = new TerminalNode(ast.member, collected); this.updateMetadata(this.operand); diff --git a/src/slang-nodes/ModifierDefinition.ts b/src/slang-nodes/ModifierDefinition.ts index e067c0598..afe65355c 100644 --- a/src/slang-nodes/ModifierDefinition.ts +++ b/src/slang-nodes/ModifierDefinition.ts @@ -9,13 +9,12 @@ import { ModifierAttributes } from './ModifierAttributes.js'; import { FunctionBody } from './FunctionBody.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { AstLocation, CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ModifierDefinition extends SlangNode { readonly kind = NonterminalKind.ModifierDefinition; @@ -28,23 +27,15 @@ export class ModifierDefinition extends SlangNode { body: FunctionBody['variant']; - constructor( - ast: ast.ModifierDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ModifierDefinition, collected: CollectedMetadata) { super(ast, collected); this.name = new TerminalNode(ast.name, collected); if (ast.parameters) { - this.parameters = new ParametersDeclaration( - ast.parameters, - collected, - options - ); + this.parameters = new ParametersDeclaration(ast.parameters, collected); } this.attributes = new ModifierAttributes(ast.attributes, collected); - this.body = extractVariant(new FunctionBody(ast.body, collected, options)); + this.body = extractVariant(new FunctionBody(ast.body, collected)); this.updateMetadata(this.parameters, this.attributes, this.body); diff --git a/src/slang-nodes/ModifierInvocation.ts b/src/slang-nodes/ModifierInvocation.ts index a144faa2d..60f40a37e 100644 --- a/src/slang-nodes/ModifierInvocation.ts +++ b/src/slang-nodes/ModifierInvocation.ts @@ -5,9 +5,8 @@ import { IdentifierPath } from './IdentifierPath.js'; import { ArgumentsDeclaration } from './ArgumentsDeclaration.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ModifierInvocation extends SlangNode { readonly kind = NonterminalKind.ModifierInvocation; @@ -16,17 +15,13 @@ export class ModifierInvocation extends SlangNode { arguments?: ArgumentsDeclaration['variant']; - constructor( - ast: ast.ModifierInvocation, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ModifierInvocation, collected: CollectedMetadata) { super(ast, collected); this.name = new IdentifierPath(ast.name, collected); if (ast.arguments) { this.arguments = extractVariant( - new ArgumentsDeclaration(ast.arguments, collected, options) + new ArgumentsDeclaration(ast.arguments, collected) ); } diff --git a/src/slang-nodes/MultiplicativeExpression.ts b/src/slang-nodes/MultiplicativeExpression.ts index 5a1a7415f..949106023 100644 --- a/src/slang-nodes/MultiplicativeExpression.ts +++ b/src/slang-nodes/MultiplicativeExpression.ts @@ -40,19 +40,15 @@ export class MultiplicativeExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.MultiplicativeExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.MultiplicativeExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/NamedArgument.ts b/src/slang-nodes/NamedArgument.ts index 84c73f178..7527e7e5a 100644 --- a/src/slang-nodes/NamedArgument.ts +++ b/src/slang-nodes/NamedArgument.ts @@ -5,9 +5,8 @@ import { TerminalNode } from './TerminalNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class NamedArgument extends SlangNode { readonly kind = NonterminalKind.NamedArgument; @@ -16,15 +15,11 @@ export class NamedArgument extends SlangNode { value: Expression['variant']; - constructor( - ast: ast.NamedArgument, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.NamedArgument, collected: CollectedMetadata) { super(ast, collected); this.name = new TerminalNode(ast.name, collected); - this.value = extractVariant(new Expression(ast.value, collected, options)); + this.value = extractVariant(new Expression(ast.value, collected)); this.updateMetadata(this.value); } diff --git a/src/slang-nodes/NamedArgumentGroup.ts b/src/slang-nodes/NamedArgumentGroup.ts index f12878d9b..be0f05c05 100644 --- a/src/slang-nodes/NamedArgumentGroup.ts +++ b/src/slang-nodes/NamedArgumentGroup.ts @@ -3,23 +3,18 @@ import { SlangNode } from './SlangNode.js'; import { NamedArguments } from './NamedArguments.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class NamedArgumentGroup extends SlangNode { readonly kind = NonterminalKind.NamedArgumentGroup; arguments: NamedArguments; - constructor( - ast: ast.NamedArgumentGroup, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.NamedArgumentGroup, collected: CollectedMetadata) { super(ast, collected); - this.arguments = new NamedArguments(ast.arguments, collected, options); + this.arguments = new NamedArguments(ast.arguments, collected); this.updateMetadata(this.arguments); } diff --git a/src/slang-nodes/NamedArguments.ts b/src/slang-nodes/NamedArguments.ts index 2b4fb3c4c..acffe60c7 100644 --- a/src/slang-nodes/NamedArguments.ts +++ b/src/slang-nodes/NamedArguments.ts @@ -16,16 +16,10 @@ export class NamedArguments extends SlangNode { items: NamedArgument[]; - constructor( - ast: ast.NamedArguments, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.NamedArguments, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new NamedArgument(item, collected, options) - ); + this.items = ast.items.map((item) => new NamedArgument(item, collected)); } print( diff --git a/src/slang-nodes/NamedArgumentsDeclaration.ts b/src/slang-nodes/NamedArgumentsDeclaration.ts index 6e900e5d3..4ecb6f4c8 100644 --- a/src/slang-nodes/NamedArgumentsDeclaration.ts +++ b/src/slang-nodes/NamedArgumentsDeclaration.ts @@ -3,9 +3,8 @@ import { SlangNode } from './SlangNode.js'; import { NamedArgumentGroup } from './NamedArgumentGroup.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class NamedArgumentsDeclaration extends SlangNode { readonly kind = NonterminalKind.NamedArgumentsDeclaration; @@ -14,17 +13,12 @@ export class NamedArgumentsDeclaration extends SlangNode { constructor( ast: ast.NamedArgumentsDeclaration, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); if (ast.arguments) { - this.arguments = new NamedArgumentGroup( - ast.arguments, - collected, - options - ); + this.arguments = new NamedArgumentGroup(ast.arguments, collected); } this.updateMetadata(this.arguments); diff --git a/src/slang-nodes/NamedImport.ts b/src/slang-nodes/NamedImport.ts index 5238681f9..1af2b4190 100644 --- a/src/slang-nodes/NamedImport.ts +++ b/src/slang-nodes/NamedImport.ts @@ -4,9 +4,8 @@ import { ImportAlias } from './ImportAlias.js'; import { StringLiteral } from './StringLiteral.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class NamedImport extends SlangNode { readonly kind = NonterminalKind.NamedImport; @@ -15,15 +14,11 @@ export class NamedImport extends SlangNode { path: StringLiteral; - constructor( - ast: ast.NamedImport, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.NamedImport, collected: CollectedMetadata) { super(ast, collected); this.alias = new ImportAlias(ast.alias, collected); - this.path = new StringLiteral(ast.path, collected, options); + this.path = new StringLiteral(ast.path, collected); this.updateMetadata(this.alias, this.path); } diff --git a/src/slang-nodes/NewExpression.ts b/src/slang-nodes/NewExpression.ts index 0331037a8..91853b4a9 100644 --- a/src/slang-nodes/NewExpression.ts +++ b/src/slang-nodes/NewExpression.ts @@ -4,25 +4,18 @@ import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class NewExpression extends SlangNode { readonly kind = NonterminalKind.NewExpression; typeName: TypeName['variant']; - constructor( - ast: ast.NewExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.NewExpression, collected: CollectedMetadata) { super(ast, collected); - this.typeName = extractVariant( - new TypeName(ast.typeName, collected, options) - ); + this.typeName = extractVariant(new TypeName(ast.typeName, collected)); this.updateMetadata(this.typeName); } diff --git a/src/slang-nodes/OrExpression.ts b/src/slang-nodes/OrExpression.ts index f67a80f42..06a272776 100644 --- a/src/slang-nodes/OrExpression.ts +++ b/src/slang-nodes/OrExpression.ts @@ -21,19 +21,15 @@ export class OrExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.OrExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.OrExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/Parameter.ts b/src/slang-nodes/Parameter.ts index fac9c2ef6..e9abcfe1e 100644 --- a/src/slang-nodes/Parameter.ts +++ b/src/slang-nodes/Parameter.ts @@ -8,9 +8,8 @@ import { StorageLocation } from './StorageLocation.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { group } = doc.builders; @@ -23,16 +22,10 @@ export class Parameter extends SlangNode { name?: TerminalNode; - constructor( - ast: ast.Parameter, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.Parameter, collected: CollectedMetadata) { super(ast, collected); - this.typeName = extractVariant( - new TypeName(ast.typeName, collected, options) - ); + this.typeName = extractVariant(new TypeName(ast.typeName, collected)); if (ast.storageLocation) { this.storageLocation = new StorageLocation( ast.storageLocation, diff --git a/src/slang-nodes/Parameters.ts b/src/slang-nodes/Parameters.ts index 43ee709f8..718fe79e4 100644 --- a/src/slang-nodes/Parameters.ts +++ b/src/slang-nodes/Parameters.ts @@ -15,16 +15,10 @@ export class Parameters extends SlangNode { items: Parameter[]; - constructor( - ast: ast.Parameters, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.Parameters, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new Parameter(item, collected, options) - ); + this.items = ast.items.map((item) => new Parameter(item, collected)); } print( diff --git a/src/slang-nodes/ParametersDeclaration.ts b/src/slang-nodes/ParametersDeclaration.ts index 9d139eb63..939d8c650 100644 --- a/src/slang-nodes/ParametersDeclaration.ts +++ b/src/slang-nodes/ParametersDeclaration.ts @@ -3,23 +3,18 @@ import { SlangNode } from './SlangNode.js'; import { Parameters } from './Parameters.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ParametersDeclaration extends SlangNode { readonly kind = NonterminalKind.ParametersDeclaration; parameters: Parameters; - constructor( - ast: ast.ParametersDeclaration, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ParametersDeclaration, collected: CollectedMetadata) { super(ast, collected); - this.parameters = new Parameters(ast.parameters, collected, options); + this.parameters = new Parameters(ast.parameters, collected); this.updateMetadata(this.parameters); } diff --git a/src/slang-nodes/PathImport.ts b/src/slang-nodes/PathImport.ts index e46e18338..589b9bac7 100644 --- a/src/slang-nodes/PathImport.ts +++ b/src/slang-nodes/PathImport.ts @@ -4,9 +4,8 @@ import { StringLiteral } from './StringLiteral.js'; import { ImportAlias } from './ImportAlias.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class PathImport extends SlangNode { readonly kind = NonterminalKind.PathImport; @@ -15,14 +14,10 @@ export class PathImport extends SlangNode { alias?: ImportAlias; - constructor( - ast: ast.PathImport, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.PathImport, collected: CollectedMetadata) { super(ast, collected); - this.path = new StringLiteral(ast.path, collected, options); + this.path = new StringLiteral(ast.path, collected); if (ast.alias) { this.alias = new ImportAlias(ast.alias, collected); } diff --git a/src/slang-nodes/PositionalArguments.ts b/src/slang-nodes/PositionalArguments.ts index ed0b538ae..1d104e506 100644 --- a/src/slang-nodes/PositionalArguments.ts +++ b/src/slang-nodes/PositionalArguments.ts @@ -16,15 +16,11 @@ export class PositionalArguments extends SlangNode { items: Expression['variant'][]; - constructor( - ast: ast.PositionalArguments, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.PositionalArguments, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new Expression(item, collected, options)) + extractVariant(new Expression(item, collected)) ); } diff --git a/src/slang-nodes/PositionalArgumentsDeclaration.ts b/src/slang-nodes/PositionalArgumentsDeclaration.ts index 88ddec4fe..9b6a5a548 100644 --- a/src/slang-nodes/PositionalArgumentsDeclaration.ts +++ b/src/slang-nodes/PositionalArgumentsDeclaration.ts @@ -4,9 +4,8 @@ import { SlangNode } from './SlangNode.js'; import { PositionalArguments } from './PositionalArguments.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class PositionalArgumentsDeclaration extends SlangNode { readonly kind = NonterminalKind.PositionalArgumentsDeclaration; @@ -17,12 +16,11 @@ export class PositionalArgumentsDeclaration extends SlangNode { constructor( ast: ast.PositionalArgumentsDeclaration, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); - this.arguments = new PositionalArguments(ast.arguments, collected, options); + this.arguments = new PositionalArguments(ast.arguments, collected); this.updateMetadata(this.arguments); diff --git a/src/slang-nodes/PostfixExpression.ts b/src/slang-nodes/PostfixExpression.ts index 863c83218..de92f8fc3 100644 --- a/src/slang-nodes/PostfixExpression.ts +++ b/src/slang-nodes/PostfixExpression.ts @@ -4,9 +4,8 @@ import { SlangNode } from './SlangNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class PostfixExpression extends SlangNode { readonly kind = NonterminalKind.PostfixExpression; @@ -15,16 +14,10 @@ export class PostfixExpression extends SlangNode { operator: string; - constructor( - ast: ast.PostfixExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.PostfixExpression, collected: CollectedMetadata) { super(ast, collected); - this.operand = extractVariant( - new Expression(ast.operand, collected, options) - ); + this.operand = extractVariant(new Expression(ast.operand, collected)); this.operator = ast.operator.unparse(); this.updateMetadata(this.operand); diff --git a/src/slang-nodes/Pragma.ts b/src/slang-nodes/Pragma.ts index 822d78c64..ad129e7b4 100644 --- a/src/slang-nodes/Pragma.ts +++ b/src/slang-nodes/Pragma.ts @@ -6,9 +6,7 @@ import { AbicoderPragma } from './AbicoderPragma.js'; import { ExperimentalPragma } from './ExperimentalPragma.js'; import { VersionPragma } from './VersionPragma.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.Pragma, @@ -24,14 +22,10 @@ export class Pragma extends SlangNode { variant: AbicoderPragma | ExperimentalPragma | VersionPragma; - constructor( - ast: ast.Pragma, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.Pragma, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/PragmaDirective.ts b/src/slang-nodes/PragmaDirective.ts index fd6226668..1c4261181 100644 --- a/src/slang-nodes/PragmaDirective.ts +++ b/src/slang-nodes/PragmaDirective.ts @@ -4,23 +4,18 @@ import { SlangNode } from './SlangNode.js'; import { Pragma } from './Pragma.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class PragmaDirective extends SlangNode { readonly kind = NonterminalKind.PragmaDirective; pragma: Pragma['variant']; - constructor( - ast: ast.PragmaDirective, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.PragmaDirective, collected: CollectedMetadata) { super(ast, collected); - this.pragma = extractVariant(new Pragma(ast.pragma, collected, options)); + this.pragma = extractVariant(new Pragma(ast.pragma, collected)); this.updateMetadata(this.pragma); } diff --git a/src/slang-nodes/PrefixExpression.ts b/src/slang-nodes/PrefixExpression.ts index 3910d2f61..bf78b6b86 100644 --- a/src/slang-nodes/PrefixExpression.ts +++ b/src/slang-nodes/PrefixExpression.ts @@ -4,9 +4,8 @@ import { SlangNode } from './SlangNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class PrefixExpression extends SlangNode { readonly kind = NonterminalKind.PrefixExpression; @@ -15,17 +14,11 @@ export class PrefixExpression extends SlangNode { operand: Expression['variant']; - constructor( - ast: ast.PrefixExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.PrefixExpression, collected: CollectedMetadata) { super(ast, collected); this.operator = ast.operator.unparse(); - this.operand = extractVariant( - new Expression(ast.operand, collected, options) - ); + this.operand = extractVariant(new Expression(ast.operand, collected)); this.updateMetadata(this.operand); diff --git a/src/slang-nodes/ReceiveFunctionAttribute.ts b/src/slang-nodes/ReceiveFunctionAttribute.ts index 713fa0e94..05fdffcf8 100644 --- a/src/slang-nodes/ReceiveFunctionAttribute.ts +++ b/src/slang-nodes/ReceiveFunctionAttribute.ts @@ -9,9 +9,7 @@ import { ModifierInvocation } from './ModifierInvocation.js'; import { OverrideSpecifier } from './OverrideSpecifier.js'; import { TerminalNode } from './TerminalNode.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.ReceiveFunctionAttribute, @@ -26,11 +24,7 @@ export class ReceiveFunctionAttribute extends SlangNode { variant: ModifierInvocation | OverrideSpecifier | TerminalNode; - constructor( - ast: ast.ReceiveFunctionAttribute, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ReceiveFunctionAttribute, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -38,7 +32,7 @@ export class ReceiveFunctionAttribute extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = createNonterminalVariant(variant, collected, options); + this.variant = createNonterminalVariant(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/ReceiveFunctionAttributes.ts b/src/slang-nodes/ReceiveFunctionAttributes.ts index da82ef171..88e8f0e77 100644 --- a/src/slang-nodes/ReceiveFunctionAttributes.ts +++ b/src/slang-nodes/ReceiveFunctionAttributes.ts @@ -6,9 +6,8 @@ import { SlangNode } from './SlangNode.js'; import { ReceiveFunctionAttribute } from './ReceiveFunctionAttribute.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { line } = doc.builders; @@ -19,13 +18,12 @@ export class ReceiveFunctionAttributes extends SlangNode { constructor( ast: ast.ReceiveFunctionAttributes, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new ReceiveFunctionAttribute(item, collected, options)) + extractVariant(new ReceiveFunctionAttribute(item, collected)) ); this.items.sort(sortFunctionAttributes); diff --git a/src/slang-nodes/ReceiveFunctionDefinition.ts b/src/slang-nodes/ReceiveFunctionDefinition.ts index 32137b17e..2a739b3a9 100644 --- a/src/slang-nodes/ReceiveFunctionDefinition.ts +++ b/src/slang-nodes/ReceiveFunctionDefinition.ts @@ -7,9 +7,8 @@ import { ReceiveFunctionAttributes } from './ReceiveFunctionAttributes.js'; import { FunctionBody } from './FunctionBody.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class ReceiveFunctionDefinition extends SlangNode { readonly kind = NonterminalKind.ReceiveFunctionDefinition; @@ -22,22 +21,13 @@ export class ReceiveFunctionDefinition extends SlangNode { constructor( ast: ast.ReceiveFunctionDefinition, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); - this.parameters = new ParametersDeclaration( - ast.parameters, - collected, - options - ); - this.attributes = new ReceiveFunctionAttributes( - ast.attributes, - collected, - options - ); - this.body = extractVariant(new FunctionBody(ast.body, collected, options)); + this.parameters = new ParametersDeclaration(ast.parameters, collected); + this.attributes = new ReceiveFunctionAttributes(ast.attributes, collected); + this.body = extractVariant(new FunctionBody(ast.body, collected)); this.updateMetadata(this.parameters, this.attributes, this.body); diff --git a/src/slang-nodes/ReturnStatement.ts b/src/slang-nodes/ReturnStatement.ts index 610aa31b5..9d0ee5f6c 100644 --- a/src/slang-nodes/ReturnStatement.ts +++ b/src/slang-nodes/ReturnStatement.ts @@ -14,16 +14,12 @@ export class ReturnStatement extends SlangNode { expression?: Expression['variant']; - constructor( - ast: ast.ReturnStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ReturnStatement, collected: CollectedMetadata) { super(ast, collected); if (ast.expression) { this.expression = extractVariant( - new Expression(ast.expression, collected, options) + new Expression(ast.expression, collected) ); } diff --git a/src/slang-nodes/ReturnsDeclaration.ts b/src/slang-nodes/ReturnsDeclaration.ts index 5f37971fc..b37fc6ab9 100644 --- a/src/slang-nodes/ReturnsDeclaration.ts +++ b/src/slang-nodes/ReturnsDeclaration.ts @@ -4,9 +4,8 @@ import { SlangNode } from './SlangNode.js'; import { ParametersDeclaration } from './ParametersDeclaration.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { group } = doc.builders; @@ -15,18 +14,10 @@ export class ReturnsDeclaration extends SlangNode { variables: ParametersDeclaration; - constructor( - ast: ast.ReturnsDeclaration, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ReturnsDeclaration, collected: CollectedMetadata) { super(ast, collected); - this.variables = new ParametersDeclaration( - ast.variables, - collected, - options - ); + this.variables = new ParametersDeclaration(ast.variables, collected); this.updateMetadata(this.variables); } diff --git a/src/slang-nodes/RevertStatement.ts b/src/slang-nodes/RevertStatement.ts index ac5709870..92e8c37c6 100644 --- a/src/slang-nodes/RevertStatement.ts +++ b/src/slang-nodes/RevertStatement.ts @@ -5,9 +5,8 @@ import { IdentifierPath } from './IdentifierPath.js'; import { ArgumentsDeclaration } from './ArgumentsDeclaration.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class RevertStatement extends SlangNode { readonly kind = NonterminalKind.RevertStatement; @@ -16,16 +15,12 @@ export class RevertStatement extends SlangNode { arguments: ArgumentsDeclaration['variant']; - constructor( - ast: ast.RevertStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.RevertStatement, collected: CollectedMetadata) { super(ast, collected); this.error = new IdentifierPath(ast.error, collected); this.arguments = extractVariant( - new ArgumentsDeclaration(ast.arguments, collected, options) + new ArgumentsDeclaration(ast.arguments, collected) ); this.updateMetadata(this.error, this.arguments); diff --git a/src/slang-nodes/ShiftExpression.ts b/src/slang-nodes/ShiftExpression.ts index 93bcb2b4e..39a729312 100644 --- a/src/slang-nodes/ShiftExpression.ts +++ b/src/slang-nodes/ShiftExpression.ts @@ -43,19 +43,15 @@ export class ShiftExpression extends SlangNode { rightOperand: Expression['variant']; - constructor( - ast: ast.ShiftExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.ShiftExpression, collected: CollectedMetadata) { super(ast, collected); this.leftOperand = extractVariant( - new Expression(ast.leftOperand, collected, options) + new Expression(ast.leftOperand, collected) ); this.operator = ast.operator.unparse(); this.rightOperand = extractVariant( - new Expression(ast.rightOperand, collected, options) + new Expression(ast.rightOperand, collected) ); this.updateMetadata(this.leftOperand, this.rightOperand); diff --git a/src/slang-nodes/SourceUnit.ts b/src/slang-nodes/SourceUnit.ts index c4da539ab..c96e8ea4b 100644 --- a/src/slang-nodes/SourceUnit.ts +++ b/src/slang-nodes/SourceUnit.ts @@ -15,14 +15,10 @@ export class SourceUnit extends SlangNode { members: SourceUnitMembers; - constructor( - ast: ast.SourceUnit, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.SourceUnit, collected: CollectedMetadata) { super(ast, collected); - this.members = new SourceUnitMembers(ast.members, collected, options); + this.members = new SourceUnitMembers(ast.members, collected); this.updateMetadata(this.members); } diff --git a/src/slang-nodes/SourceUnitMember.ts b/src/slang-nodes/SourceUnitMember.ts index 09d19f523..072525f80 100644 --- a/src/slang-nodes/SourceUnitMember.ts +++ b/src/slang-nodes/SourceUnitMember.ts @@ -16,9 +16,7 @@ import { UserDefinedValueTypeDefinition } from './UserDefinedValueTypeDefinition import { UsingDirective } from './UsingDirective.js'; import { EventDefinition } from './EventDefinition.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.SourceUnitMember, @@ -57,14 +55,10 @@ export class SourceUnitMember extends SlangNode { | UsingDirective | EventDefinition; - constructor( - ast: ast.SourceUnitMember, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.SourceUnitMember, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/SourceUnitMembers.ts b/src/slang-nodes/SourceUnitMembers.ts index 87d6707d2..27a11fd51 100644 --- a/src/slang-nodes/SourceUnitMembers.ts +++ b/src/slang-nodes/SourceUnitMembers.ts @@ -14,15 +14,11 @@ export class SourceUnitMembers extends SlangNode { items: SourceUnitMember['variant'][]; - constructor( - ast: ast.SourceUnitMembers, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.SourceUnitMembers, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new SourceUnitMember(item, collected, options)) + extractVariant(new SourceUnitMember(item, collected)) ); } diff --git a/src/slang-nodes/StateVariableDefinition.ts b/src/slang-nodes/StateVariableDefinition.ts index 8a85ddce6..a37e1d6e6 100644 --- a/src/slang-nodes/StateVariableDefinition.ts +++ b/src/slang-nodes/StateVariableDefinition.ts @@ -9,9 +9,8 @@ import { TerminalNode } from './TerminalNode.js'; import { StateVariableDefinitionValue } from './StateVariableDefinitionValue.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { indent } = doc.builders; @@ -26,24 +25,14 @@ export class StateVariableDefinition extends SlangNode { value?: StateVariableDefinitionValue; - constructor( - ast: ast.StateVariableDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.StateVariableDefinition, collected: CollectedMetadata) { super(ast, collected); - this.typeName = extractVariant( - new TypeName(ast.typeName, collected, options) - ); + this.typeName = extractVariant(new TypeName(ast.typeName, collected)); this.attributes = new StateVariableAttributes(ast.attributes, collected); this.name = new TerminalNode(ast.name, collected); if (ast.value) { - this.value = new StateVariableDefinitionValue( - ast.value, - collected, - options - ); + this.value = new StateVariableDefinitionValue(ast.value, collected); } this.updateMetadata(this.typeName, this.attributes, this.value); diff --git a/src/slang-nodes/StateVariableDefinitionValue.ts b/src/slang-nodes/StateVariableDefinitionValue.ts index aee84546b..68f56ae15 100644 --- a/src/slang-nodes/StateVariableDefinitionValue.ts +++ b/src/slang-nodes/StateVariableDefinitionValue.ts @@ -5,9 +5,8 @@ import { SlangNode } from './SlangNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class StateVariableDefinitionValue extends SlangNode { readonly kind = NonterminalKind.StateVariableDefinitionValue; @@ -16,12 +15,11 @@ export class StateVariableDefinitionValue extends SlangNode { constructor( ast: ast.StateVariableDefinitionValue, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); - this.value = extractVariant(new Expression(ast.value, collected, options)); + this.value = extractVariant(new Expression(ast.value, collected)); this.updateMetadata(this.value); } diff --git a/src/slang-nodes/Statement.ts b/src/slang-nodes/Statement.ts index db63e6f58..5400b22b5 100644 --- a/src/slang-nodes/Statement.ts +++ b/src/slang-nodes/Statement.ts @@ -20,9 +20,7 @@ import { AssemblyStatement } from './AssemblyStatement.js'; import { Block } from './Block.js'; import { UncheckedBlock } from './UncheckedBlock.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< slangAst.Statement, @@ -68,18 +66,14 @@ export class Statement extends SlangNode { | Block | UncheckedBlock; - constructor( - ast: slangAst.Statement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: slangAst.Statement, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; this.variant = variant instanceof slangAst.Block - ? new Block(variant, collected, options) - : createNonterminalVariant(variant, collected, options); + ? new Block(variant, collected) + : createNonterminalVariant(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/Statements.ts b/src/slang-nodes/Statements.ts index 587902dbf..ae6dbebc2 100644 --- a/src/slang-nodes/Statements.ts +++ b/src/slang-nodes/Statements.ts @@ -18,15 +18,11 @@ export class Statements extends SlangNode { items: Statement['variant'][]; - constructor( - ast: ast.Statements, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.Statements, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new Statement(item, collected, options)) + extractVariant(new Statement(item, collected)) ); } diff --git a/src/slang-nodes/StorageLayoutSpecifier.ts b/src/slang-nodes/StorageLayoutSpecifier.ts index 3df232038..70a93bca0 100644 --- a/src/slang-nodes/StorageLayoutSpecifier.ts +++ b/src/slang-nodes/StorageLayoutSpecifier.ts @@ -6,9 +6,8 @@ import { SlangNode } from './SlangNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { line } = doc.builders; @@ -17,16 +16,10 @@ export class StorageLayoutSpecifier extends SlangNode { expression: Expression['variant']; - constructor( - ast: ast.StorageLayoutSpecifier, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.StorageLayoutSpecifier, collected: CollectedMetadata) { super(ast, collected); - this.expression = extractVariant( - new Expression(ast.expression, collected, options) - ); + this.expression = extractVariant(new Expression(ast.expression, collected)); this.updateMetadata(this.expression); } diff --git a/src/slang-nodes/StringExpression.ts b/src/slang-nodes/StringExpression.ts index 7a1b06cbd..79c91ad65 100644 --- a/src/slang-nodes/StringExpression.ts +++ b/src/slang-nodes/StringExpression.ts @@ -8,9 +8,7 @@ import { HexStringLiteral } from './HexStringLiteral.js'; import { HexStringLiterals } from './HexStringLiterals.js'; import { UnicodeStringLiterals } from './UnicodeStringLiterals.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.StringExpression, @@ -33,14 +31,10 @@ export class StringExpression extends SlangNode { | HexStringLiterals | UnicodeStringLiterals; - constructor( - ast: ast.StringExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.StringExpression, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/StringLiteral.ts b/src/slang-nodes/StringLiteral.ts index fa24c4d5d..1f27a5b90 100644 --- a/src/slang-nodes/StringLiteral.ts +++ b/src/slang-nodes/StringLiteral.ts @@ -3,25 +3,20 @@ import { printString } from '../slang-printers/print-string.js'; import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class StringLiteral extends SlangNode { readonly kind = NonterminalKind.StringLiteral; variant: string; - constructor( - ast: ast.StringLiteral, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.StringLiteral, collected: CollectedMetadata) { super(ast, collected); this.variant = ast.variant.unparse(); - this.variant = printString(this.variant.slice(1, -1), options); + this.variant = printString(this.variant.slice(1, -1), collected.options); } print(): Doc { diff --git a/src/slang-nodes/StringLiterals.ts b/src/slang-nodes/StringLiterals.ts index 0f771306c..bf7a3ca8b 100644 --- a/src/slang-nodes/StringLiterals.ts +++ b/src/slang-nodes/StringLiterals.ts @@ -4,9 +4,8 @@ import { SlangNode } from './SlangNode.js'; import { StringLiteral } from './StringLiteral.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { join, hardline } = doc.builders; @@ -15,16 +14,10 @@ export class StringLiterals extends SlangNode { items: StringLiteral[]; - constructor( - ast: ast.StringLiterals, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.StringLiterals, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new StringLiteral(item, collected, options) - ); + this.items = ast.items.map((item) => new StringLiteral(item, collected)); } print(print: PrintFunction, path: AstPath): Doc { diff --git a/src/slang-nodes/StructDefinition.ts b/src/slang-nodes/StructDefinition.ts index 829d82010..be0e212e1 100644 --- a/src/slang-nodes/StructDefinition.ts +++ b/src/slang-nodes/StructDefinition.ts @@ -4,9 +4,8 @@ import { TerminalNode } from './TerminalNode.js'; import { StructMembers } from './StructMembers.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class StructDefinition extends SlangNode { readonly kind = NonterminalKind.StructDefinition; @@ -15,15 +14,11 @@ export class StructDefinition extends SlangNode { members: StructMembers; - constructor( - ast: ast.StructDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.StructDefinition, collected: CollectedMetadata) { super(ast, collected); this.name = new TerminalNode(ast.name, collected); - this.members = new StructMembers(ast.members, collected, options); + this.members = new StructMembers(ast.members, collected); this.updateMetadata(this.members); } diff --git a/src/slang-nodes/StructMember.ts b/src/slang-nodes/StructMember.ts index 6b9d4e868..7d2dce8be 100644 --- a/src/slang-nodes/StructMember.ts +++ b/src/slang-nodes/StructMember.ts @@ -5,9 +5,8 @@ import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class StructMember extends SlangNode { readonly kind = NonterminalKind.StructMember; @@ -16,16 +15,10 @@ export class StructMember extends SlangNode { name: TerminalNode; - constructor( - ast: ast.StructMember, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.StructMember, collected: CollectedMetadata) { super(ast, collected); - this.typeName = extractVariant( - new TypeName(ast.typeName, collected, options) - ); + this.typeName = extractVariant(new TypeName(ast.typeName, collected)); this.name = new TerminalNode(ast.name, collected); this.updateMetadata(this.typeName); diff --git a/src/slang-nodes/StructMembers.ts b/src/slang-nodes/StructMembers.ts index 4b810b4fd..b93e099a7 100644 --- a/src/slang-nodes/StructMembers.ts +++ b/src/slang-nodes/StructMembers.ts @@ -5,9 +5,8 @@ import { SlangNode } from './SlangNode.js'; import { StructMember } from './StructMember.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { hardline } = doc.builders; @@ -16,16 +15,10 @@ export class StructMembers extends SlangNode { items: StructMember[]; - constructor( - ast: ast.StructMembers, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.StructMembers, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new StructMember(item, collected, options) - ); + this.items = ast.items.map((item) => new StructMember(item, collected)); } print(print: PrintFunction, path: AstPath): Doc { diff --git a/src/slang-nodes/TryStatement.ts b/src/slang-nodes/TryStatement.ts index d9f642a0a..f8954712b 100644 --- a/src/slang-nodes/TryStatement.ts +++ b/src/slang-nodes/TryStatement.ts @@ -10,9 +10,8 @@ import { Block } from './Block.js'; import { CatchClauses } from './CatchClauses.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { line } = doc.builders; @@ -27,21 +26,15 @@ export class TryStatement extends SlangNode { catchClauses: CatchClauses; - constructor( - ast: ast.TryStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.TryStatement, collected: CollectedMetadata) { super(ast, collected); - this.expression = extractVariant( - new Expression(ast.expression, collected, options) - ); + this.expression = extractVariant(new Expression(ast.expression, collected)); if (ast.returns) { - this.returns = new ReturnsDeclaration(ast.returns, collected, options); + this.returns = new ReturnsDeclaration(ast.returns, collected); } - this.body = new Block(ast.body, collected, options); - this.catchClauses = new CatchClauses(ast.catchClauses, collected, options); + this.body = new Block(ast.body, collected); + this.catchClauses = new CatchClauses(ast.catchClauses, collected); this.updateMetadata( this.expression, diff --git a/src/slang-nodes/TupleDeconstructionElement.ts b/src/slang-nodes/TupleDeconstructionElement.ts index 243f0d552..3035f5921 100644 --- a/src/slang-nodes/TupleDeconstructionElement.ts +++ b/src/slang-nodes/TupleDeconstructionElement.ts @@ -4,9 +4,8 @@ import { SlangNode } from './SlangNode.js'; import { TupleMember } from './TupleMember.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class TupleDeconstructionElement extends SlangNode { readonly kind = NonterminalKind.TupleDeconstructionElement; @@ -15,15 +14,12 @@ export class TupleDeconstructionElement extends SlangNode { constructor( ast: ast.TupleDeconstructionElement, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); if (ast.member) { - this.member = extractVariant( - new TupleMember(ast.member, collected, options) - ); + this.member = extractVariant(new TupleMember(ast.member, collected)); } this.updateMetadata(this.member); diff --git a/src/slang-nodes/TupleDeconstructionElements.ts b/src/slang-nodes/TupleDeconstructionElements.ts index d7595238f..557eff9d1 100644 --- a/src/slang-nodes/TupleDeconstructionElements.ts +++ b/src/slang-nodes/TupleDeconstructionElements.ts @@ -4,9 +4,8 @@ import { SlangNode } from './SlangNode.js'; import { TupleDeconstructionElement } from './TupleDeconstructionElement.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class TupleDeconstructionElements extends SlangNode { readonly kind = NonterminalKind.TupleDeconstructionElements; @@ -15,13 +14,12 @@ export class TupleDeconstructionElements extends SlangNode { constructor( ast: ast.TupleDeconstructionElements, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected, true); this.items = ast.items.map( - (item) => new TupleDeconstructionElement(item, collected, options) + (item) => new TupleDeconstructionElement(item, collected) ); } diff --git a/src/slang-nodes/TupleDeconstructionStatement.ts b/src/slang-nodes/TupleDeconstructionStatement.ts index 1b2f79de7..c3eed3200 100644 --- a/src/slang-nodes/TupleDeconstructionStatement.ts +++ b/src/slang-nodes/TupleDeconstructionStatement.ts @@ -6,9 +6,8 @@ import { TupleDeconstructionElements } from './TupleDeconstructionElements.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class TupleDeconstructionStatement extends SlangNode { readonly kind = NonterminalKind.TupleDeconstructionStatement; @@ -21,20 +20,13 @@ export class TupleDeconstructionStatement extends SlangNode { constructor( ast: ast.TupleDeconstructionStatement, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); this.varKeyword = ast.varKeyword?.unparse(); - this.elements = new TupleDeconstructionElements( - ast.elements, - collected, - options - ); - this.expression = extractVariant( - new Expression(ast.expression, collected, options) - ); + this.elements = new TupleDeconstructionElements(ast.elements, collected); + this.expression = extractVariant(new Expression(ast.expression, collected)); this.updateMetadata(this.elements, this.expression); } diff --git a/src/slang-nodes/TupleExpression.ts b/src/slang-nodes/TupleExpression.ts index ef6675f8d..288032af1 100644 --- a/src/slang-nodes/TupleExpression.ts +++ b/src/slang-nodes/TupleExpression.ts @@ -3,23 +3,18 @@ import { SlangNode } from './SlangNode.js'; import { TupleValues } from './TupleValues.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class TupleExpression extends SlangNode { readonly kind = NonterminalKind.TupleExpression; items: TupleValues; - constructor( - ast: ast.TupleExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.TupleExpression, collected: CollectedMetadata) { super(ast, collected); - this.items = new TupleValues(ast.items, collected, options); + this.items = new TupleValues(ast.items, collected); this.updateMetadata(this.items); } diff --git a/src/slang-nodes/TupleMember.ts b/src/slang-nodes/TupleMember.ts index 04c005f3f..b4975d277 100644 --- a/src/slang-nodes/TupleMember.ts +++ b/src/slang-nodes/TupleMember.ts @@ -5,9 +5,7 @@ import { SlangNode } from './SlangNode.js'; import { TypedTupleMember } from './TypedTupleMember.js'; import { UntypedTupleMember } from './UntypedTupleMember.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.TupleMember, @@ -22,14 +20,10 @@ export class TupleMember extends SlangNode { variant: TypedTupleMember | UntypedTupleMember; - constructor( - ast: ast.TupleMember, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.TupleMember, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/TupleValue.ts b/src/slang-nodes/TupleValue.ts index d7c38fc9f..ecc7423e8 100644 --- a/src/slang-nodes/TupleValue.ts +++ b/src/slang-nodes/TupleValue.ts @@ -4,25 +4,20 @@ import { SlangNode } from './SlangNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class TupleValue extends SlangNode { readonly kind = NonterminalKind.TupleValue; expression?: Expression['variant']; - constructor( - ast: ast.TupleValue, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.TupleValue, collected: CollectedMetadata) { super(ast, collected); if (ast.expression) { this.expression = extractVariant( - new Expression(ast.expression, collected, options) + new Expression(ast.expression, collected) ); } diff --git a/src/slang-nodes/TupleValues.ts b/src/slang-nodes/TupleValues.ts index abedde979..fb69ac096 100644 --- a/src/slang-nodes/TupleValues.ts +++ b/src/slang-nodes/TupleValues.ts @@ -5,9 +5,8 @@ import { SlangNode } from './SlangNode.js'; import { TupleValue } from './TupleValue.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; import type { Expression } from './Expression.ts'; export class TupleValues extends SlangNode { @@ -15,16 +14,10 @@ export class TupleValues extends SlangNode { items: TupleValue[]; - constructor( - ast: ast.TupleValues, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.TupleValues, collected: CollectedMetadata) { super(ast, collected, true); - this.items = ast.items.map( - (item) => new TupleValue(item, collected, options) - ); + this.items = ast.items.map((item) => new TupleValue(item, collected)); } getSingleExpression(): Expression['variant'] | undefined { diff --git a/src/slang-nodes/TypeExpression.ts b/src/slang-nodes/TypeExpression.ts index fe680023c..94281b542 100644 --- a/src/slang-nodes/TypeExpression.ts +++ b/src/slang-nodes/TypeExpression.ts @@ -4,25 +4,18 @@ import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class TypeExpression extends SlangNode { readonly kind = NonterminalKind.TypeExpression; typeName: TypeName['variant']; - constructor( - ast: ast.TypeExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.TypeExpression, collected: CollectedMetadata) { super(ast, collected); - this.typeName = extractVariant( - new TypeName(ast.typeName, collected, options) - ); + this.typeName = extractVariant(new TypeName(ast.typeName, collected)); this.updateMetadata(this.typeName); } diff --git a/src/slang-nodes/TypeName.ts b/src/slang-nodes/TypeName.ts index 86a84c4c0..578e33cb2 100644 --- a/src/slang-nodes/TypeName.ts +++ b/src/slang-nodes/TypeName.ts @@ -8,9 +8,7 @@ import { MappingType } from './MappingType.js'; import { ElementaryType } from './ElementaryType.js'; import { IdentifierPath } from './IdentifierPath.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantCreator< ast.TypeName, @@ -35,14 +33,10 @@ export class TypeName extends SlangNode { | ElementaryType['variant'] | IdentifierPath; - constructor( - ast: ast.TypeName, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.TypeName, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/TypedTupleMember.ts b/src/slang-nodes/TypedTupleMember.ts index b004f120c..1089bd516 100644 --- a/src/slang-nodes/TypedTupleMember.ts +++ b/src/slang-nodes/TypedTupleMember.ts @@ -7,9 +7,8 @@ import { StorageLocation } from './StorageLocation.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class TypedTupleMember extends SlangNode { readonly kind = NonterminalKind.TypedTupleMember; @@ -20,16 +19,10 @@ export class TypedTupleMember extends SlangNode { name: TerminalNode; - constructor( - ast: ast.TypedTupleMember, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.TypedTupleMember, collected: CollectedMetadata) { super(ast, collected); - this.typeName = extractVariant( - new TypeName(ast.typeName, collected, options) - ); + this.typeName = extractVariant(new TypeName(ast.typeName, collected)); if (ast.storageLocation) { this.storageLocation = new StorageLocation( ast.storageLocation, diff --git a/src/slang-nodes/UncheckedBlock.ts b/src/slang-nodes/UncheckedBlock.ts index fdfd66d7b..f1eb55d43 100644 --- a/src/slang-nodes/UncheckedBlock.ts +++ b/src/slang-nodes/UncheckedBlock.ts @@ -3,23 +3,18 @@ import { SlangNode } from './SlangNode.js'; import { Block } from './Block.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class UncheckedBlock extends SlangNode { readonly kind = NonterminalKind.UncheckedBlock; block: Block; - constructor( - ast: ast.UncheckedBlock, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.UncheckedBlock, collected: CollectedMetadata) { super(ast, collected); - this.block = new Block(ast.block, collected, options); + this.block = new Block(ast.block, collected); this.updateMetadata(this.block); } diff --git a/src/slang-nodes/UnicodeStringLiteral.ts b/src/slang-nodes/UnicodeStringLiteral.ts index 5d2bed0b1..b325cde1c 100644 --- a/src/slang-nodes/UnicodeStringLiteral.ts +++ b/src/slang-nodes/UnicodeStringLiteral.ts @@ -3,25 +3,20 @@ import { printString } from '../slang-printers/print-string.js'; import { SlangNode } from './SlangNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class UnicodeStringLiteral extends SlangNode { readonly kind = NonterminalKind.UnicodeStringLiteral; variant: string; - constructor( - ast: ast.UnicodeStringLiteral, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.UnicodeStringLiteral, collected: CollectedMetadata) { super(ast, collected); this.variant = ast.variant.unparse(); - this.variant = `unicode${printString(this.variant.slice(8, -1), options)}`; + this.variant = `unicode${printString(this.variant.slice(8, -1), collected.options)}`; } print(): Doc { diff --git a/src/slang-nodes/UnicodeStringLiterals.ts b/src/slang-nodes/UnicodeStringLiterals.ts index f6a02c14a..e4b610b91 100644 --- a/src/slang-nodes/UnicodeStringLiterals.ts +++ b/src/slang-nodes/UnicodeStringLiterals.ts @@ -4,9 +4,8 @@ import { SlangNode } from './SlangNode.js'; import { UnicodeStringLiteral } from './UnicodeStringLiteral.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { join, hardline } = doc.builders; @@ -15,15 +14,11 @@ export class UnicodeStringLiterals extends SlangNode { items: UnicodeStringLiteral[]; - constructor( - ast: ast.UnicodeStringLiterals, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.UnicodeStringLiterals, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map( - (item) => new UnicodeStringLiteral(item, collected, options) + (item) => new UnicodeStringLiteral(item, collected) ); } diff --git a/src/slang-nodes/UnnamedFunctionAttribute.ts b/src/slang-nodes/UnnamedFunctionAttribute.ts index 4b10a71d7..00fd5bcf6 100644 --- a/src/slang-nodes/UnnamedFunctionAttribute.ts +++ b/src/slang-nodes/UnnamedFunctionAttribute.ts @@ -7,20 +7,14 @@ import { ModifierInvocation } from './ModifierInvocation.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class UnnamedFunctionAttribute extends SlangNode { readonly kind = NonterminalKind.UnnamedFunctionAttribute; variant: ModifierInvocation | TerminalNode; - constructor( - ast: ast.UnnamedFunctionAttribute, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.UnnamedFunctionAttribute, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -28,7 +22,7 @@ export class UnnamedFunctionAttribute extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = new ModifierInvocation(variant, collected, options); + this.variant = new ModifierInvocation(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/UnnamedFunctionAttributes.ts b/src/slang-nodes/UnnamedFunctionAttributes.ts index dd3f99a0d..e8ab90208 100644 --- a/src/slang-nodes/UnnamedFunctionAttributes.ts +++ b/src/slang-nodes/UnnamedFunctionAttributes.ts @@ -6,9 +6,8 @@ import { SlangNode } from './SlangNode.js'; import { UnnamedFunctionAttribute } from './UnnamedFunctionAttribute.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { line } = doc.builders; @@ -19,13 +18,12 @@ export class UnnamedFunctionAttributes extends SlangNode { constructor( ast: ast.UnnamedFunctionAttributes, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new UnnamedFunctionAttribute(item, collected, options)) + extractVariant(new UnnamedFunctionAttribute(item, collected)) ); this.items.sort(sortFunctionAttributes); diff --git a/src/slang-nodes/UnnamedFunctionDefinition.ts b/src/slang-nodes/UnnamedFunctionDefinition.ts index 047f81efb..60c145cff 100644 --- a/src/slang-nodes/UnnamedFunctionDefinition.ts +++ b/src/slang-nodes/UnnamedFunctionDefinition.ts @@ -7,9 +7,8 @@ import { UnnamedFunctionAttributes } from './UnnamedFunctionAttributes.js'; import { FunctionBody } from './FunctionBody.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class UnnamedFunctionDefinition extends SlangNode { readonly kind = NonterminalKind.UnnamedFunctionDefinition; @@ -22,22 +21,13 @@ export class UnnamedFunctionDefinition extends SlangNode { constructor( ast: ast.UnnamedFunctionDefinition, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); - this.parameters = new ParametersDeclaration( - ast.parameters, - collected, - options - ); - this.attributes = new UnnamedFunctionAttributes( - ast.attributes, - collected, - options - ); - this.body = extractVariant(new FunctionBody(ast.body, collected, options)); + this.parameters = new ParametersDeclaration(ast.parameters, collected); + this.attributes = new UnnamedFunctionAttributes(ast.attributes, collected); + this.body = extractVariant(new FunctionBody(ast.body, collected)); this.updateMetadata(this.parameters, this.attributes, this.body); diff --git a/src/slang-nodes/UsingDirective.ts b/src/slang-nodes/UsingDirective.ts index cce80662b..6e4831a6b 100644 --- a/src/slang-nodes/UsingDirective.ts +++ b/src/slang-nodes/UsingDirective.ts @@ -5,9 +5,8 @@ import { UsingClause } from './UsingClause.js'; import { UsingTarget } from './UsingTarget.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class UsingDirective extends SlangNode { readonly kind = NonterminalKind.UsingDirective; @@ -18,17 +17,11 @@ export class UsingDirective extends SlangNode { globalKeyword?: string; - constructor( - ast: ast.UsingDirective, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.UsingDirective, collected: CollectedMetadata) { super(ast, collected); this.clause = extractVariant(new UsingClause(ast.clause, collected)); - this.target = extractVariant( - new UsingTarget(ast.target, collected, options) - ); + this.target = extractVariant(new UsingTarget(ast.target, collected)); this.globalKeyword = ast.globalKeyword?.unparse(); this.updateMetadata(this.clause, this.target); diff --git a/src/slang-nodes/UsingTarget.ts b/src/slang-nodes/UsingTarget.ts index 87645a2f4..a00f0c8a8 100644 --- a/src/slang-nodes/UsingTarget.ts +++ b/src/slang-nodes/UsingTarget.ts @@ -8,20 +8,14 @@ import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class UsingTarget extends SlangNode { readonly kind = NonterminalKind.UsingTarget; variant: TypeName['variant'] | TerminalNode; - constructor( - ast: ast.UsingTarget, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.UsingTarget, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -29,7 +23,7 @@ export class UsingTarget extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = extractVariant(new TypeName(variant, collected, options)); + this.variant = extractVariant(new TypeName(variant, collected)); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/VariableDeclarationStatement.ts b/src/slang-nodes/VariableDeclarationStatement.ts index d47aad0a0..f9caa0f97 100644 --- a/src/slang-nodes/VariableDeclarationStatement.ts +++ b/src/slang-nodes/VariableDeclarationStatement.ts @@ -9,9 +9,8 @@ import { TerminalNode } from './TerminalNode.js'; import { VariableDeclarationValue } from './VariableDeclarationValue.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { indent, line } = doc.builders; @@ -28,13 +27,12 @@ export class VariableDeclarationStatement extends SlangNode { constructor( ast: ast.VariableDeclarationStatement, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); this.variableType = extractVariant( - new VariableDeclarationType(ast.variableType, collected, options) + new VariableDeclarationType(ast.variableType, collected) ); if (ast.storageLocation) { this.storageLocation = new StorageLocation( @@ -44,7 +42,7 @@ export class VariableDeclarationStatement extends SlangNode { } this.name = new TerminalNode(ast.name, collected); if (ast.value) { - this.value = new VariableDeclarationValue(ast.value, collected, options); + this.value = new VariableDeclarationValue(ast.value, collected); } this.updateMetadata(this.variableType, this.storageLocation, this.value); diff --git a/src/slang-nodes/VariableDeclarationType.ts b/src/slang-nodes/VariableDeclarationType.ts index f657d9355..635cc0dbb 100644 --- a/src/slang-nodes/VariableDeclarationType.ts +++ b/src/slang-nodes/VariableDeclarationType.ts @@ -8,20 +8,14 @@ import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class VariableDeclarationType extends SlangNode { readonly kind = NonterminalKind.VariableDeclarationType; variant: TypeName['variant'] | TerminalNode; - constructor( - ast: ast.VariableDeclarationType, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.VariableDeclarationType, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -29,7 +23,7 @@ export class VariableDeclarationType extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = extractVariant(new TypeName(variant, collected, options)); + this.variant = extractVariant(new TypeName(variant, collected)); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/VariableDeclarationValue.ts b/src/slang-nodes/VariableDeclarationValue.ts index 5611189fb..9c9b0dcfa 100644 --- a/src/slang-nodes/VariableDeclarationValue.ts +++ b/src/slang-nodes/VariableDeclarationValue.ts @@ -5,25 +5,18 @@ import { SlangNode } from './SlangNode.js'; import { Expression } from './Expression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class VariableDeclarationValue extends SlangNode { readonly kind = NonterminalKind.VariableDeclarationValue; expression: Expression['variant']; - constructor( - ast: ast.VariableDeclarationValue, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.VariableDeclarationValue, collected: CollectedMetadata) { super(ast, collected); - this.expression = extractVariant( - new Expression(ast.expression, collected, options) - ); + this.expression = extractVariant(new Expression(ast.expression, collected)); this.updateMetadata(this.expression); } diff --git a/src/slang-nodes/WhileStatement.ts b/src/slang-nodes/WhileStatement.ts index 5c4bd8709..96e2af079 100644 --- a/src/slang-nodes/WhileStatement.ts +++ b/src/slang-nodes/WhileStatement.ts @@ -7,9 +7,8 @@ import { Expression } from './Expression.js'; import { Statement } from './Statement.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class WhileStatement extends SlangNode { readonly kind = NonterminalKind.WhileStatement; @@ -18,17 +17,11 @@ export class WhileStatement extends SlangNode { body: Statement['variant']; - constructor( - ast: ast.WhileStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.WhileStatement, collected: CollectedMetadata) { super(ast, collected); - this.condition = extractVariant( - new Expression(ast.condition, collected, options) - ); - this.body = extractVariant(new Statement(ast.body, collected, options)); + this.condition = extractVariant(new Expression(ast.condition, collected)); + this.body = extractVariant(new Statement(ast.body, collected)); this.updateMetadata(this.condition, this.body); } diff --git a/src/slang-nodes/YulArguments.ts b/src/slang-nodes/YulArguments.ts index 9e19082eb..f15c1cfe1 100644 --- a/src/slang-nodes/YulArguments.ts +++ b/src/slang-nodes/YulArguments.ts @@ -5,24 +5,19 @@ import { SlangNode } from './SlangNode.js'; import { YulExpression } from './YulExpression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class YulArguments extends SlangNode { readonly kind = NonterminalKind.YulArguments; items: YulExpression['variant'][]; - constructor( - ast: ast.YulArguments, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulArguments, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new YulExpression(item, collected, options)) + extractVariant(new YulExpression(item, collected)) ); } diff --git a/src/slang-nodes/YulBlock.ts b/src/slang-nodes/YulBlock.ts index b7de9f754..05fcf7014 100644 --- a/src/slang-nodes/YulBlock.ts +++ b/src/slang-nodes/YulBlock.ts @@ -3,23 +3,18 @@ import { SlangNode } from './SlangNode.js'; import { YulStatements } from './YulStatements.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class YulBlock extends SlangNode { readonly kind = NonterminalKind.YulBlock; statements: YulStatements; - constructor( - ast: ast.YulBlock, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulBlock, collected: CollectedMetadata) { super(ast, collected); - this.statements = new YulStatements(ast.statements, collected, options); + this.statements = new YulStatements(ast.statements, collected); this.updateMetadata(this.statements); } diff --git a/src/slang-nodes/YulDefaultCase.ts b/src/slang-nodes/YulDefaultCase.ts index 72311ff26..a0b02c3c0 100644 --- a/src/slang-nodes/YulDefaultCase.ts +++ b/src/slang-nodes/YulDefaultCase.ts @@ -3,23 +3,18 @@ import { SlangNode } from './SlangNode.js'; import { YulBlock } from './YulBlock.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class YulDefaultCase extends SlangNode { readonly kind = NonterminalKind.YulDefaultCase; body: YulBlock; - constructor( - ast: ast.YulDefaultCase, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulDefaultCase, collected: CollectedMetadata) { super(ast, collected); - this.body = new YulBlock(ast.body, collected, options); + this.body = new YulBlock(ast.body, collected); this.updateMetadata(this.body); } diff --git a/src/slang-nodes/YulExpression.ts b/src/slang-nodes/YulExpression.ts index 08e8ffce3..b0d1e06ce 100644 --- a/src/slang-nodes/YulExpression.ts +++ b/src/slang-nodes/YulExpression.ts @@ -6,9 +6,7 @@ import { YulFunctionCallExpression } from './YulFunctionCallExpression.js'; import { YulLiteral } from './YulLiteral.js'; import { YulPath } from './YulPath.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantCreator< ast.YulExpression, @@ -26,14 +24,10 @@ export class YulExpression extends SlangNode { variant: YulFunctionCallExpression | YulLiteral['variant'] | YulPath; - constructor( - ast: ast.YulExpression, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulExpression, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/YulForStatement.ts b/src/slang-nodes/YulForStatement.ts index 5232f88e7..340a1324a 100644 --- a/src/slang-nodes/YulForStatement.ts +++ b/src/slang-nodes/YulForStatement.ts @@ -6,9 +6,8 @@ import { YulBlock } from './YulBlock.js'; import { YulExpression } from './YulExpression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { join } = doc.builders; @@ -23,19 +22,15 @@ export class YulForStatement extends SlangNode { body: YulBlock; - constructor( - ast: ast.YulForStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulForStatement, collected: CollectedMetadata) { super(ast, collected); - this.initialization = new YulBlock(ast.initialization, collected, options); + this.initialization = new YulBlock(ast.initialization, collected); this.condition = extractVariant( - new YulExpression(ast.condition, collected, options) + new YulExpression(ast.condition, collected) ); - this.iterator = new YulBlock(ast.iterator, collected, options); - this.body = new YulBlock(ast.body, collected, options); + this.iterator = new YulBlock(ast.iterator, collected); + this.body = new YulBlock(ast.body, collected); this.updateMetadata( this.initialization, diff --git a/src/slang-nodes/YulFunctionCallExpression.ts b/src/slang-nodes/YulFunctionCallExpression.ts index 77c3d7829..cf8c22c6d 100644 --- a/src/slang-nodes/YulFunctionCallExpression.ts +++ b/src/slang-nodes/YulFunctionCallExpression.ts @@ -5,9 +5,8 @@ import { YulExpression } from './YulExpression.js'; import { YulArguments } from './YulArguments.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class YulFunctionCallExpression extends SlangNode { readonly kind = NonterminalKind.YulFunctionCallExpression; @@ -18,15 +17,12 @@ export class YulFunctionCallExpression extends SlangNode { constructor( ast: ast.YulFunctionCallExpression, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); - this.operand = extractVariant( - new YulExpression(ast.operand, collected, options) - ); - this.arguments = new YulArguments(ast.arguments, collected, options); + this.operand = extractVariant(new YulExpression(ast.operand, collected)); + this.arguments = new YulArguments(ast.arguments, collected); this.updateMetadata(this.operand, this.arguments); } diff --git a/src/slang-nodes/YulFunctionDefinition.ts b/src/slang-nodes/YulFunctionDefinition.ts index 17378284f..ba0cc7831 100644 --- a/src/slang-nodes/YulFunctionDefinition.ts +++ b/src/slang-nodes/YulFunctionDefinition.ts @@ -6,9 +6,8 @@ import { YulReturnsDeclaration } from './YulReturnsDeclaration.js'; import { YulBlock } from './YulBlock.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class YulFunctionDefinition extends SlangNode { readonly kind = NonterminalKind.YulFunctionDefinition; @@ -21,11 +20,7 @@ export class YulFunctionDefinition extends SlangNode { body: YulBlock; - constructor( - ast: ast.YulFunctionDefinition, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulFunctionDefinition, collected: CollectedMetadata) { super(ast, collected); this.name = new TerminalNode(ast.name, collected); @@ -33,7 +28,7 @@ export class YulFunctionDefinition extends SlangNode { if (ast.returns) { this.returns = new YulReturnsDeclaration(ast.returns, collected); } - this.body = new YulBlock(ast.body, collected, options); + this.body = new YulBlock(ast.body, collected); this.updateMetadata(this.parameters, this.returns, this.body); } diff --git a/src/slang-nodes/YulIfStatement.ts b/src/slang-nodes/YulIfStatement.ts index 94ed7863e..cf2f2355c 100644 --- a/src/slang-nodes/YulIfStatement.ts +++ b/src/slang-nodes/YulIfStatement.ts @@ -5,9 +5,8 @@ import { YulExpression } from './YulExpression.js'; import { YulBlock } from './YulBlock.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class YulIfStatement extends SlangNode { readonly kind = NonterminalKind.YulIfStatement; @@ -16,17 +15,13 @@ export class YulIfStatement extends SlangNode { body: YulBlock; - constructor( - ast: ast.YulIfStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulIfStatement, collected: CollectedMetadata) { super(ast, collected); this.condition = extractVariant( - new YulExpression(ast.condition, collected, options) + new YulExpression(ast.condition, collected) ); - this.body = new YulBlock(ast.body, collected, options); + this.body = new YulBlock(ast.body, collected); this.updateMetadata(this.condition, this.body); } diff --git a/src/slang-nodes/YulLiteral.ts b/src/slang-nodes/YulLiteral.ts index 2da19aabc..5ae4ab010 100644 --- a/src/slang-nodes/YulLiteral.ts +++ b/src/slang-nodes/YulLiteral.ts @@ -9,9 +9,7 @@ import { HexStringLiteral } from './HexStringLiteral.js'; import { StringLiteral } from './StringLiteral.js'; import { TerminalNode } from './TerminalNode.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.YulLiteral, @@ -26,11 +24,7 @@ export class YulLiteral extends SlangNode { variant: HexStringLiteral | StringLiteral | TerminalNode; - constructor( - ast: ast.YulLiteral, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulLiteral, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; @@ -38,7 +32,7 @@ export class YulLiteral extends SlangNode { this.variant = new TerminalNode(variant, collected); return; } - this.variant = createNonterminalVariant(variant, collected, options); + this.variant = createNonterminalVariant(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/YulStatement.ts b/src/slang-nodes/YulStatement.ts index c6906b1d8..925888699 100644 --- a/src/slang-nodes/YulStatement.ts +++ b/src/slang-nodes/YulStatement.ts @@ -16,9 +16,7 @@ import { YulContinueStatement } from './YulContinueStatement.js'; import { YulLabel } from './YulLabel.js'; import { YulExpression } from './YulExpression.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantCreator< slangAst.YulStatement, @@ -58,18 +56,14 @@ export class YulStatement extends SlangNode { | YulLabel | YulExpression['variant']; - constructor( - ast: slangAst.YulStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: slangAst.YulStatement, collected: CollectedMetadata) { super(ast, collected); const variant = ast.variant; this.variant = variant instanceof slangAst.YulBlock - ? new YulBlock(variant, collected, options) - : createNonterminalVariant(variant, collected, options); + ? new YulBlock(variant, collected) + : createNonterminalVariant(variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/YulStatements.ts b/src/slang-nodes/YulStatements.ts index fdb0324ce..66e133e6b 100644 --- a/src/slang-nodes/YulStatements.ts +++ b/src/slang-nodes/YulStatements.ts @@ -18,15 +18,11 @@ export class YulStatements extends SlangNode { items: YulStatement['variant'][]; - constructor( - ast: ast.YulStatements, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulStatements, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new YulStatement(item, collected, options)) + extractVariant(new YulStatement(item, collected)) ); } diff --git a/src/slang-nodes/YulSwitchCase.ts b/src/slang-nodes/YulSwitchCase.ts index c6aa5b5fa..66958efb4 100644 --- a/src/slang-nodes/YulSwitchCase.ts +++ b/src/slang-nodes/YulSwitchCase.ts @@ -5,9 +5,7 @@ import { SlangNode } from './SlangNode.js'; import { YulDefaultCase } from './YulDefaultCase.js'; import { YulValueCase } from './YulValueCase.js'; -import type { ParserOptions } from 'prettier'; import type { CollectedMetadata } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const createNonterminalVariant = createNonterminalVariantSimpleCreator< ast.YulSwitchCase, @@ -22,14 +20,10 @@ export class YulSwitchCase extends SlangNode { variant: YulDefaultCase | YulValueCase; - constructor( - ast: ast.YulSwitchCase, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulSwitchCase, collected: CollectedMetadata) { super(ast, collected); - this.variant = createNonterminalVariant(ast.variant, collected, options); + this.variant = createNonterminalVariant(ast.variant, collected); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/YulSwitchCases.ts b/src/slang-nodes/YulSwitchCases.ts index 8e4d60750..26b64c1f3 100644 --- a/src/slang-nodes/YulSwitchCases.ts +++ b/src/slang-nodes/YulSwitchCases.ts @@ -5,9 +5,8 @@ import { SlangNode } from './SlangNode.js'; import { YulSwitchCase } from './YulSwitchCase.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc, ParserOptions } from 'prettier'; +import type { AstPath, Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { hardline, join } = doc.builders; @@ -16,15 +15,11 @@ export class YulSwitchCases extends SlangNode { items: YulSwitchCase['variant'][]; - constructor( - ast: ast.YulSwitchCases, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulSwitchCases, collected: CollectedMetadata) { super(ast, collected, true); this.items = ast.items.map((item) => - extractVariant(new YulSwitchCase(item, collected, options)) + extractVariant(new YulSwitchCase(item, collected)) ); } diff --git a/src/slang-nodes/YulSwitchStatement.ts b/src/slang-nodes/YulSwitchStatement.ts index 3af7ac381..fa4914415 100644 --- a/src/slang-nodes/YulSwitchStatement.ts +++ b/src/slang-nodes/YulSwitchStatement.ts @@ -6,9 +6,8 @@ import { YulExpression } from './YulExpression.js'; import { YulSwitchCases } from './YulSwitchCases.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { hardline } = doc.builders; @@ -19,17 +18,13 @@ export class YulSwitchStatement extends SlangNode { cases: YulSwitchCases; - constructor( - ast: ast.YulSwitchStatement, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulSwitchStatement, collected: CollectedMetadata) { super(ast, collected); this.expression = extractVariant( - new YulExpression(ast.expression, collected, options) + new YulExpression(ast.expression, collected) ); - this.cases = new YulSwitchCases(ast.cases, collected, options); + this.cases = new YulSwitchCases(ast.cases, collected); this.updateMetadata(this.expression, this.cases); } diff --git a/src/slang-nodes/YulValueCase.ts b/src/slang-nodes/YulValueCase.ts index 0fa978503..687c137ed 100644 --- a/src/slang-nodes/YulValueCase.ts +++ b/src/slang-nodes/YulValueCase.ts @@ -5,9 +5,8 @@ import { YulLiteral } from './YulLiteral.js'; import { YulBlock } from './YulBlock.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class YulValueCase extends SlangNode { readonly kind = NonterminalKind.YulValueCase; @@ -16,15 +15,11 @@ export class YulValueCase extends SlangNode { body: YulBlock; - constructor( - ast: ast.YulValueCase, - collected: CollectedMetadata, - options: ParserOptions - ) { + constructor(ast: ast.YulValueCase, collected: CollectedMetadata) { super(ast, collected); - this.value = extractVariant(new YulLiteral(ast.value, collected, options)); - this.body = new YulBlock(ast.body, collected, options); + this.value = extractVariant(new YulLiteral(ast.value, collected)); + this.body = new YulBlock(ast.body, collected); this.updateMetadata(this.value, this.body); } diff --git a/src/slang-nodes/YulVariableAssignmentStatement.ts b/src/slang-nodes/YulVariableAssignmentStatement.ts index ebee7c2b5..e73d39fa0 100644 --- a/src/slang-nodes/YulVariableAssignmentStatement.ts +++ b/src/slang-nodes/YulVariableAssignmentStatement.ts @@ -7,9 +7,8 @@ import { YulAssignmentOperator } from './YulAssignmentOperator.js'; import { YulExpression } from './YulExpression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; const { join } = doc.builders; @@ -24,8 +23,7 @@ export class YulVariableAssignmentStatement extends SlangNode { constructor( ast: ast.YulVariableAssignmentStatement, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); @@ -34,7 +32,7 @@ export class YulVariableAssignmentStatement extends SlangNode { new YulAssignmentOperator(ast.assignment, collected) ); this.expression = extractVariant( - new YulExpression(ast.expression, collected, options) + new YulExpression(ast.expression, collected) ); this.updateMetadata(this.variables, this.assignment, this.expression); diff --git a/src/slang-nodes/YulVariableDeclarationStatement.ts b/src/slang-nodes/YulVariableDeclarationStatement.ts index 3b30265e8..a2ef21a02 100644 --- a/src/slang-nodes/YulVariableDeclarationStatement.ts +++ b/src/slang-nodes/YulVariableDeclarationStatement.ts @@ -5,9 +5,8 @@ import { YulVariableDeclarationValue } from './YulVariableDeclarationValue.js'; import { YulVariableNames } from './YulVariableNames.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class YulVariableDeclarationStatement extends SlangNode { readonly kind = NonterminalKind.YulVariableDeclarationStatement; @@ -18,18 +17,13 @@ export class YulVariableDeclarationStatement extends SlangNode { constructor( ast: ast.YulVariableDeclarationStatement, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); this.variables = new YulVariableNames(ast.variables, collected); if (ast.value) { - this.value = new YulVariableDeclarationValue( - ast.value, - collected, - options - ); + this.value = new YulVariableDeclarationValue(ast.value, collected); } this.updateMetadata(this.value); diff --git a/src/slang-nodes/YulVariableDeclarationValue.ts b/src/slang-nodes/YulVariableDeclarationValue.ts index 67b637580..aa401f342 100644 --- a/src/slang-nodes/YulVariableDeclarationValue.ts +++ b/src/slang-nodes/YulVariableDeclarationValue.ts @@ -5,9 +5,8 @@ import { YulAssignmentOperator } from './YulAssignmentOperator.js'; import { YulExpression } from './YulExpression.js'; import type * as ast from '@nomicfoundation/slang/ast'; -import type { Doc, ParserOptions } from 'prettier'; +import type { Doc } from 'prettier'; import type { CollectedMetadata, PrintFunction } from '../types.d.ts'; -import type { PrintableNode } from './types.d.ts'; export class YulVariableDeclarationValue extends SlangNode { readonly kind = NonterminalKind.YulVariableDeclarationValue; @@ -18,8 +17,7 @@ export class YulVariableDeclarationValue extends SlangNode { constructor( ast: ast.YulVariableDeclarationValue, - collected: CollectedMetadata, - options: ParserOptions + collected: CollectedMetadata ) { super(ast, collected); @@ -27,7 +25,7 @@ export class YulVariableDeclarationValue extends SlangNode { new YulAssignmentOperator(ast.assignment, collected) ); this.expression = extractVariant( - new YulExpression(ast.expression, collected, options) + new YulExpression(ast.expression, collected) ); this.updateMetadata(this.assignment, this.expression); diff --git a/src/slang-utils/create-nonterminal-variant-creator.ts b/src/slang-utils/create-nonterminal-variant-creator.ts index d463b3369..94dbc9bed 100644 --- a/src/slang-utils/create-nonterminal-variant-creator.ts +++ b/src/slang-utils/create-nonterminal-variant-creator.ts @@ -12,7 +12,7 @@ import type { SlangAstNodeClass } from '../types.d.ts'; -type Constructor = new (...args: any) => T; +type Constructor = new (ast: any, collected: CollectedMetadata) => T; type ConstructorsFromInstances = U extends any ? Constructor : never; type SlangPolymorphicNode = Extract; @@ -31,10 +31,10 @@ export function createNonterminalVariantSimpleCreator< >( constructors: [SlangAstNodeClass, ConstructorsFromInstances][] ): NonterminalVariantFactory { - return (variant, collected, options?) => { + return (variant, collected) => { for (const [slangAstClass, constructor] of constructors) { if (variant instanceof slangAstClass) - return new constructor(variant, collected, options); + return new constructor(variant, collected); } throw new Error(`Unexpected variant: ${JSON.stringify(variant)}`); @@ -55,12 +55,12 @@ export function createNonterminalVariantCreator< constructors ); - return (variant, collected, options?) => { + return (variant, collected) => { for (const [slangAstClass, constructor] of extractVariantConstructors) { if (variant instanceof slangAstClass) - return extractVariant(new constructor(variant, collected, options)); + return extractVariant(new constructor(variant, collected)); } - return simpleCreator(variant, collected, options); + return simpleCreator(variant, collected); }; } diff --git a/src/slangSolidityParser.ts b/src/slangSolidityParser.ts index 47f5bd043..e15bcc2aa 100644 --- a/src/slangSolidityParser.ts +++ b/src/slangSolidityParser.ts @@ -17,8 +17,7 @@ export default function parse( const comments: Comment[] = []; const parsed = new SourceUnit( new SlangSourceUnit(parseOutput.tree.asNonterminalNode()), - { offsets: new Map(), comments }, - options + { offsets: new Map(), comments, options } ); // Because of comments being extracted like a Russian doll, the order needs diff --git a/src/types.d.ts b/src/types.d.ts index c57ae0502..98e42df9f 100644 --- a/src/types.d.ts +++ b/src/types.d.ts @@ -1,5 +1,5 @@ import type * as ast from '@nomicfoundation/slang/ast'; -import type { AstPath, Doc } from 'prettier'; +import type { AstPath, Doc, ParserOptions } from 'prettier'; import type { Comment, PrintableNode } from './slang-nodes/types.d.ts'; // Adding our own options to prettier's `ParserOptions` interface. @@ -12,6 +12,7 @@ declare module 'prettier' { interface CollectedMetadata { offsets: Map; comments: Comment[]; + options: ParserOptions; } interface Location { From 2f4f32897370459a34370afaa08fcea7de31d329 Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 22 Apr 2026 16:43:59 -0400 Subject: [PATCH 2/4] stricter type for constructors --- src/slang-utils/create-nonterminal-variant-creator.ts | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/slang-utils/create-nonterminal-variant-creator.ts b/src/slang-utils/create-nonterminal-variant-creator.ts index 94dbc9bed..03cc7491a 100644 --- a/src/slang-utils/create-nonterminal-variant-creator.ts +++ b/src/slang-utils/create-nonterminal-variant-creator.ts @@ -12,8 +12,7 @@ import type { SlangAstNodeClass } from '../types.d.ts'; -type Constructor = new (ast: any, collected: CollectedMetadata) => T; -type ConstructorsFromInstances = U extends any ? Constructor : never; +type NodeConstructor = new (ast: any, collected: CollectedMetadata) => T; type SlangPolymorphicNode = Extract; type NonterminalVariantFactory< @@ -29,7 +28,7 @@ export function createNonterminalVariantSimpleCreator< U extends SlangPolymorphicNode, T extends StrictPolymorphicNode >( - constructors: [SlangAstNodeClass, ConstructorsFromInstances][] + constructors: [SlangAstNodeClass, NodeConstructor][] ): NonterminalVariantFactory { return (variant, collected) => { for (const [slangAstClass, constructor] of constructors) { @@ -45,10 +44,10 @@ export function createNonterminalVariantCreator< U extends SlangPolymorphicNode, T extends StrictPolymorphicNode >( - constructors: [SlangAstNodeClass, ConstructorsFromInstances][], + constructors: [SlangAstNodeClass, NodeConstructor][], extractVariantConstructors: [ SlangAstNodeClass, - ConstructorsFromInstances + NodeConstructor ][] ): NonterminalVariantFactory { const simpleCreator = createNonterminalVariantSimpleCreator( From fe0d49ebe51d4ee59bb1ad7e74f4d93a7bd214c3 Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 22 Apr 2026 18:31:14 -0400 Subject: [PATCH 3/4] removing options declaration in type --- .../create-nonterminal-variant-creator.ts | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/src/slang-utils/create-nonterminal-variant-creator.ts b/src/slang-utils/create-nonterminal-variant-creator.ts index 03cc7491a..9dd7b0c82 100644 --- a/src/slang-utils/create-nonterminal-variant-creator.ts +++ b/src/slang-utils/create-nonterminal-variant-creator.ts @@ -1,11 +1,7 @@ /* eslint-disable @typescript-eslint/no-explicit-any */ import { extractVariant } from './extract-variant.js'; -import type { ParserOptions } from 'prettier'; -import type { - PrintableNode, - StrictPolymorphicNode -} from '../slang-nodes/types.d.ts'; +import type { StrictPolymorphicNode } from '../slang-nodes/types.d.ts'; import type { CollectedMetadata, SlangAstNode, @@ -18,11 +14,7 @@ type SlangPolymorphicNode = Extract; type NonterminalVariantFactory< U extends SlangPolymorphicNode, T extends StrictPolymorphicNode -> = ( - variant: U['variant'], - collected: CollectedMetadata, - options?: ParserOptions -) => T['variant']; +> = (variant: U['variant'], collected: CollectedMetadata) => T['variant']; export function createNonterminalVariantSimpleCreator< U extends SlangPolymorphicNode, From 60aeff1db5080f7ad3ed3654171026bbef3426ad Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 22 Apr 2026 18:32:27 -0400 Subject: [PATCH 4/4] fix extension --- src/slang-utils/has-prettier-ignore.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/slang-utils/has-prettier-ignore.ts b/src/slang-utils/has-prettier-ignore.ts index 3033c4130..aa49c3064 100644 --- a/src/slang-utils/has-prettier-ignore.ts +++ b/src/slang-utils/has-prettier-ignore.ts @@ -1,7 +1,7 @@ import { isBlockComment, isComment } from './is-comment.js'; import type { AstPath } from 'prettier'; -import type { PrintableNode } from '../slang-nodes/types.js'; +import type { PrintableNode } from '../slang-nodes/types.d.ts'; export function hasPrettierIgnore({ node