From 3092584488a025008869088a050dab898a7c4f5d Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 17 Sep 2025 00:56:42 +0300 Subject: [PATCH 1/9] removing `ForStatementInitialization` and `ForStatementCondition` from the AST tree --- src/slang-nodes/ForStatement.ts | 18 +++++++++--------- src/slang-nodes/ForStatementCondition.ts | 4 ++-- src/slang-nodes/ForStatementInitialization.ts | 4 ++-- src/slang-printers/print-binary-operation.ts | 2 +- src/slangPrinter.ts | 4 ++++ 5 files changed, 18 insertions(+), 14 deletions(-) diff --git a/src/slang-nodes/ForStatement.ts b/src/slang-nodes/ForStatement.ts index e68565be8..4dc772089 100644 --- a/src/slang-nodes/ForStatement.ts +++ b/src/slang-nodes/ForStatement.ts @@ -2,7 +2,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; import { printSeparatedList } from '../slang-printers/print-separated-list.js'; import { printIndentedGroupOrSpacedDocument } from '../slang-printers/print-indented-group-or-spaced-document.js'; -import { printVariant } from '../slang-printers/print-variant.js'; import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { ForStatementInitialization } from './ForStatementInitialization.js'; @@ -20,9 +19,9 @@ const { line } = doc.builders; export class ForStatement extends SlangNode { readonly kind = NonterminalKind.ForStatement; - initialization: ForStatementInitialization; + initialization: ForStatementInitialization['variant']; - condition: ForStatementCondition; + condition: ForStatementCondition['variant']; iterator?: Expression['variant']; @@ -31,11 +30,12 @@ export class ForStatement extends SlangNode { constructor(ast: ast.ForStatement, options: ParserOptions) { super(ast); - this.initialization = new ForStatementInitialization( - ast.initialization, - options + this.initialization = extractVariant( + new ForStatementInitialization(ast.initialization, options) + ); + this.condition = extractVariant( + new ForStatementCondition(ast.condition, options) ); - this.condition = new ForStatementCondition(ast.condition, options); if (ast.iterator) { this.iterator = extractVariant(new Expression(ast.iterator, options)); } @@ -50,8 +50,8 @@ export class ForStatement extends SlangNode { } print(path: AstPath, print: PrintFunction): Doc { - const initialization = path.call(printVariant(print), 'initialization'); - const condition = path.call(printVariant(print), 'condition'); + const initialization = path.call(print, 'initialization'); + const condition = path.call(print, 'condition'); const iterator = path.call(print, 'iterator'); return [ diff --git a/src/slang-nodes/ForStatementCondition.ts b/src/slang-nodes/ForStatementCondition.ts index 852a57bfc..0c75d9c94 100644 --- a/src/slang-nodes/ForStatementCondition.ts +++ b/src/slang-nodes/ForStatementCondition.ts @@ -2,7 +2,7 @@ import { NonterminalKind, TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { ExpressionStatement } from './ExpressionStatement.js'; import { TerminalNode } from './TerminalNode.js'; @@ -10,7 +10,7 @@ import type * as ast from '@nomicfoundation/slang/ast'; import type { ParserOptions } from 'prettier'; import type { AstNode } from './types.d.ts'; -export class ForStatementCondition extends PolymorphicNode { +export class ForStatementCondition extends SlangNode { readonly kind = NonterminalKind.ForStatementCondition; variant: ExpressionStatement | TerminalNode; diff --git a/src/slang-nodes/ForStatementInitialization.ts b/src/slang-nodes/ForStatementInitialization.ts index a1f88c986..a26489a0f 100644 --- a/src/slang-nodes/ForStatementInitialization.ts +++ b/src/slang-nodes/ForStatementInitialization.ts @@ -3,7 +3,7 @@ import { NonterminalKind, TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { ExpressionStatement } from './ExpressionStatement.js'; import { VariableDeclarationStatement } from './VariableDeclarationStatement.js'; import { TupleDeconstructionStatement } from './TupleDeconstructionStatement.js'; @@ -32,7 +32,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class ForStatementInitialization extends PolymorphicNode { +export class ForStatementInitialization extends SlangNode { readonly kind = NonterminalKind.ForStatementInitialization; variant: diff --git a/src/slang-printers/print-binary-operation.ts b/src/slang-printers/print-binary-operation.ts index 21361ea4a..b0feabe9b 100644 --- a/src/slang-printers/print-binary-operation.ts +++ b/src/slang-printers/print-binary-operation.ts @@ -38,7 +38,7 @@ export const shouldNotIndent = ( isStatementWithoutIndentedOperation(node) || (node.kind === NonterminalKind.ExpressionStatement && (path.getNode(index + 1) as StrictAstNode).kind === - NonterminalKind.ForStatementCondition); + NonterminalKind.ForStatement); export const binaryIndentRulesBuilder = (shouldIndent: (node: BinaryOperation) => boolean) => diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts index 4e4ab9ff5..17c6a0561 100644 --- a/src/slangPrinter.ts +++ b/src/slangPrinter.ts @@ -21,6 +21,8 @@ import type { ContractSpecifier } from './slang-nodes/ContractSpecifier.js'; import type { ElementaryType } from './slang-nodes/ElementaryType.js'; import type { ExperimentalFeature } from './slang-nodes/ExperimentalFeature.js'; import type { Expression } from './slang-nodes/Expression.js'; +import type { ForStatementInitialization } from './slang-nodes/ForStatementInitialization.js'; +import type { ForStatementCondition } from './slang-nodes/ForStatementCondition.js'; function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean { // Prettier sets SourceUnit's comments to undefined after assigning comments @@ -90,6 +92,8 @@ function genericPrint( | ElementaryType | ExperimentalFeature | Expression + | ForStatementInitialization + | ForStatementCondition > >, options: ParserOptions, From 7bf1a646a5ce5ed22d9d892b04cc371e39fb655b Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 17 Sep 2025 01:08:09 +0300 Subject: [PATCH 2/9] removing `FunctionBody` from the AST tree --- src/slang-nodes/FallbackFunctionDefinition.ts | 5 +++-- src/slang-nodes/FunctionBody.ts | 4 ++-- src/slang-nodes/FunctionDefinition.ts | 5 +++-- src/slang-nodes/ModifierDefinition.ts | 5 +++-- src/slang-nodes/ReceiveFunctionDefinition.ts | 5 +++-- src/slang-nodes/UnnamedFunctionDefinition.ts | 5 +++-- src/slang-printers/print-function.ts | 22 +++++-------------- src/slangPrinter.ts | 2 ++ 8 files changed, 25 insertions(+), 28 deletions(-) diff --git a/src/slang-nodes/FallbackFunctionDefinition.ts b/src/slang-nodes/FallbackFunctionDefinition.ts index 31d067bcd..500171d27 100644 --- a/src/slang-nodes/FallbackFunctionDefinition.ts +++ b/src/slang-nodes/FallbackFunctionDefinition.ts @@ -1,5 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printFunctionWithBody } from '../slang-printers/print-function.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { ParametersDeclaration } from './ParametersDeclaration.js'; import { FallbackFunctionAttributes } from './FallbackFunctionAttributes.js'; @@ -20,7 +21,7 @@ export class FallbackFunctionDefinition extends SlangNode { returns?: ReturnsDeclaration; - body: FunctionBody; + body: FunctionBody['variant']; constructor( ast: ast.FallbackFunctionDefinition, @@ -33,7 +34,7 @@ export class FallbackFunctionDefinition extends SlangNode { if (ast.returns) { this.returns = new ReturnsDeclaration(ast.returns, options); } - this.body = new FunctionBody(ast.body, options); + this.body = extractVariant(new FunctionBody(ast.body, options)); this.updateMetadata( this.parameters, diff --git a/src/slang-nodes/FunctionBody.ts b/src/slang-nodes/FunctionBody.ts index 7a297fdcc..364a0923f 100644 --- a/src/slang-nodes/FunctionBody.ts +++ b/src/slang-nodes/FunctionBody.ts @@ -2,7 +2,7 @@ import { NonterminalKind, TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { Block } from './Block.js'; import { TerminalNode } from './TerminalNode.js'; @@ -10,7 +10,7 @@ import type * as ast from '@nomicfoundation/slang/ast'; import type { ParserOptions } from 'prettier'; import type { AstNode } from './types.d.ts'; -export class FunctionBody extends PolymorphicNode { +export class FunctionBody extends SlangNode { readonly kind = NonterminalKind.FunctionBody; variant: Block | TerminalNode; diff --git a/src/slang-nodes/FunctionDefinition.ts b/src/slang-nodes/FunctionDefinition.ts index 32df3faf1..9cefa6361 100644 --- a/src/slang-nodes/FunctionDefinition.ts +++ b/src/slang-nodes/FunctionDefinition.ts @@ -2,6 +2,7 @@ import { satisfies } from 'semver'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printFunctionWithBody } from '../slang-printers/print-function.js'; import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { FunctionName } from './FunctionName.js'; import { ParametersDeclaration } from './ParametersDeclaration.js'; @@ -25,7 +26,7 @@ export class FunctionDefinition extends SlangNode { returns?: ReturnsDeclaration; - body: FunctionBody; + body: FunctionBody['variant']; constructor(ast: ast.FunctionDefinition, options: ParserOptions) { super(ast); @@ -36,7 +37,7 @@ export class FunctionDefinition extends SlangNode { if (ast.returns) { this.returns = new ReturnsDeclaration(ast.returns, options); } - this.body = new FunctionBody(ast.body, options); + this.body = extractVariant(new FunctionBody(ast.body, options)); this.updateMetadata( this.name, diff --git a/src/slang-nodes/ModifierDefinition.ts b/src/slang-nodes/ModifierDefinition.ts index af3cc526c..d668f397c 100644 --- a/src/slang-nodes/ModifierDefinition.ts +++ b/src/slang-nodes/ModifierDefinition.ts @@ -1,5 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printFunctionWithBody } from '../slang-printers/print-function.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.js'; import { ParametersDeclaration } from './ParametersDeclaration.js'; @@ -21,7 +22,7 @@ export class ModifierDefinition extends SlangNode { attributes: ModifierAttributes; - body: FunctionBody; + body: FunctionBody['variant']; constructor(ast: ast.ModifierDefinition, options: ParserOptions) { super(ast); @@ -31,7 +32,7 @@ export class ModifierDefinition extends SlangNode { this.parameters = new ParametersDeclaration(ast.parameters, options); } this.attributes = new ModifierAttributes(ast.attributes); - this.body = new FunctionBody(ast.body, options); + this.body = extractVariant(new FunctionBody(ast.body, options)); this.updateMetadata(this.parameters, this.attributes, this.body); diff --git a/src/slang-nodes/ReceiveFunctionDefinition.ts b/src/slang-nodes/ReceiveFunctionDefinition.ts index bd21f0240..27aa54698 100644 --- a/src/slang-nodes/ReceiveFunctionDefinition.ts +++ b/src/slang-nodes/ReceiveFunctionDefinition.ts @@ -1,5 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printFunctionWithBody } from '../slang-printers/print-function.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { ParametersDeclaration } from './ParametersDeclaration.js'; import { ReceiveFunctionAttributes } from './ReceiveFunctionAttributes.js'; @@ -17,7 +18,7 @@ export class ReceiveFunctionDefinition extends SlangNode { attributes: ReceiveFunctionAttributes; - body: FunctionBody; + body: FunctionBody['variant']; constructor( ast: ast.ReceiveFunctionDefinition, @@ -27,7 +28,7 @@ export class ReceiveFunctionDefinition extends SlangNode { this.parameters = new ParametersDeclaration(ast.parameters, options); this.attributes = new ReceiveFunctionAttributes(ast.attributes, options); - this.body = new FunctionBody(ast.body, options); + this.body = extractVariant(new FunctionBody(ast.body, options)); this.updateMetadata(this.parameters, this.attributes, this.body); diff --git a/src/slang-nodes/UnnamedFunctionDefinition.ts b/src/slang-nodes/UnnamedFunctionDefinition.ts index f22514401..71a0c8414 100644 --- a/src/slang-nodes/UnnamedFunctionDefinition.ts +++ b/src/slang-nodes/UnnamedFunctionDefinition.ts @@ -1,5 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printFunctionWithBody } from '../slang-printers/print-function.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { ParametersDeclaration } from './ParametersDeclaration.js'; import { UnnamedFunctionAttributes } from './UnnamedFunctionAttributes.js'; @@ -17,7 +18,7 @@ export class UnnamedFunctionDefinition extends SlangNode { attributes: UnnamedFunctionAttributes; - body: FunctionBody; + body: FunctionBody['variant']; constructor( ast: ast.UnnamedFunctionDefinition, @@ -27,7 +28,7 @@ export class UnnamedFunctionDefinition extends SlangNode { this.parameters = new ParametersDeclaration(ast.parameters, options); this.attributes = new UnnamedFunctionAttributes(ast.attributes, options); - this.body = new FunctionBody(ast.body, options); + this.body = extractVariant(new FunctionBody(ast.body, options)); this.updateMetadata(this.parameters, this.attributes, this.body); diff --git a/src/slang-printers/print-function.ts b/src/slang-printers/print-function.ts index b727cf4cb..024eb111a 100644 --- a/src/slang-printers/print-function.ts +++ b/src/slang-printers/print-function.ts @@ -1,13 +1,9 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; import { joinExisting } from '../slang-utils/join-existing.js'; -import { printVariant } from './print-variant.js'; import type { AstPath, Doc } from 'prettier'; -import type { - FunctionLike, - StrictPolymorphicNode -} from '../slang-nodes/types.d.ts'; +import type { FunctionLike } from '../slang-nodes/types.d.ts'; import type { PrintFunction } from '../types.d.ts'; import type { FunctionBody } from '../slang-nodes/FunctionBody.js'; @@ -19,7 +15,9 @@ export function printFunction( path: AstPath, print: PrintFunction ): Doc { - const body = (node as Extract).body; + const body = ( + node as Extract + ).body; return group([ functionName, @@ -30,9 +28,7 @@ export function printFunction( path.call(print, 'attributes'), path.call(print, 'returns') ]), - body && (!body.variant || body.variant.kind === NonterminalKind.Block) - ? dedent(line) - : '' + body && body.kind === NonterminalKind.Block ? dedent(line) : '' ]) ) ]); @@ -46,12 +42,6 @@ export function printFunctionWithBody( ): Doc { return [ printFunction(functionName, node, path, print), - node.kind !== NonterminalKind.ConstructorDefinition - ? ( - path as AstPath< - Extract - > - ).call(printVariant(print), 'body') - : path.call(print, 'body') + path.call(print, 'body') ]; } diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts index 17c6a0561..1bf813dd7 100644 --- a/src/slangPrinter.ts +++ b/src/slangPrinter.ts @@ -23,6 +23,7 @@ import type { ExperimentalFeature } from './slang-nodes/ExperimentalFeature.js'; import type { Expression } from './slang-nodes/Expression.js'; import type { ForStatementInitialization } from './slang-nodes/ForStatementInitialization.js'; import type { ForStatementCondition } from './slang-nodes/ForStatementCondition.js'; +import type { FunctionBody } from './slang-nodes/FunctionBody.js'; function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean { // Prettier sets SourceUnit's comments to undefined after assigning comments @@ -94,6 +95,7 @@ function genericPrint( | Expression | ForStatementInitialization | ForStatementCondition + | FunctionBody > >, options: ParserOptions, From e024caf89fba62fea694f2843a8ffaf6556f8c38 Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 17 Sep 2025 01:14:49 +0300 Subject: [PATCH 3/9] removing `FunctionName` from the AST tree --- src/slang-nodes/ContractDefinition.ts | 2 +- src/slang-nodes/FunctionDefinition.ts | 7 +++---- src/slang-nodes/FunctionName.ts | 4 ++-- src/slangPrinter.ts | 2 ++ 4 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/slang-nodes/ContractDefinition.ts b/src/slang-nodes/ContractDefinition.ts index 8dfc2b516..41c24bd5a 100644 --- a/src/slang-nodes/ContractDefinition.ts +++ b/src/slang-nodes/ContractDefinition.ts @@ -44,7 +44,7 @@ export class ContractDefinition extends SlangNode { for (const member of this.members.items) { if ( member.kind === NonterminalKind.FunctionDefinition && - member.name.variant.value !== this.name.value + member.name.value !== this.name.value ) { member.cleanModifierInvocationArguments(); } diff --git a/src/slang-nodes/FunctionDefinition.ts b/src/slang-nodes/FunctionDefinition.ts index 9cefa6361..a59d7afb9 100644 --- a/src/slang-nodes/FunctionDefinition.ts +++ b/src/slang-nodes/FunctionDefinition.ts @@ -1,7 +1,6 @@ import { satisfies } from 'semver'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printFunctionWithBody } from '../slang-printers/print-function.js'; -import { printVariant } from '../slang-printers/print-variant.js'; import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { FunctionName } from './FunctionName.js'; @@ -18,7 +17,7 @@ import type { AstNode } from './types.d.ts'; export class FunctionDefinition extends SlangNode { readonly kind = NonterminalKind.FunctionDefinition; - name: FunctionName; + name: FunctionName['variant']; parameters: ParametersDeclaration; @@ -31,7 +30,7 @@ export class FunctionDefinition extends SlangNode { constructor(ast: ast.FunctionDefinition, options: ParserOptions) { super(ast); - this.name = new FunctionName(ast.name); + this.name = extractVariant(new FunctionName(ast.name)); this.parameters = new ParametersDeclaration(ast.parameters, options); this.attributes = new FunctionAttributes(ast.attributes, options); if (ast.returns) { @@ -67,7 +66,7 @@ export class FunctionDefinition extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return printFunctionWithBody( - ['function ', path.call(printVariant(print), 'name')], + ['function ', path.call(print, 'name')], this, path, print diff --git a/src/slang-nodes/FunctionName.ts b/src/slang-nodes/FunctionName.ts index b3f9620e3..59cd6325d 100644 --- a/src/slang-nodes/FunctionName.ts +++ b/src/slang-nodes/FunctionName.ts @@ -1,10 +1,10 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -export class FunctionName extends PolymorphicNode { +export class FunctionName extends SlangNode { readonly kind = NonterminalKind.FunctionName; variant: TerminalNode; diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts index 1bf813dd7..3e6d0226c 100644 --- a/src/slangPrinter.ts +++ b/src/slangPrinter.ts @@ -24,6 +24,7 @@ import type { Expression } from './slang-nodes/Expression.js'; import type { ForStatementInitialization } from './slang-nodes/ForStatementInitialization.js'; import type { ForStatementCondition } from './slang-nodes/ForStatementCondition.js'; import type { FunctionBody } from './slang-nodes/FunctionBody.js'; +import type { FunctionName } from './slang-nodes/FunctionName.js'; function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean { // Prettier sets SourceUnit's comments to undefined after assigning comments @@ -96,6 +97,7 @@ function genericPrint( | ForStatementInitialization | ForStatementCondition | FunctionBody + | FunctionName > >, options: ParserOptions, From 964a10c331fc7c16e79793a023b370587a8b72cb Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 17 Sep 2025 01:32:49 +0300 Subject: [PATCH 4/9] removing `ImportClause`, `MappingKeyType`, `Pragma`, `StringExpression`, and `TupleMember` from the AST tree --- src/slang-nodes/Expression.ts | 4 ++-- src/slang-nodes/ImportClause.ts | 4 ++-- src/slang-nodes/ImportDirective.ts | 8 ++++---- src/slang-nodes/MappingKey.ts | 8 ++++---- src/slang-nodes/MappingKeyType.ts | 4 ++-- src/slang-nodes/Pragma.ts | 4 ++-- src/slang-nodes/PragmaDirective.ts | 8 ++++---- src/slang-nodes/StringExpression.ts | 4 ++-- src/slang-nodes/TupleDeconstructionElement.ts | 8 ++++---- src/slang-nodes/TupleMember.ts | 4 ++-- src/slangPrinter.ts | 10 ++++++++++ 11 files changed, 38 insertions(+), 28 deletions(-) diff --git a/src/slang-nodes/Expression.ts b/src/slang-nodes/Expression.ts index 0427f7b0f..32b746a42 100644 --- a/src/slang-nodes/Expression.ts +++ b/src/slang-nodes/Expression.ts @@ -117,7 +117,7 @@ function createNonterminalVariant( return new DecimalNumberExpression(variant); } if (variant instanceof ast.StringExpression) { - return new StringExpression(variant, options); + return extractVariant(new StringExpression(variant, options)); } if (variant instanceof ast.ElementaryType) { return extractVariant(new ElementaryType(variant)); @@ -155,7 +155,7 @@ export class Expression extends SlangNode { | ArrayExpression | HexNumberExpression | DecimalNumberExpression - | StringExpression + | StringExpression['variant'] | ElementaryType['variant'] | TerminalNode; diff --git a/src/slang-nodes/ImportClause.ts b/src/slang-nodes/ImportClause.ts index 3c721dc53..58f3cd96b 100644 --- a/src/slang-nodes/ImportClause.ts +++ b/src/slang-nodes/ImportClause.ts @@ -1,6 +1,6 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { PathImport } from './PathImport.js'; import { NamedImport } from './NamedImport.js'; import { ImportDeconstruction } from './ImportDeconstruction.js'; @@ -25,7 +25,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class ImportClause extends PolymorphicNode { +export class ImportClause extends SlangNode { readonly kind = NonterminalKind.ImportClause; variant: PathImport | NamedImport | ImportDeconstruction; diff --git a/src/slang-nodes/ImportDirective.ts b/src/slang-nodes/ImportDirective.ts index a09d53135..0f89c1600 100644 --- a/src/slang-nodes/ImportDirective.ts +++ b/src/slang-nodes/ImportDirective.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { ImportClause } from './ImportClause.js'; @@ -11,17 +11,17 @@ import type { AstNode } from './types.d.ts'; export class ImportDirective extends SlangNode { readonly kind = NonterminalKind.ImportDirective; - clause: ImportClause; + clause: ImportClause['variant']; constructor(ast: ast.ImportDirective, options: ParserOptions) { super(ast); - this.clause = new ImportClause(ast.clause, options); + this.clause = extractVariant(new ImportClause(ast.clause, options)); this.updateMetadata(this.clause); } print(path: AstPath, print: PrintFunction): Doc { - return ['import ', path.call(printVariant(print), 'clause'), ';']; + return ['import ', path.call(print, 'clause'), ';']; } } diff --git a/src/slang-nodes/MappingKey.ts b/src/slang-nodes/MappingKey.ts index 997193fcd..9c8248159 100644 --- a/src/slang-nodes/MappingKey.ts +++ b/src/slang-nodes/MappingKey.ts @@ -1,6 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { joinExisting } from '../slang-utils/join-existing.js'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { MappingKeyType } from './MappingKeyType.js'; import { TerminalNode } from './TerminalNode.js'; @@ -12,14 +12,14 @@ import type { PrintFunction } from '../types.d.ts'; export class MappingKey extends SlangNode { readonly kind = NonterminalKind.MappingKey; - keyType: MappingKeyType; + keyType: MappingKeyType['variant']; name?: TerminalNode; constructor(ast: ast.MappingKey) { super(ast); - this.keyType = new MappingKeyType(ast.keyType); + this.keyType = extractVariant(new MappingKeyType(ast.keyType)); if (ast.name) { this.name = new TerminalNode(ast.name); } @@ -29,7 +29,7 @@ export class MappingKey extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return joinExisting(' ', [ - path.call(printVariant(print), 'keyType'), + path.call(print, 'keyType'), path.call(print, 'name') ]); } diff --git a/src/slang-nodes/MappingKeyType.ts b/src/slang-nodes/MappingKeyType.ts index ba0fac223..4aa3cbd95 100644 --- a/src/slang-nodes/MappingKeyType.ts +++ b/src/slang-nodes/MappingKeyType.ts @@ -1,7 +1,7 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { extractVariant } from '../slang-utils/extract-variant.js'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { ElementaryType } from './ElementaryType.js'; import { IdentifierPath } from './IdentifierPath.js'; @@ -18,7 +18,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class MappingKeyType extends PolymorphicNode { +export class MappingKeyType extends SlangNode { readonly kind = NonterminalKind.MappingKeyType; variant: ElementaryType['variant'] | IdentifierPath; diff --git a/src/slang-nodes/Pragma.ts b/src/slang-nodes/Pragma.ts index 1206e2bbd..9d06b2a43 100644 --- a/src/slang-nodes/Pragma.ts +++ b/src/slang-nodes/Pragma.ts @@ -1,6 +1,6 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { AbicoderPragma } from './AbicoderPragma.js'; import { ExperimentalPragma } from './ExperimentalPragma.js'; import { VersionPragma } from './VersionPragma.js'; @@ -25,7 +25,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class Pragma extends PolymorphicNode { +export class Pragma extends SlangNode { readonly kind = NonterminalKind.Pragma; variant: AbicoderPragma | ExperimentalPragma | VersionPragma; diff --git a/src/slang-nodes/PragmaDirective.ts b/src/slang-nodes/PragmaDirective.ts index 1f1666b1f..3a928e7f7 100644 --- a/src/slang-nodes/PragmaDirective.ts +++ b/src/slang-nodes/PragmaDirective.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { Pragma } from './Pragma.js'; @@ -11,17 +11,17 @@ import type { AstNode } from './types.d.ts'; export class PragmaDirective extends SlangNode { readonly kind = NonterminalKind.PragmaDirective; - pragma: Pragma; + pragma: Pragma['variant']; constructor(ast: ast.PragmaDirective, options: ParserOptions) { super(ast); - this.pragma = new Pragma(ast.pragma, options); + this.pragma = extractVariant(new Pragma(ast.pragma, options)); this.updateMetadata(this.pragma); } print(path: AstPath, print: PrintFunction): Doc { - return ['pragma ', path.call(printVariant(print), 'pragma'), ';']; + return ['pragma ', path.call(print, 'pragma'), ';']; } } diff --git a/src/slang-nodes/StringExpression.ts b/src/slang-nodes/StringExpression.ts index 5b074af51..7dac815db 100644 --- a/src/slang-nodes/StringExpression.ts +++ b/src/slang-nodes/StringExpression.ts @@ -1,6 +1,6 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { StringLiteral } from './StringLiteral.js'; import { StringLiterals } from './StringLiterals.js'; import { HexStringLiteral } from './HexStringLiteral.js'; @@ -33,7 +33,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class StringExpression extends PolymorphicNode { +export class StringExpression extends SlangNode { readonly kind = NonterminalKind.StringExpression; variant: diff --git a/src/slang-nodes/TupleDeconstructionElement.ts b/src/slang-nodes/TupleDeconstructionElement.ts index 8c7c27d77..4a6c0493d 100644 --- a/src/slang-nodes/TupleDeconstructionElement.ts +++ b/src/slang-nodes/TupleDeconstructionElement.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TupleMember } from './TupleMember.js'; @@ -11,7 +11,7 @@ import type { AstNode } from './types.d.ts'; export class TupleDeconstructionElement extends SlangNode { readonly kind = NonterminalKind.TupleDeconstructionElement; - member?: TupleMember; + member?: TupleMember['variant']; constructor( ast: ast.TupleDeconstructionElement, @@ -20,13 +20,13 @@ export class TupleDeconstructionElement extends SlangNode { super(ast); if (ast.member) { - this.member = new TupleMember(ast.member, options); + this.member = extractVariant(new TupleMember(ast.member, options)); } this.updateMetadata(this.member); } print(path: AstPath, print: PrintFunction): Doc { - return path.call(printVariant(print), 'member'); + return path.call(print, 'member'); } } diff --git a/src/slang-nodes/TupleMember.ts b/src/slang-nodes/TupleMember.ts index 19b3b378b..4eb3bbe0b 100644 --- a/src/slang-nodes/TupleMember.ts +++ b/src/slang-nodes/TupleMember.ts @@ -1,6 +1,6 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { TypedTupleMember } from './TypedTupleMember.js'; import { UntypedTupleMember } from './UntypedTupleMember.js'; @@ -21,7 +21,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class TupleMember extends PolymorphicNode { +export class TupleMember extends SlangNode { readonly kind = NonterminalKind.TupleMember; variant: TypedTupleMember | UntypedTupleMember; diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts index 3e6d0226c..dc099b345 100644 --- a/src/slangPrinter.ts +++ b/src/slangPrinter.ts @@ -25,6 +25,11 @@ import type { ForStatementInitialization } from './slang-nodes/ForStatementIniti import type { ForStatementCondition } from './slang-nodes/ForStatementCondition.js'; import type { FunctionBody } from './slang-nodes/FunctionBody.js'; import type { FunctionName } from './slang-nodes/FunctionName.js'; +import type { ImportClause } from './slang-nodes/ImportClause.js'; +import type { MappingKeyType } from './slang-nodes/MappingKeyType.js'; +import type { Pragma } from './slang-nodes/Pragma.js'; +import type { StringExpression } from './slang-nodes/StringExpression.js'; +import type { TupleMember } from './slang-nodes/TupleMember.js'; function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean { // Prettier sets SourceUnit's comments to undefined after assigning comments @@ -98,6 +103,11 @@ function genericPrint( | ForStatementCondition | FunctionBody | FunctionName + | ImportClause + | MappingKeyType + | Pragma + | StringExpression + | TupleMember > >, options: ParserOptions, From 53ed70521eff7dd415d22b97f0afd1923b8a937f Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 17 Sep 2025 01:44:30 +0300 Subject: [PATCH 5/9] removing `TypeName` from the AST tree --- src/slang-nodes/ArrayTypeName.ts | 12 +++--------- src/slang-nodes/ConstantDefinition.ts | 7 +++---- src/slang-nodes/ErrorParameter.ts | 8 ++++---- src/slang-nodes/EventParameter.ts | 8 ++++---- src/slang-nodes/MappingValue.ts | 8 ++++---- src/slang-nodes/NewExpression.ts | 8 ++++---- src/slang-nodes/Parameter.ts | 8 ++++---- src/slang-nodes/StateVariableDefinition.ts | 8 ++++---- src/slang-nodes/StructMember.ts | 13 ++++--------- src/slang-nodes/TypeExpression.ts | 8 ++++---- src/slang-nodes/TypeName.ts | 4 ++-- src/slang-nodes/TypedTupleMember.ts | 8 ++++---- src/slang-nodes/UsingTarget.ts | 5 +++-- src/slang-nodes/VariableDeclarationType.ts | 5 +++-- src/slangPrinter.ts | 2 ++ 15 files changed, 52 insertions(+), 60 deletions(-) diff --git a/src/slang-nodes/ArrayTypeName.ts b/src/slang-nodes/ArrayTypeName.ts index a7ce37c14..eea23eb13 100644 --- a/src/slang-nodes/ArrayTypeName.ts +++ b/src/slang-nodes/ArrayTypeName.ts @@ -1,5 +1,4 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; @@ -13,14 +12,14 @@ import type { AstNode } from './types.d.ts'; export class ArrayTypeName extends SlangNode { readonly kind = NonterminalKind.ArrayTypeName; - operand: TypeName; + operand: TypeName['variant']; index?: Expression['variant']; constructor(ast: ast.ArrayTypeName, options: ParserOptions) { super(ast); - this.operand = new TypeName(ast.operand, options); + this.operand = extractVariant(new TypeName(ast.operand, options)); if (ast.index) { this.index = extractVariant(new Expression(ast.index, options)); } @@ -29,11 +28,6 @@ export class ArrayTypeName extends SlangNode { } print(path: AstPath, print: PrintFunction): Doc { - return [ - path.call(printVariant(print), 'operand'), - '[', - path.call(print, 'index'), - ']' - ]; + return [path.call(print, 'operand'), '[', path.call(print, 'index'), ']']; } } diff --git a/src/slang-nodes/ConstantDefinition.ts b/src/slang-nodes/ConstantDefinition.ts index 0e2e95a28..0c898b8e4 100644 --- a/src/slang-nodes/ConstantDefinition.ts +++ b/src/slang-nodes/ConstantDefinition.ts @@ -1,5 +1,4 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; @@ -14,7 +13,7 @@ import type { AstNode } from './types.d.ts'; export class ConstantDefinition extends SlangNode { readonly kind = NonterminalKind.ConstantDefinition; - typeName: TypeName; + typeName: TypeName['variant']; name: TerminalNode; @@ -23,7 +22,7 @@ export class ConstantDefinition extends SlangNode { constructor(ast: ast.ConstantDefinition, options: ParserOptions) { super(ast); - this.typeName = new TypeName(ast.typeName, options); + this.typeName = extractVariant(new TypeName(ast.typeName, options)); this.name = new TerminalNode(ast.name); this.value = extractVariant(new Expression(ast.value, options)); @@ -32,7 +31,7 @@ export class ConstantDefinition extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return [ - path.call(printVariant(print), 'typeName'), + path.call(print, 'typeName'), ' constant ', path.call(print, 'name'), ' = ', diff --git a/src/slang-nodes/ErrorParameter.ts b/src/slang-nodes/ErrorParameter.ts index 105f0c855..bca479f2e 100644 --- a/src/slang-nodes/ErrorParameter.ts +++ b/src/slang-nodes/ErrorParameter.ts @@ -1,6 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { joinExisting } from '../slang-utils/join-existing.js'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; @@ -13,14 +13,14 @@ import type { AstNode } from './types.d.ts'; export class ErrorParameter extends SlangNode { readonly kind = NonterminalKind.ErrorParameter; - typeName: TypeName; + typeName: TypeName['variant']; name?: TerminalNode; constructor(ast: ast.ErrorParameter, options: ParserOptions) { super(ast); - this.typeName = new TypeName(ast.typeName, options); + this.typeName = extractVariant(new TypeName(ast.typeName, options)); if (ast.name) { this.name = new TerminalNode(ast.name); } @@ -30,7 +30,7 @@ export class ErrorParameter extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return joinExisting(' ', [ - path.call(printVariant(print), 'typeName'), + path.call(print, 'typeName'), path.call(print, 'name') ]); } diff --git a/src/slang-nodes/EventParameter.ts b/src/slang-nodes/EventParameter.ts index 00114408c..4e49d652b 100644 --- a/src/slang-nodes/EventParameter.ts +++ b/src/slang-nodes/EventParameter.ts @@ -1,6 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { joinExisting } from '../slang-utils/join-existing.js'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; @@ -13,7 +13,7 @@ import type { AstNode } from './types.d.ts'; export class EventParameter extends SlangNode { readonly kind = NonterminalKind.EventParameter; - typeName: TypeName; + typeName: TypeName['variant']; indexedKeyword?: string; @@ -22,7 +22,7 @@ export class EventParameter extends SlangNode { constructor(ast: ast.EventParameter, options: ParserOptions) { super(ast); - this.typeName = new TypeName(ast.typeName, options); + this.typeName = extractVariant(new TypeName(ast.typeName, options)); this.indexedKeyword = ast.indexedKeyword?.unparse(); if (ast.name) { this.name = new TerminalNode(ast.name); @@ -33,7 +33,7 @@ export class EventParameter extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return joinExisting(' ', [ - path.call(printVariant(print), 'typeName'), + path.call(print, 'typeName'), this.indexedKeyword, path.call(print, 'name') ]); diff --git a/src/slang-nodes/MappingValue.ts b/src/slang-nodes/MappingValue.ts index 7221d9d52..e22917a21 100644 --- a/src/slang-nodes/MappingValue.ts +++ b/src/slang-nodes/MappingValue.ts @@ -1,6 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { joinExisting } from '../slang-utils/join-existing.js'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; @@ -13,14 +13,14 @@ import type { AstNode } from './types.d.ts'; export class MappingValue extends SlangNode { readonly kind = NonterminalKind.MappingValue; - typeName: TypeName; + typeName: TypeName['variant']; name?: TerminalNode; constructor(ast: ast.MappingValue, options: ParserOptions) { super(ast); - this.typeName = new TypeName(ast.typeName, options); + this.typeName = extractVariant(new TypeName(ast.typeName, options)); if (ast.name) { this.name = new TerminalNode(ast.name); } @@ -30,7 +30,7 @@ export class MappingValue extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return joinExisting(' ', [ - path.call(printVariant(print), 'typeName'), + path.call(print, 'typeName'), path.call(print, 'name') ]); } diff --git a/src/slang-nodes/NewExpression.ts b/src/slang-nodes/NewExpression.ts index 972606fa7..e022c17fd 100644 --- a/src/slang-nodes/NewExpression.ts +++ b/src/slang-nodes/NewExpression.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; @@ -11,17 +11,17 @@ import type { AstNode } from './types.d.ts'; export class NewExpression extends SlangNode { readonly kind = NonterminalKind.NewExpression; - typeName: TypeName; + typeName: TypeName['variant']; constructor(ast: ast.NewExpression, options: ParserOptions) { super(ast); - this.typeName = new TypeName(ast.typeName, options); + this.typeName = extractVariant(new TypeName(ast.typeName, options)); this.updateMetadata(this.typeName); } print(path: AstPath, print: PrintFunction): Doc { - return ['new ', path.call(printVariant(print), 'typeName')]; + return ['new ', path.call(print, 'typeName')]; } } diff --git a/src/slang-nodes/Parameter.ts b/src/slang-nodes/Parameter.ts index 0f371faae..f2a6c3b9a 100644 --- a/src/slang-nodes/Parameter.ts +++ b/src/slang-nodes/Parameter.ts @@ -1,7 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; import { joinExisting } from '../slang-utils/join-existing.js'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import { StorageLocation } from './StorageLocation.js'; @@ -17,7 +17,7 @@ const { group } = doc.builders; export class Parameter extends SlangNode { readonly kind = NonterminalKind.Parameter; - typeName: TypeName; + typeName: TypeName['variant']; storageLocation?: StorageLocation; @@ -26,7 +26,7 @@ export class Parameter extends SlangNode { constructor(ast: ast.Parameter, options: ParserOptions) { super(ast); - this.typeName = new TypeName(ast.typeName, options); + this.typeName = extractVariant(new TypeName(ast.typeName, options)); if (ast.storageLocation) { this.storageLocation = new StorageLocation(ast.storageLocation); } @@ -40,7 +40,7 @@ export class Parameter extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return group( joinExisting(' ', [ - path.call(printVariant(print), 'typeName'), + path.call(print, 'typeName'), path.call(print, 'storageLocation'), path.call(print, 'name') ]) diff --git a/src/slang-nodes/StateVariableDefinition.ts b/src/slang-nodes/StateVariableDefinition.ts index 1d7bdd830..a4f5d34fd 100644 --- a/src/slang-nodes/StateVariableDefinition.ts +++ b/src/slang-nodes/StateVariableDefinition.ts @@ -1,7 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; import { printGroupAndIndentIfBreakPair } from '../slang-printers/print-group-and-indent-if-break-pair.js'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import { StateVariableAttributes } from './StateVariableAttributes.js'; @@ -18,7 +18,7 @@ const { indent } = doc.builders; export class StateVariableDefinition extends SlangNode { readonly kind = NonterminalKind.StateVariableDefinition; - typeName: TypeName; + typeName: TypeName['variant']; attributes: StateVariableAttributes; @@ -32,7 +32,7 @@ export class StateVariableDefinition extends SlangNode { ) { super(ast); - this.typeName = new TypeName(ast.typeName, options); + this.typeName = extractVariant(new TypeName(ast.typeName, options)); this.attributes = new StateVariableAttributes(ast.attributes); this.name = new TerminalNode(ast.name); if (ast.value) { @@ -45,7 +45,7 @@ export class StateVariableDefinition extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return printGroupAndIndentIfBreakPair( [ - path.call(printVariant(print), 'typeName'), + path.call(print, 'typeName'), indent(path.call(print, 'attributes')), ' ', path.call(print, 'name') diff --git a/src/slang-nodes/StructMember.ts b/src/slang-nodes/StructMember.ts index 581a49659..bfc8fa75b 100644 --- a/src/slang-nodes/StructMember.ts +++ b/src/slang-nodes/StructMember.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; @@ -12,25 +12,20 @@ import type { AstNode } from './types.d.ts'; export class StructMember extends SlangNode { readonly kind = NonterminalKind.StructMember; - typeName: TypeName; + typeName: TypeName['variant']; name: TerminalNode; constructor(ast: ast.StructMember, options: ParserOptions) { super(ast); - this.typeName = new TypeName(ast.typeName, options); + this.typeName = extractVariant(new TypeName(ast.typeName, options)); this.name = new TerminalNode(ast.name); this.updateMetadata(this.typeName); } print(path: AstPath, print: PrintFunction): Doc { - return [ - path.call(printVariant(print), 'typeName'), - ' ', - path.call(print, 'name'), - ';' - ]; + return [path.call(print, 'typeName'), ' ', path.call(print, 'name'), ';']; } } diff --git a/src/slang-nodes/TypeExpression.ts b/src/slang-nodes/TypeExpression.ts index dc1fe0f59..14d87f050 100644 --- a/src/slang-nodes/TypeExpression.ts +++ b/src/slang-nodes/TypeExpression.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; @@ -11,17 +11,17 @@ import type { AstNode } from './types.d.ts'; export class TypeExpression extends SlangNode { readonly kind = NonterminalKind.TypeExpression; - typeName: TypeName; + typeName: TypeName['variant']; constructor(ast: ast.TypeExpression, options: ParserOptions) { super(ast); - this.typeName = new TypeName(ast.typeName, options); + this.typeName = extractVariant(new TypeName(ast.typeName, options)); this.updateMetadata(this.typeName); } print(path: AstPath, print: PrintFunction): Doc { - return ['type(', path.call(printVariant(print), 'typeName'), ')']; + return ['type(', path.call(print, 'typeName'), ')']; } } diff --git a/src/slang-nodes/TypeName.ts b/src/slang-nodes/TypeName.ts index 341a1e7af..e4868c37a 100644 --- a/src/slang-nodes/TypeName.ts +++ b/src/slang-nodes/TypeName.ts @@ -1,7 +1,7 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { extractVariant } from '../slang-utils/extract-variant.js'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { ArrayTypeName } from './ArrayTypeName.js'; import { FunctionType } from './FunctionType.js'; import { MappingType } from './MappingType.js'; @@ -34,7 +34,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class TypeName extends PolymorphicNode { +export class TypeName extends SlangNode { readonly kind = NonterminalKind.TypeName; variant: diff --git a/src/slang-nodes/TypedTupleMember.ts b/src/slang-nodes/TypedTupleMember.ts index 700ed2ce9..2cf82bd72 100644 --- a/src/slang-nodes/TypedTupleMember.ts +++ b/src/slang-nodes/TypedTupleMember.ts @@ -1,6 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { joinExisting } from '../slang-utils/join-existing.js'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import { StorageLocation } from './StorageLocation.js'; @@ -14,7 +14,7 @@ import type { AstNode } from './types.d.ts'; export class TypedTupleMember extends SlangNode { readonly kind = NonterminalKind.TypedTupleMember; - typeName: TypeName; + typeName: TypeName['variant']; storageLocation?: StorageLocation; @@ -23,7 +23,7 @@ export class TypedTupleMember extends SlangNode { constructor(ast: ast.TypedTupleMember, options: ParserOptions) { super(ast); - this.typeName = new TypeName(ast.typeName, options); + this.typeName = extractVariant(new TypeName(ast.typeName, options)); if (ast.storageLocation) { this.storageLocation = new StorageLocation(ast.storageLocation); } @@ -34,7 +34,7 @@ export class TypedTupleMember extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return joinExisting(' ', [ - path.call(printVariant(print), 'typeName'), + path.call(print, 'typeName'), path.call(print, 'storageLocation'), path.call(print, 'name') ]); diff --git a/src/slang-nodes/UsingTarget.ts b/src/slang-nodes/UsingTarget.ts index 8eaeb1490..9d33cf9bd 100644 --- a/src/slang-nodes/UsingTarget.ts +++ b/src/slang-nodes/UsingTarget.ts @@ -2,6 +2,7 @@ import { NonterminalKind, TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { PolymorphicNode } from './PolymorphicNode.js'; import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; @@ -13,7 +14,7 @@ import type { AstNode } from './types.d.ts'; export class UsingTarget extends PolymorphicNode { readonly kind = NonterminalKind.UsingTarget; - variant: TypeName | TerminalNode; + variant: TypeName['variant'] | TerminalNode; constructor(ast: ast.UsingTarget, options: ParserOptions) { super(ast); @@ -23,7 +24,7 @@ export class UsingTarget extends PolymorphicNode { this.variant = new TerminalNode(variant); return; } - this.variant = new TypeName(variant, options); + this.variant = extractVariant(new TypeName(variant, options)); this.updateMetadata(this.variant); } diff --git a/src/slang-nodes/VariableDeclarationType.ts b/src/slang-nodes/VariableDeclarationType.ts index d17312222..ae683a6b9 100644 --- a/src/slang-nodes/VariableDeclarationType.ts +++ b/src/slang-nodes/VariableDeclarationType.ts @@ -2,6 +2,7 @@ import { NonterminalKind, TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { PolymorphicNode } from './PolymorphicNode.js'; import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; @@ -13,7 +14,7 @@ import type { AstNode } from './types.d.ts'; export class VariableDeclarationType extends PolymorphicNode { readonly kind = NonterminalKind.VariableDeclarationType; - variant: TypeName | TerminalNode; + variant: TypeName['variant'] | TerminalNode; constructor( ast: ast.VariableDeclarationType, @@ -26,7 +27,7 @@ export class VariableDeclarationType extends PolymorphicNode { this.variant = new TerminalNode(variant); return; } - this.variant = new TypeName(variant, options); + this.variant = extractVariant(new TypeName(variant, options)); this.updateMetadata(this.variant); } diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts index dc099b345..66d556529 100644 --- a/src/slangPrinter.ts +++ b/src/slangPrinter.ts @@ -30,6 +30,7 @@ import type { MappingKeyType } from './slang-nodes/MappingKeyType.js'; import type { Pragma } from './slang-nodes/Pragma.js'; import type { StringExpression } from './slang-nodes/StringExpression.js'; import type { TupleMember } from './slang-nodes/TupleMember.js'; +import type { TypeName } from './slang-nodes/TypeName.js'; function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean { // Prettier sets SourceUnit's comments to undefined after assigning comments @@ -108,6 +109,7 @@ function genericPrint( | Pragma | StringExpression | TupleMember + | TypeName > >, options: ParserOptions, From badb2cfcba4a526ab6e7c3f67d098610ad8cbc00 Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 17 Sep 2025 02:11:31 +0300 Subject: [PATCH 6/9] removing `UsingClause`, `UsingTarget`, `VariableDeclarationType`, `VersionExpression`, and `VersionLiteral` from the AST tree --- src/slang-nodes/UsingClause.ts | 4 ++-- src/slang-nodes/UsingDirective.ts | 14 +++++++------- src/slang-nodes/UsingTarget.ts | 4 ++-- src/slang-nodes/VariableDeclarationStatement.ts | 10 ++++++---- src/slang-nodes/VariableDeclarationType.ts | 4 ++-- src/slang-nodes/VersionExpression.ts | 4 ++-- src/slang-nodes/VersionExpressionSet.ts | 10 ++++++---- src/slang-nodes/VersionLiteral.ts | 4 ++-- src/slang-nodes/VersionRange.ts | 16 ++++++---------- src/slang-nodes/VersionTerm.ts | 11 ++++------- src/slangPrinter.ts | 10 ++++++++++ 11 files changed, 49 insertions(+), 42 deletions(-) diff --git a/src/slang-nodes/UsingClause.ts b/src/slang-nodes/UsingClause.ts index a1f8f8215..e619b60c9 100644 --- a/src/slang-nodes/UsingClause.ts +++ b/src/slang-nodes/UsingClause.ts @@ -1,6 +1,6 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { IdentifierPath } from './IdentifierPath.js'; import { UsingDeconstruction } from './UsingDeconstruction.js'; @@ -17,7 +17,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class UsingClause extends PolymorphicNode { +export class UsingClause extends SlangNode { readonly kind = NonterminalKind.UsingClause; variant: IdentifierPath | UsingDeconstruction; diff --git a/src/slang-nodes/UsingDirective.ts b/src/slang-nodes/UsingDirective.ts index 8383f758e..10f1789a8 100644 --- a/src/slang-nodes/UsingDirective.ts +++ b/src/slang-nodes/UsingDirective.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { UsingClause } from './UsingClause.js'; import { UsingTarget } from './UsingTarget.js'; @@ -12,17 +12,17 @@ import type { AstNode } from './types.d.ts'; export class UsingDirective extends SlangNode { readonly kind = NonterminalKind.UsingDirective; - clause: UsingClause; + clause: UsingClause['variant']; - target: UsingTarget; + target: UsingTarget['variant']; globalKeyword?: string; constructor(ast: ast.UsingDirective, options: ParserOptions) { super(ast); - this.clause = new UsingClause(ast.clause); - this.target = new UsingTarget(ast.target, options); + this.clause = extractVariant(new UsingClause(ast.clause)); + this.target = extractVariant(new UsingTarget(ast.target, options)); this.globalKeyword = ast.globalKeyword?.unparse(); this.updateMetadata(this.clause, this.target); @@ -31,9 +31,9 @@ export class UsingDirective extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return [ 'using ', - path.call(printVariant(print), 'clause'), + path.call(print, 'clause'), ' for ', - path.call(printVariant(print), 'target'), + path.call(print, 'target'), this.globalKeyword ? ' global;' : ';' ]; } diff --git a/src/slang-nodes/UsingTarget.ts b/src/slang-nodes/UsingTarget.ts index 9d33cf9bd..74d07e770 100644 --- a/src/slang-nodes/UsingTarget.ts +++ b/src/slang-nodes/UsingTarget.ts @@ -3,7 +3,7 @@ import { TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; import { extractVariant } from '../slang-utils/extract-variant.js'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; @@ -11,7 +11,7 @@ import type * as ast from '@nomicfoundation/slang/ast'; import type { ParserOptions } from 'prettier'; import type { AstNode } from './types.d.ts'; -export class UsingTarget extends PolymorphicNode { +export class UsingTarget extends SlangNode { readonly kind = NonterminalKind.UsingTarget; variant: TypeName['variant'] | TerminalNode; diff --git a/src/slang-nodes/VariableDeclarationStatement.ts b/src/slang-nodes/VariableDeclarationStatement.ts index ee5d1fadb..b777d637f 100644 --- a/src/slang-nodes/VariableDeclarationStatement.ts +++ b/src/slang-nodes/VariableDeclarationStatement.ts @@ -1,7 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; import { printGroupAndIndentIfBreakPair } from '../slang-printers/print-group-and-indent-if-break-pair.js'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { VariableDeclarationType } from './VariableDeclarationType.js'; import { StorageLocation } from './StorageLocation.js'; @@ -18,7 +18,7 @@ const { indent, line } = doc.builders; export class VariableDeclarationStatement extends SlangNode { readonly kind = NonterminalKind.VariableDeclarationStatement; - variableType: VariableDeclarationType; + variableType: VariableDeclarationType['variant']; storageLocation?: StorageLocation; @@ -32,7 +32,9 @@ export class VariableDeclarationStatement extends SlangNode { ) { super(ast); - this.variableType = new VariableDeclarationType(ast.variableType, options); + this.variableType = extractVariant( + new VariableDeclarationType(ast.variableType, options) + ); if (ast.storageLocation) { this.storageLocation = new StorageLocation(ast.storageLocation); } @@ -50,7 +52,7 @@ export class VariableDeclarationStatement extends SlangNode { ): Doc { return printGroupAndIndentIfBreakPair( [ - path.call(printVariant(print), 'variableType'), + path.call(print, 'variableType'), this.storageLocation ? indent([line, path.call(print, 'storageLocation')]) : '', diff --git a/src/slang-nodes/VariableDeclarationType.ts b/src/slang-nodes/VariableDeclarationType.ts index ae683a6b9..99bfff663 100644 --- a/src/slang-nodes/VariableDeclarationType.ts +++ b/src/slang-nodes/VariableDeclarationType.ts @@ -3,7 +3,7 @@ import { TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; import { extractVariant } from '../slang-utils/extract-variant.js'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { TypeName } from './TypeName.js'; import { TerminalNode } from './TerminalNode.js'; @@ -11,7 +11,7 @@ import type * as ast from '@nomicfoundation/slang/ast'; import type { ParserOptions } from 'prettier'; import type { AstNode } from './types.d.ts'; -export class VariableDeclarationType extends PolymorphicNode { +export class VariableDeclarationType extends SlangNode { readonly kind = NonterminalKind.VariableDeclarationType; variant: TypeName['variant'] | TerminalNode; diff --git a/src/slang-nodes/VersionExpression.ts b/src/slang-nodes/VersionExpression.ts index abb1cb85c..1385e3ee3 100644 --- a/src/slang-nodes/VersionExpression.ts +++ b/src/slang-nodes/VersionExpression.ts @@ -1,6 +1,6 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { VersionRange } from './VersionRange.js'; import { VersionTerm } from './VersionTerm.js'; @@ -17,7 +17,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class VersionExpression extends PolymorphicNode { +export class VersionExpression extends SlangNode { readonly kind = NonterminalKind.VersionExpression; variant: VersionRange | VersionTerm; diff --git a/src/slang-nodes/VersionExpressionSet.ts b/src/slang-nodes/VersionExpressionSet.ts index 1cbf99ed3..25d58d6c6 100644 --- a/src/slang-nodes/VersionExpressionSet.ts +++ b/src/slang-nodes/VersionExpressionSet.ts @@ -1,6 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { VersionExpression } from './VersionExpression.js'; @@ -13,15 +13,17 @@ const { join } = doc.builders; export class VersionExpressionSet extends SlangNode { readonly kind = NonterminalKind.VersionExpressionSet; - items: VersionExpression[]; + items: VersionExpression['variant'][]; constructor(ast: ast.VersionExpressionSet) { super(ast, true); - this.items = ast.items.map((item) => new VersionExpression(item)); + this.items = ast.items.map((item) => + extractVariant(new VersionExpression(item)) + ); } print(path: AstPath, print: PrintFunction): Doc { - return join(' ', path.map(printVariant(print), 'items')); + return join(' ', path.map(print, 'items')); } } diff --git a/src/slang-nodes/VersionLiteral.ts b/src/slang-nodes/VersionLiteral.ts index fa809017f..6d13cfb2a 100644 --- a/src/slang-nodes/VersionLiteral.ts +++ b/src/slang-nodes/VersionLiteral.ts @@ -2,13 +2,13 @@ import { NonterminalKind, TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { SimpleVersionLiteral } from './SimpleVersionLiteral.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -export class VersionLiteral extends PolymorphicNode { +export class VersionLiteral extends SlangNode { readonly kind = NonterminalKind.VersionLiteral; variant: SimpleVersionLiteral | TerminalNode; diff --git a/src/slang-nodes/VersionRange.ts b/src/slang-nodes/VersionRange.ts index f4cd5da40..9da999c9c 100644 --- a/src/slang-nodes/VersionRange.ts +++ b/src/slang-nodes/VersionRange.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { VersionLiteral } from './VersionLiteral.js'; @@ -10,24 +10,20 @@ import type { PrintFunction } from '../types.d.ts'; export class VersionRange extends SlangNode { readonly kind = NonterminalKind.VersionRange; - start: VersionLiteral; + start: VersionLiteral['variant']; - end: VersionLiteral; + end: VersionLiteral['variant']; constructor(ast: ast.VersionRange) { super(ast); - this.start = new VersionLiteral(ast.start); - this.end = new VersionLiteral(ast.end); + this.start = extractVariant(new VersionLiteral(ast.start)); + this.end = extractVariant(new VersionLiteral(ast.end)); this.updateMetadata(this.start, this.end); } print(path: AstPath, print: PrintFunction): Doc { - return [ - path.call(printVariant(print), 'start'), - ' - ', - path.call(printVariant(print), 'end') - ]; + return [path.call(print, 'start'), ' - ', path.call(print, 'end')]; } } diff --git a/src/slang-nodes/VersionTerm.ts b/src/slang-nodes/VersionTerm.ts index 201064e65..e4a2dfc02 100644 --- a/src/slang-nodes/VersionTerm.ts +++ b/src/slang-nodes/VersionTerm.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { VersionOperator } from './VersionOperator.js'; import { VersionLiteral } from './VersionLiteral.js'; @@ -13,7 +13,7 @@ export class VersionTerm extends SlangNode { operator?: VersionOperator; - literal: VersionLiteral; + literal: VersionLiteral['variant']; constructor(ast: ast.VersionTerm) { super(ast); @@ -21,15 +21,12 @@ export class VersionTerm extends SlangNode { if (ast.operator) { this.operator = new VersionOperator(ast.operator); } - this.literal = new VersionLiteral(ast.literal); + this.literal = extractVariant(new VersionLiteral(ast.literal)); this.updateMetadata(this.operator, this.literal); } print(path: AstPath, print: PrintFunction): Doc { - return [ - path.call(print, 'operator'), - path.call(printVariant(print), 'literal') - ]; + return [path.call(print, 'operator'), path.call(print, 'literal')]; } } diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts index 66d556529..831518b7a 100644 --- a/src/slangPrinter.ts +++ b/src/slangPrinter.ts @@ -31,6 +31,11 @@ import type { Pragma } from './slang-nodes/Pragma.js'; import type { StringExpression } from './slang-nodes/StringExpression.js'; import type { TupleMember } from './slang-nodes/TupleMember.js'; import type { TypeName } from './slang-nodes/TypeName.js'; +import type { UsingClause } from './slang-nodes/UsingClause.js'; +import type { UsingTarget } from './slang-nodes/UsingTarget.js'; +import type { VariableDeclarationType } from './slang-nodes/VariableDeclarationType.js'; +import type { VersionExpression } from './slang-nodes/VersionExpression.js'; +import type { VersionLiteral } from './slang-nodes/VersionLiteral.js'; function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean { // Prettier sets SourceUnit's comments to undefined after assigning comments @@ -110,6 +115,11 @@ function genericPrint( | StringExpression | TupleMember | TypeName + | UsingClause + | UsingTarget + | VariableDeclarationType + | VersionExpression + | VersionLiteral > >, options: ParserOptions, From 6527066ab6e0ca43acc51252f42b82f916121565 Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 17 Sep 2025 02:25:12 +0300 Subject: [PATCH 7/9] removing `YulAssignmentOperator`, `YulLiteral`, `YulStackAssignmentOperator`, and `YulSwitchCase` from the AST tree --- src/slang-nodes/YulAssignmentOperator.ts | 4 ++-- src/slang-nodes/YulExpression.ts | 5 +++-- src/slang-nodes/YulLiteral.ts | 4 ++-- src/slang-nodes/YulStackAssignmentOperator.ts | 4 ++-- src/slang-nodes/YulStackAssignmentStatement.ts | 10 ++++++---- src/slang-nodes/YulSwitchCase.ts | 4 ++-- src/slang-nodes/YulSwitchCases.ts | 10 ++++++---- src/slang-nodes/YulValueCase.ts | 13 ++++--------- src/slang-nodes/YulVariableAssignmentStatement.ts | 7 ++++--- src/slang-nodes/YulVariableDeclarationValue.ts | 7 ++++--- src/slangPrinter.ts | 8 ++++++++ 11 files changed, 43 insertions(+), 33 deletions(-) diff --git a/src/slang-nodes/YulAssignmentOperator.ts b/src/slang-nodes/YulAssignmentOperator.ts index c8453b73b..e23ebed1b 100644 --- a/src/slang-nodes/YulAssignmentOperator.ts +++ b/src/slang-nodes/YulAssignmentOperator.ts @@ -2,13 +2,13 @@ import { NonterminalKind, TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { YulColonAndEqual } from './YulColonAndEqual.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -export class YulAssignmentOperator extends PolymorphicNode { +export class YulAssignmentOperator extends SlangNode { readonly kind = NonterminalKind.YulAssignmentOperator; variant: YulColonAndEqual | TerminalNode; diff --git a/src/slang-nodes/YulExpression.ts b/src/slang-nodes/YulExpression.ts index 6afa8526f..2c6daae25 100644 --- a/src/slang-nodes/YulExpression.ts +++ b/src/slang-nodes/YulExpression.ts @@ -1,5 +1,6 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { PolymorphicNode } from './PolymorphicNode.js'; import { YulFunctionCallExpression } from './YulFunctionCallExpression.js'; import { YulLiteral } from './YulLiteral.js'; @@ -16,7 +17,7 @@ function createNonterminalVariant( return new YulFunctionCallExpression(variant, options); } if (variant instanceof ast.YulLiteral) { - return new YulLiteral(variant, options); + return extractVariant(new YulLiteral(variant, options)); } if (variant instanceof ast.YulPath) { return new YulPath(variant); @@ -28,7 +29,7 @@ function createNonterminalVariant( export class YulExpression extends PolymorphicNode { readonly kind = NonterminalKind.YulExpression; - variant: YulFunctionCallExpression | YulLiteral | YulPath; + variant: YulFunctionCallExpression | YulLiteral['variant'] | YulPath; constructor(ast: ast.YulExpression, options: ParserOptions) { super(ast); diff --git a/src/slang-nodes/YulLiteral.ts b/src/slang-nodes/YulLiteral.ts index e79a7c97b..72ef74856 100644 --- a/src/slang-nodes/YulLiteral.ts +++ b/src/slang-nodes/YulLiteral.ts @@ -3,7 +3,7 @@ import { NonterminalKind, TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { HexStringLiteral } from './HexStringLiteral.js'; import { StringLiteral } from './StringLiteral.js'; import { TerminalNode } from './TerminalNode.js'; @@ -25,7 +25,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class YulLiteral extends PolymorphicNode { +export class YulLiteral extends SlangNode { readonly kind = NonterminalKind.YulLiteral; variant: HexStringLiteral | StringLiteral | TerminalNode; diff --git a/src/slang-nodes/YulStackAssignmentOperator.ts b/src/slang-nodes/YulStackAssignmentOperator.ts index 9bcf338bd..0318ae8bf 100644 --- a/src/slang-nodes/YulStackAssignmentOperator.ts +++ b/src/slang-nodes/YulStackAssignmentOperator.ts @@ -2,13 +2,13 @@ import { NonterminalKind, TerminalNode as SlangTerminalNode } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { YulEqualAndColon } from './YulEqualAndColon.js'; import { TerminalNode } from './TerminalNode.js'; import type * as ast from '@nomicfoundation/slang/ast'; -export class YulStackAssignmentOperator extends PolymorphicNode { +export class YulStackAssignmentOperator extends SlangNode { readonly kind = NonterminalKind.YulStackAssignmentOperator; variant: YulEqualAndColon | TerminalNode; diff --git a/src/slang-nodes/YulStackAssignmentStatement.ts b/src/slang-nodes/YulStackAssignmentStatement.ts index f8723b72b..e2bd99982 100644 --- a/src/slang-nodes/YulStackAssignmentStatement.ts +++ b/src/slang-nodes/YulStackAssignmentStatement.ts @@ -1,7 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; import { printSeparatedItem } from '../slang-printers/print-separated-item.js'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulStackAssignmentOperator } from './YulStackAssignmentOperator.js'; import { TerminalNode } from './TerminalNode.js'; @@ -15,14 +15,16 @@ const { line } = doc.builders; export class YulStackAssignmentStatement extends SlangNode { readonly kind = NonterminalKind.YulStackAssignmentStatement; - assignment: YulStackAssignmentOperator; + assignment: YulStackAssignmentOperator['variant']; variable: TerminalNode; constructor(ast: ast.YulStackAssignmentStatement) { super(ast); - this.assignment = new YulStackAssignmentOperator(ast.assignment); + this.assignment = extractVariant( + new YulStackAssignmentOperator(ast.assignment) + ); this.variable = new TerminalNode(ast.variable); this.updateMetadata(this.assignment); @@ -30,7 +32,7 @@ export class YulStackAssignmentStatement extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return [ - path.call(printVariant(print), 'assignment'), + path.call(print, 'assignment'), printSeparatedItem(path.call(print, 'variable'), { firstSeparator: line, lastSeparator: '' diff --git a/src/slang-nodes/YulSwitchCase.ts b/src/slang-nodes/YulSwitchCase.ts index 12fedd3fb..3c629e55b 100644 --- a/src/slang-nodes/YulSwitchCase.ts +++ b/src/slang-nodes/YulSwitchCase.ts @@ -1,6 +1,6 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { YulDefaultCase } from './YulDefaultCase.js'; import { YulValueCase } from './YulValueCase.js'; @@ -21,7 +21,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class YulSwitchCase extends PolymorphicNode { +export class YulSwitchCase extends SlangNode { readonly kind = NonterminalKind.YulSwitchCase; variant: YulDefaultCase | YulValueCase; diff --git a/src/slang-nodes/YulSwitchCases.ts b/src/slang-nodes/YulSwitchCases.ts index 841efb113..0b0d672b2 100644 --- a/src/slang-nodes/YulSwitchCases.ts +++ b/src/slang-nodes/YulSwitchCases.ts @@ -1,6 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulSwitchCase } from './YulSwitchCase.js'; @@ -14,15 +14,17 @@ const { hardline, join } = doc.builders; export class YulSwitchCases extends SlangNode { readonly kind = NonterminalKind.YulSwitchCases; - items: YulSwitchCase[]; + items: YulSwitchCase['variant'][]; constructor(ast: ast.YulSwitchCases, options: ParserOptions) { super(ast, true); - this.items = ast.items.map((item) => new YulSwitchCase(item, options)); + this.items = ast.items.map((item) => + extractVariant(new YulSwitchCase(item, options)) + ); } print(path: AstPath, print: PrintFunction): Doc { - return join(hardline, path.map(printVariant(print), 'items')); + return join(hardline, path.map(print, 'items')); } } diff --git a/src/slang-nodes/YulValueCase.ts b/src/slang-nodes/YulValueCase.ts index 76ed81653..7a8c43c18 100644 --- a/src/slang-nodes/YulValueCase.ts +++ b/src/slang-nodes/YulValueCase.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulLiteral } from './YulLiteral.js'; import { YulBlock } from './YulBlock.js'; @@ -12,25 +12,20 @@ import type { AstNode } from './types.d.ts'; export class YulValueCase extends SlangNode { readonly kind = NonterminalKind.YulValueCase; - value: YulLiteral; + value: YulLiteral['variant']; body: YulBlock; constructor(ast: ast.YulValueCase, options: ParserOptions) { super(ast); - this.value = new YulLiteral(ast.value, options); + this.value = extractVariant(new YulLiteral(ast.value, options)); this.body = new YulBlock(ast.body, options); this.updateMetadata(this.value, this.body); } print(path: AstPath, print: PrintFunction): Doc { - return [ - 'case ', - path.call(printVariant(print), 'value'), - ' ', - path.call(print, 'body') - ]; + return ['case ', path.call(print, 'value'), ' ', path.call(print, 'body')]; } } diff --git a/src/slang-nodes/YulVariableAssignmentStatement.ts b/src/slang-nodes/YulVariableAssignmentStatement.ts index 55551bc65..ad6defd20 100644 --- a/src/slang-nodes/YulVariableAssignmentStatement.ts +++ b/src/slang-nodes/YulVariableAssignmentStatement.ts @@ -1,6 +1,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulPaths } from './YulPaths.js'; import { YulAssignmentOperator } from './YulAssignmentOperator.js'; @@ -18,7 +19,7 @@ export class YulVariableAssignmentStatement extends SlangNode { variables: YulPaths; - assignment: YulAssignmentOperator; + assignment: YulAssignmentOperator['variant']; expression: YulExpression; @@ -29,7 +30,7 @@ export class YulVariableAssignmentStatement extends SlangNode { super(ast); this.variables = new YulPaths(ast.variables); - this.assignment = new YulAssignmentOperator(ast.assignment); + this.assignment = extractVariant(new YulAssignmentOperator(ast.assignment)); this.expression = new YulExpression(ast.expression, options); this.updateMetadata(this.variables, this.assignment, this.expression); @@ -41,7 +42,7 @@ export class YulVariableAssignmentStatement extends SlangNode { ): Doc { return join(' ', [ path.call(print, 'variables'), - path.call(printVariant(print), 'assignment'), + path.call(print, 'assignment'), path.call(printVariant(print), 'expression') ]); } diff --git a/src/slang-nodes/YulVariableDeclarationValue.ts b/src/slang-nodes/YulVariableDeclarationValue.ts index e6bffbfe1..c3eef5859 100644 --- a/src/slang-nodes/YulVariableDeclarationValue.ts +++ b/src/slang-nodes/YulVariableDeclarationValue.ts @@ -1,5 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulAssignmentOperator } from './YulAssignmentOperator.js'; import { YulExpression } from './YulExpression.js'; @@ -12,7 +13,7 @@ import type { AstNode } from './types.d.ts'; export class YulVariableDeclarationValue extends SlangNode { readonly kind = NonterminalKind.YulVariableDeclarationValue; - assignment: YulAssignmentOperator; + assignment: YulAssignmentOperator['variant']; expression: YulExpression; @@ -22,7 +23,7 @@ export class YulVariableDeclarationValue extends SlangNode { ) { super(ast); - this.assignment = new YulAssignmentOperator(ast.assignment); + this.assignment = extractVariant(new YulAssignmentOperator(ast.assignment)); this.expression = new YulExpression(ast.expression, options); this.updateMetadata(this.assignment, this.expression); @@ -30,7 +31,7 @@ export class YulVariableDeclarationValue extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return [ - path.call(printVariant(print), 'assignment'), + path.call(print, 'assignment'), ' ', path.call(printVariant(print), 'expression') ]; diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts index 831518b7a..44f0549e0 100644 --- a/src/slangPrinter.ts +++ b/src/slangPrinter.ts @@ -36,6 +36,10 @@ import type { UsingTarget } from './slang-nodes/UsingTarget.js'; import type { VariableDeclarationType } from './slang-nodes/VariableDeclarationType.js'; import type { VersionExpression } from './slang-nodes/VersionExpression.js'; import type { VersionLiteral } from './slang-nodes/VersionLiteral.js'; +import type { YulAssignmentOperator } from './slang-nodes/YulAssignmentOperator.js'; +import type { YulLiteral } from './slang-nodes/YulLiteral.js'; +import type { YulStackAssignmentOperator } from './slang-nodes/YulStackAssignmentOperator.js'; +import type { YulSwitchCase } from './slang-nodes/YulSwitchCase.js'; function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean { // Prettier sets SourceUnit's comments to undefined after assigning comments @@ -120,6 +124,10 @@ function genericPrint( | VariableDeclarationType | VersionExpression | VersionLiteral + | YulAssignmentOperator + | YulLiteral + | YulStackAssignmentOperator + | YulSwitchCase > >, options: ParserOptions, From c0b28b094fde4428069fd31474bd431723fdfe7e Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 17 Sep 2025 02:33:16 +0300 Subject: [PATCH 8/9] removing `YulExpression` from the AST tree --- src/slang-nodes/YulArguments.ts | 10 ++++++---- src/slang-nodes/YulExpression.ts | 4 ++-- src/slang-nodes/YulForStatement.ts | 8 ++++---- src/slang-nodes/YulFunctionCallExpression.ts | 8 ++++---- src/slang-nodes/YulIfStatement.ts | 8 ++++---- src/slang-nodes/YulStatement.ts | 5 +++-- src/slang-nodes/YulSwitchStatement.ts | 10 ++++++---- src/slang-nodes/YulVariableAssignmentStatement.ts | 9 +++++---- src/slang-nodes/YulVariableDeclarationValue.ts | 9 +++++---- src/slangPrinter.ts | 2 ++ 10 files changed, 41 insertions(+), 32 deletions(-) diff --git a/src/slang-nodes/YulArguments.ts b/src/slang-nodes/YulArguments.ts index 20e701a2d..1309f3f1b 100644 --- a/src/slang-nodes/YulArguments.ts +++ b/src/slang-nodes/YulArguments.ts @@ -1,6 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { printSeparatedList } from '../slang-printers/print-separated-list.js'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulExpression } from './YulExpression.js'; @@ -12,15 +12,17 @@ import type { AstNode } from './types.d.ts'; export class YulArguments extends SlangNode { readonly kind = NonterminalKind.YulArguments; - items: YulExpression[]; + items: YulExpression['variant'][]; constructor(ast: ast.YulArguments, options: ParserOptions) { super(ast, true); - this.items = ast.items.map((item) => new YulExpression(item, options)); + this.items = ast.items.map((item) => + extractVariant(new YulExpression(item, options)) + ); } print(path: AstPath, print: PrintFunction): Doc { - return printSeparatedList(path.map(printVariant(print), 'items')); + return printSeparatedList(path.map(print, 'items')); } } diff --git a/src/slang-nodes/YulExpression.ts b/src/slang-nodes/YulExpression.ts index 2c6daae25..66de092bd 100644 --- a/src/slang-nodes/YulExpression.ts +++ b/src/slang-nodes/YulExpression.ts @@ -1,7 +1,7 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { extractVariant } from '../slang-utils/extract-variant.js'; -import { PolymorphicNode } from './PolymorphicNode.js'; +import { SlangNode } from './SlangNode.js'; import { YulFunctionCallExpression } from './YulFunctionCallExpression.js'; import { YulLiteral } from './YulLiteral.js'; import { YulPath } from './YulPath.js'; @@ -26,7 +26,7 @@ function createNonterminalVariant( return exhaustiveCheck; } -export class YulExpression extends PolymorphicNode { +export class YulExpression extends SlangNode { readonly kind = NonterminalKind.YulExpression; variant: YulFunctionCallExpression | YulLiteral['variant'] | YulPath; diff --git a/src/slang-nodes/YulForStatement.ts b/src/slang-nodes/YulForStatement.ts index c77d88e17..1fdeb2b85 100644 --- a/src/slang-nodes/YulForStatement.ts +++ b/src/slang-nodes/YulForStatement.ts @@ -1,6 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulBlock } from './YulBlock.js'; import { YulExpression } from './YulExpression.js'; @@ -17,7 +17,7 @@ export class YulForStatement extends SlangNode { initialization: YulBlock; - condition: YulExpression; + condition: YulExpression['variant']; iterator: YulBlock; @@ -27,7 +27,7 @@ export class YulForStatement extends SlangNode { super(ast); this.initialization = new YulBlock(ast.initialization, options); - this.condition = new YulExpression(ast.condition, options); + this.condition = extractVariant(new YulExpression(ast.condition, options)); this.iterator = new YulBlock(ast.iterator, options); this.body = new YulBlock(ast.body, options); @@ -43,7 +43,7 @@ export class YulForStatement extends SlangNode { return join(' ', [ 'for', path.call(print, 'initialization'), - path.call(printVariant(print), 'condition'), + path.call(print, 'condition'), path.call(print, 'iterator'), path.call(print, 'body') ]); diff --git a/src/slang-nodes/YulFunctionCallExpression.ts b/src/slang-nodes/YulFunctionCallExpression.ts index 799d791ad..6b5f5bc4f 100644 --- a/src/slang-nodes/YulFunctionCallExpression.ts +++ b/src/slang-nodes/YulFunctionCallExpression.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulExpression } from './YulExpression.js'; import { YulArguments } from './YulArguments.js'; @@ -12,7 +12,7 @@ import type { AstNode } from './types.d.ts'; export class YulFunctionCallExpression extends SlangNode { readonly kind = NonterminalKind.YulFunctionCallExpression; - operand: YulExpression; + operand: YulExpression['variant']; arguments: YulArguments; @@ -22,7 +22,7 @@ export class YulFunctionCallExpression extends SlangNode { ) { super(ast); - this.operand = new YulExpression(ast.operand, options); + this.operand = extractVariant(new YulExpression(ast.operand, options)); this.arguments = new YulArguments(ast.arguments, options); this.updateMetadata(this.operand, this.arguments); @@ -30,7 +30,7 @@ export class YulFunctionCallExpression extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return [ - path.call(printVariant(print), 'operand'), + path.call(print, 'operand'), '(', path.call(print, 'arguments'), ')' diff --git a/src/slang-nodes/YulIfStatement.ts b/src/slang-nodes/YulIfStatement.ts index 8298ea655..5be71f59e 100644 --- a/src/slang-nodes/YulIfStatement.ts +++ b/src/slang-nodes/YulIfStatement.ts @@ -1,5 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulExpression } from './YulExpression.js'; import { YulBlock } from './YulBlock.js'; @@ -12,14 +12,14 @@ import type { AstNode } from './types.d.ts'; export class YulIfStatement extends SlangNode { readonly kind = NonterminalKind.YulIfStatement; - condition: YulExpression; + condition: YulExpression['variant']; body: YulBlock; constructor(ast: ast.YulIfStatement, options: ParserOptions) { super(ast); - this.condition = new YulExpression(ast.condition, options); + this.condition = extractVariant(new YulExpression(ast.condition, options)); this.body = new YulBlock(ast.body, options); this.updateMetadata(this.condition, this.body); @@ -28,7 +28,7 @@ export class YulIfStatement extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return [ 'if ', - path.call(printVariant(print), 'condition'), + path.call(print, 'condition'), ' ', path.call(print, 'body') ]; diff --git a/src/slang-nodes/YulStatement.ts b/src/slang-nodes/YulStatement.ts index efe91c786..6d711899c 100644 --- a/src/slang-nodes/YulStatement.ts +++ b/src/slang-nodes/YulStatement.ts @@ -1,5 +1,6 @@ import * as ast from '@nomicfoundation/slang/ast'; import { NonterminalKind } from '@nomicfoundation/slang/cst'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulBlock } from './YulBlock.js'; import { YulFunctionDefinition } from './YulFunctionDefinition.js'; @@ -59,7 +60,7 @@ function createNonterminalVariant( return new YulLabel(variant); } if (variant instanceof ast.YulExpression) { - return new YulExpression(variant, options); + return extractVariant(new YulExpression(variant, options)); } const exhaustiveCheck: never = variant; return exhaustiveCheck; @@ -81,7 +82,7 @@ export class YulStatement extends SlangNode { | YulBreakStatement | YulContinueStatement | YulLabel - | YulExpression; + | YulExpression['variant']; constructor(ast: ast.YulStatement, options: ParserOptions) { super(ast); diff --git a/src/slang-nodes/YulSwitchStatement.ts b/src/slang-nodes/YulSwitchStatement.ts index f131eb55a..319fa26be 100644 --- a/src/slang-nodes/YulSwitchStatement.ts +++ b/src/slang-nodes/YulSwitchStatement.ts @@ -1,6 +1,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; -import { printVariant } from '../slang-printers/print-variant.js'; +import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulExpression } from './YulExpression.js'; import { YulSwitchCases } from './YulSwitchCases.js'; @@ -15,14 +15,16 @@ const { hardline } = doc.builders; export class YulSwitchStatement extends SlangNode { readonly kind = NonterminalKind.YulSwitchStatement; - expression: YulExpression; + expression: YulExpression['variant']; cases: YulSwitchCases; constructor(ast: ast.YulSwitchStatement, options: ParserOptions) { super(ast); - this.expression = new YulExpression(ast.expression, options); + this.expression = extractVariant( + new YulExpression(ast.expression, options) + ); this.cases = new YulSwitchCases(ast.cases, options); this.updateMetadata(this.expression, this.cases); @@ -31,7 +33,7 @@ export class YulSwitchStatement extends SlangNode { print(path: AstPath, print: PrintFunction): Doc { return [ 'switch ', - path.call(printVariant(print), 'expression'), + path.call(print, 'expression'), hardline, path.call(print, 'cases') ]; diff --git a/src/slang-nodes/YulVariableAssignmentStatement.ts b/src/slang-nodes/YulVariableAssignmentStatement.ts index ad6defd20..df314159a 100644 --- a/src/slang-nodes/YulVariableAssignmentStatement.ts +++ b/src/slang-nodes/YulVariableAssignmentStatement.ts @@ -1,6 +1,5 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; import { doc } from 'prettier'; -import { printVariant } from '../slang-printers/print-variant.js'; import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulPaths } from './YulPaths.js'; @@ -21,7 +20,7 @@ export class YulVariableAssignmentStatement extends SlangNode { assignment: YulAssignmentOperator['variant']; - expression: YulExpression; + expression: YulExpression['variant']; constructor( ast: ast.YulVariableAssignmentStatement, @@ -31,7 +30,9 @@ export class YulVariableAssignmentStatement extends SlangNode { this.variables = new YulPaths(ast.variables); this.assignment = extractVariant(new YulAssignmentOperator(ast.assignment)); - this.expression = new YulExpression(ast.expression, options); + this.expression = extractVariant( + new YulExpression(ast.expression, options) + ); this.updateMetadata(this.variables, this.assignment, this.expression); } @@ -43,7 +44,7 @@ export class YulVariableAssignmentStatement extends SlangNode { return join(' ', [ path.call(print, 'variables'), path.call(print, 'assignment'), - path.call(printVariant(print), 'expression') + path.call(print, 'expression') ]); } } diff --git a/src/slang-nodes/YulVariableDeclarationValue.ts b/src/slang-nodes/YulVariableDeclarationValue.ts index c3eef5859..9a249df21 100644 --- a/src/slang-nodes/YulVariableDeclarationValue.ts +++ b/src/slang-nodes/YulVariableDeclarationValue.ts @@ -1,5 +1,4 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst'; -import { printVariant } from '../slang-printers/print-variant.js'; import { extractVariant } from '../slang-utils/extract-variant.js'; import { SlangNode } from './SlangNode.js'; import { YulAssignmentOperator } from './YulAssignmentOperator.js'; @@ -15,7 +14,7 @@ export class YulVariableDeclarationValue extends SlangNode { assignment: YulAssignmentOperator['variant']; - expression: YulExpression; + expression: YulExpression['variant']; constructor( ast: ast.YulVariableDeclarationValue, @@ -24,7 +23,9 @@ export class YulVariableDeclarationValue extends SlangNode { super(ast); this.assignment = extractVariant(new YulAssignmentOperator(ast.assignment)); - this.expression = new YulExpression(ast.expression, options); + this.expression = extractVariant( + new YulExpression(ast.expression, options) + ); this.updateMetadata(this.assignment, this.expression); } @@ -33,7 +34,7 @@ export class YulVariableDeclarationValue extends SlangNode { return [ path.call(print, 'assignment'), ' ', - path.call(printVariant(print), 'expression') + path.call(print, 'expression') ]; } } diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts index 44f0549e0..0641bdc5b 100644 --- a/src/slangPrinter.ts +++ b/src/slangPrinter.ts @@ -40,6 +40,7 @@ import type { YulAssignmentOperator } from './slang-nodes/YulAssignmentOperator. import type { YulLiteral } from './slang-nodes/YulLiteral.js'; import type { YulStackAssignmentOperator } from './slang-nodes/YulStackAssignmentOperator.js'; import type { YulSwitchCase } from './slang-nodes/YulSwitchCase.js'; +import type { YulExpression } from './slang-nodes/YulExpression.js'; function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean { // Prettier sets SourceUnit's comments to undefined after assigning comments @@ -128,6 +129,7 @@ function genericPrint( | YulLiteral | YulStackAssignmentOperator | YulSwitchCase + | YulExpression > >, options: ParserOptions, From 8d8039ab9e215fa56bd87d73cabf489f6dd5988e Mon Sep 17 00:00:00 2001 From: Klaus Date: Wed, 17 Sep 2025 02:38:05 +0300 Subject: [PATCH 9/9] cleanup unused code --- src/slang-nodes/PolymorphicNode.ts | 17 ------ src/slang-printers/print-variant.ts | 13 ----- src/slangPrinter.ts | 86 ++--------------------------- 3 files changed, 6 insertions(+), 110 deletions(-) delete mode 100644 src/slang-nodes/PolymorphicNode.ts delete mode 100644 src/slang-printers/print-variant.ts diff --git a/src/slang-nodes/PolymorphicNode.ts b/src/slang-nodes/PolymorphicNode.ts deleted file mode 100644 index 2ff2cbbcf..000000000 --- a/src/slang-nodes/PolymorphicNode.ts +++ /dev/null @@ -1,17 +0,0 @@ -import { SlangNode } from './SlangNode.js'; - -import type { AstPath, Doc } from 'prettier'; -import type { PrintFunction, SlangAstNode } from '../types.d.ts'; -import type { StrictPolymorphicNode } from './types.d.ts'; - -export abstract class PolymorphicNode extends SlangNode { - abstract variant: StrictPolymorphicNode['variant']; - - constructor(ast: SlangAstNode) { - super(ast); - } - - print(path: AstPath, print: PrintFunction): Doc { - return path.call(print, 'variant'); - } -} diff --git a/src/slang-printers/print-variant.ts b/src/slang-printers/print-variant.ts deleted file mode 100644 index 9499147b3..000000000 --- a/src/slang-printers/print-variant.ts +++ /dev/null @@ -1,13 +0,0 @@ -import type { AstPath, Doc } from 'prettier'; -import type { PrintFunction } from '../types.d.ts'; -import type { StrictPolymorphicNode } from '../slang-nodes/types.d.ts'; - -export const printVariant = - (print: PrintFunction) => - (path: AstPath): Doc => { - const node = path.node; - if (!node) return ''; - return node.comments && node.comments.length > 0 - ? print(path) - : path.call(print, 'variant'); - }; diff --git a/src/slangPrinter.ts b/src/slangPrinter.ts index 0641bdc5b..295d9a07c 100644 --- a/src/slangPrinter.ts +++ b/src/slangPrinter.ts @@ -2,45 +2,12 @@ import { isBlockComment } from './slang-utils/is-comment.js'; import { locEnd, locStart } from './slang-utils/loc.js'; import type { AstPath, Doc, ParserOptions } from 'prettier'; -import type { AstNode, StrictAstNode } from './slang-nodes/types.d.ts'; +import type { + AstNode, + StrictAstNode, + StrictPolymorphicNode +} from './slang-nodes/types.d.ts'; import type { PrintFunction } from './types.d.ts'; -import type { ArgumentsDeclaration } from './slang-nodes/ArgumentsDeclaration.js'; -import type { ConstructorAttribute } from './slang-nodes/ConstructorAttribute.js'; -import type { FallbackFunctionAttribute } from './slang-nodes/FallbackFunctionAttribute.js'; -import type { FunctionAttribute } from './slang-nodes/FunctionAttribute.js'; -import type { FunctionTypeAttribute } from './slang-nodes/FunctionTypeAttribute.js'; -import type { ModifierAttribute } from './slang-nodes/ModifierAttribute.js'; -import type { ReceiveFunctionAttribute } from './slang-nodes/ReceiveFunctionAttribute.js'; -import type { StateVariableAttribute } from './slang-nodes/StateVariableAttribute.js'; -import type { UnnamedFunctionAttribute } from './slang-nodes/UnnamedFunctionAttribute.js'; -import type { ContractMember } from './slang-nodes/ContractMember.js'; -import type { SourceUnitMember } from './slang-nodes/SourceUnitMember.js'; -import type { Statement } from './slang-nodes/Statement.js'; -import type { YulStatement } from './slang-nodes/YulStatement.js'; -import type { ContractSpecifier } from './slang-nodes/ContractSpecifier.js'; -import type { ElementaryType } from './slang-nodes/ElementaryType.js'; -import type { ExperimentalFeature } from './slang-nodes/ExperimentalFeature.js'; -import type { Expression } from './slang-nodes/Expression.js'; -import type { ForStatementInitialization } from './slang-nodes/ForStatementInitialization.js'; -import type { ForStatementCondition } from './slang-nodes/ForStatementCondition.js'; -import type { FunctionBody } from './slang-nodes/FunctionBody.js'; -import type { FunctionName } from './slang-nodes/FunctionName.js'; -import type { ImportClause } from './slang-nodes/ImportClause.js'; -import type { MappingKeyType } from './slang-nodes/MappingKeyType.js'; -import type { Pragma } from './slang-nodes/Pragma.js'; -import type { StringExpression } from './slang-nodes/StringExpression.js'; -import type { TupleMember } from './slang-nodes/TupleMember.js'; -import type { TypeName } from './slang-nodes/TypeName.js'; -import type { UsingClause } from './slang-nodes/UsingClause.js'; -import type { UsingTarget } from './slang-nodes/UsingTarget.js'; -import type { VariableDeclarationType } from './slang-nodes/VariableDeclarationType.js'; -import type { VersionExpression } from './slang-nodes/VersionExpression.js'; -import type { VersionLiteral } from './slang-nodes/VersionLiteral.js'; -import type { YulAssignmentOperator } from './slang-nodes/YulAssignmentOperator.js'; -import type { YulLiteral } from './slang-nodes/YulLiteral.js'; -import type { YulStackAssignmentOperator } from './slang-nodes/YulStackAssignmentOperator.js'; -import type { YulSwitchCase } from './slang-nodes/YulSwitchCase.js'; -import type { YulExpression } from './slang-nodes/YulExpression.js'; function hasNodeIgnoreComment({ comments }: StrictAstNode): boolean { // Prettier sets SourceUnit's comments to undefined after assigning comments @@ -90,48 +57,7 @@ function ignoreComments(path: AstPath): void { // Nodes take care of undefined and string properties so we can restrict path // to AstPath function genericPrint( - path: AstPath< - Exclude< - StrictAstNode, - | ArgumentsDeclaration - | ConstructorAttribute - | FallbackFunctionAttribute - | FunctionAttribute - | FunctionTypeAttribute - | ModifierAttribute - | ReceiveFunctionAttribute - | StateVariableAttribute - | UnnamedFunctionAttribute - | ContractMember - | SourceUnitMember - | Statement - | YulStatement - | ContractSpecifier - | ElementaryType - | ExperimentalFeature - | Expression - | ForStatementInitialization - | ForStatementCondition - | FunctionBody - | FunctionName - | ImportClause - | MappingKeyType - | Pragma - | StringExpression - | TupleMember - | TypeName - | UsingClause - | UsingTarget - | VariableDeclarationType - | VersionExpression - | VersionLiteral - | YulAssignmentOperator - | YulLiteral - | YulStackAssignmentOperator - | YulSwitchCase - | YulExpression - > - >, + path: AstPath>, options: ParserOptions, print: PrintFunction ): Doc {