removing Expression from the AST tree

src/slang-comments/handlers/add-collection-first-comment.ts

@@ -1,11 +1,11 @@
 import { util } from 'prettier';
 
-import type { Comment, NodeCollection } from '../../slang-nodes/types.d.ts';
+import type { Comment, StrictCollection } from '../../slang-nodes/types.d.ts';
 
 const { addDanglingComment, addLeadingComment } = util;
 
 export default function addCollectionFirstComment(
-  node: NodeCollection,
+  node: StrictCollection,
   comment: Comment
 ): void {
   if (node.items.length === 0) {

src/slang-comments/handlers/add-collection-last-comment.ts

@@ -1,11 +1,11 @@
 import { util } from 'prettier';
 
-import type { Comment, NodeCollection } from '../../slang-nodes/types.d.ts';
+import type { Comment, StrictCollection } from '../../slang-nodes/types.d.ts';
 
 const { addDanglingComment, addTrailingComment } = util;
 
 export default function addCollectionLastComment(
-  node: NodeCollection,
+  node: StrictCollection,
   comment: Comment
 ): void {
   if (node.items.length === 0) {

src/slang-nodes/AdditiveExpression.ts

@@ -2,6 +2,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printBinaryOperation } from '../slang-printers/print-binary-operation.js';
 import { createHugFunction } from '../slang-utils/create-hug-function.js';
 import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
@@ -28,18 +29,20 @@ const printAdditiveExpression = printBinaryOperation(
 export class AdditiveExpression extends SlangNode {
   readonly kind = NonterminalKind.AdditiveExpression;
 
-  leftOperand: Expression;
+  leftOperand: Expression['variant'];
 
   operator: string;
 
-  rightOperand: Expression;
+  rightOperand: Expression['variant'];
 
   constructor(ast: ast.AdditiveExpression, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.leftOperand = new Expression(ast.leftOperand, options);
+    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();
-    this.rightOperand = new Expression(ast.rightOperand, options);
+    this.rightOperand = extractVariant(
+      new Expression(ast.rightOperand, options)
+    );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
 

src/slang-nodes/AndExpression.ts

@@ -1,5 +1,6 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printLogicalOperation } from '../slang-printers/print-logical-operation.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
@@ -11,18 +12,20 @@ import type { AstNode } from './types.d.ts';
 export class AndExpression extends SlangNode {
   readonly kind = NonterminalKind.AndExpression;
 
-  leftOperand: Expression;
+  leftOperand: Expression['variant'];
 
   operator: string;
 
-  rightOperand: Expression;
+  rightOperand: Expression['variant'];
 
   constructor(ast: ast.AndExpression, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.leftOperand = new Expression(ast.leftOperand, options);
+    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();
-    this.rightOperand = new Expression(ast.rightOperand, options);
+    this.rightOperand = extractVariant(
+      new Expression(ast.rightOperand, options)
+    );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
   }

src/slang-nodes/ArrayTypeName.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 { TypeName } from './TypeName.js';
 import { Expression } from './Expression.js';
@@ -14,14 +15,14 @@ export class ArrayTypeName extends SlangNode {
 
   operand: TypeName;
 
-  index?: Expression;
+  index?: Expression['variant'];
 
   constructor(ast: ast.ArrayTypeName, options: ParserOptions<AstNode>) {
     super(ast);
 
     this.operand = new TypeName(ast.operand, options);
     if (ast.index) {
-      this.index = new Expression(ast.index, options);
+      this.index = extractVariant(new Expression(ast.index, options));
     }
 
     this.updateMetadata(this.operand, this.index);
@@ -31,7 +32,7 @@ export class ArrayTypeName extends SlangNode {
     return [
       path.call(printVariant(print), 'operand'),
       '[',
-      path.call(printVariant(print), 'index'),
+      path.call(print, 'index'),
       ']'
     ];
   }

src/slang-nodes/ArrayValues.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 { Expression } from './Expression.js';
 
@@ -12,15 +12,17 @@ import type { AstNode } from './types.d.ts';
 export class ArrayValues extends SlangNode {
   readonly kind = NonterminalKind.ArrayValues;
 
-  items: Expression[];
+  items: Expression['variant'][];
 
   constructor(ast: ast.ArrayValues, options: ParserOptions<AstNode>) {
     super(ast, true);
 
-    this.items = ast.items.map((item) => new Expression(item, options));
+    this.items = ast.items.map((item) =>
+      extractVariant(new Expression(item, options))
+    );
   }
 
   print(path: AstPath<ArrayValues>, print: PrintFunction): Doc {
-    return printSeparatedList(path.map(printVariant(print), 'items'));
+    return printSeparatedList(path.map(print, 'items'));
   }
 }

src/slang-nodes/AssignmentExpression.ts

@@ -1,7 +1,7 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { isBinaryOperation } from '../slang-utils/is-binary-operation.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 { Expression } from './Expression.js';
 import { TerminalNode } from './TerminalNode.js';
@@ -14,31 +14,32 @@ import type { AstNode } from './types.d.ts';
 export class AssignmentExpression extends SlangNode {
   readonly kind = NonterminalKind.AssignmentExpression;
 
-  leftOperand: Expression;
+  leftOperand: Expression['variant'];
 
   operator: string;
 
-  rightOperand: Expression;
+  rightOperand: Expression['variant'];
 
   constructor(ast: ast.AssignmentExpression, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.leftOperand = new Expression(ast.leftOperand, options);
+    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();
-    this.rightOperand = new Expression(ast.rightOperand, options);
+    this.rightOperand = extractVariant(
+      new Expression(ast.rightOperand, options)
+    );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
   }
 
   print(path: AstPath<AssignmentExpression>, print: PrintFunction): Doc {
-    const rightOperandVariant = this.rightOperand.variant;
     return [
-      path.call(printVariant(print), 'leftOperand'),
+      path.call(print, 'leftOperand'),
       ` ${this.operator}`,
       printIndentedGroupOrSpacedDocument(
-        path.call(printVariant(print), 'rightOperand'),
-        !(rightOperandVariant instanceof TerminalNode) &&
-          isBinaryOperation(rightOperandVariant)
+        path.call(print, 'rightOperand'),
+        !(this.rightOperand instanceof TerminalNode) &&
+          isBinaryOperation(this.rightOperand)
       )
     ];
   }

src/slang-nodes/BitwiseAndExpression.ts

@@ -2,6 +2,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printBinaryOperation } from '../slang-printers/print-binary-operation.js';
 import { createHugFunction } from '../slang-utils/create-hug-function.js';
 import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
@@ -24,18 +25,20 @@ const printBitwiseAndExpression = printBinaryOperation(
 export class BitwiseAndExpression extends SlangNode {
   readonly kind = NonterminalKind.BitwiseAndExpression;
 
-  leftOperand: Expression;
+  leftOperand: Expression['variant'];
 
   operator: string;
 
-  rightOperand: Expression;
+  rightOperand: Expression['variant'];
 
   constructor(ast: ast.BitwiseAndExpression, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.leftOperand = new Expression(ast.leftOperand, options);
+    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();
-    this.rightOperand = new Expression(ast.rightOperand, options);
+    this.rightOperand = extractVariant(
+      new Expression(ast.rightOperand, options)
+    );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
 

src/slang-nodes/BitwiseOrExpression.ts

@@ -2,6 +2,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printBinaryOperation } from '../slang-printers/print-binary-operation.js';
 import { createHugFunction } from '../slang-utils/create-hug-function.js';
 import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
@@ -34,18 +35,20 @@ const printBitwiseOrExpression = printBinaryOperation(
 export class BitwiseOrExpression extends SlangNode {
   readonly kind = NonterminalKind.BitwiseOrExpression;
 
-  leftOperand: Expression;
+  leftOperand: Expression['variant'];
 
   operator: string;
 
-  rightOperand: Expression;
+  rightOperand: Expression['variant'];
 
   constructor(ast: ast.BitwiseOrExpression, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.leftOperand = new Expression(ast.leftOperand, options);
+    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();
-    this.rightOperand = new Expression(ast.rightOperand, options);
+    this.rightOperand = extractVariant(
+      new Expression(ast.rightOperand, options)
+    );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
 

src/slang-nodes/BitwiseXorExpression.ts

@@ -2,6 +2,7 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { printBinaryOperation } from '../slang-printers/print-binary-operation.js';
 import { createHugFunction } from '../slang-utils/create-hug-function.js';
 import { createKindCheckFunction } from '../slang-utils/create-kind-check-function.js';
+import { extractVariant } from '../slang-utils/extract-variant.js';
 import { SlangNode } from './SlangNode.js';
 import { Expression } from './Expression.js';
 
@@ -24,18 +25,20 @@ const printBitwiseXorExpression = printBinaryOperation(
 export class BitwiseXorExpression extends SlangNode {
   readonly kind = NonterminalKind.BitwiseXorExpression;
 
-  leftOperand: Expression;
+  leftOperand: Expression['variant'];
 
   operator: string;
 
-  rightOperand: Expression;
+  rightOperand: Expression['variant'];
 
   constructor(ast: ast.BitwiseXorExpression, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.leftOperand = new Expression(ast.leftOperand, options);
+    this.leftOperand = extractVariant(new Expression(ast.leftOperand, options));
     this.operator = ast.operator.unparse();
-    this.rightOperand = new Expression(ast.rightOperand, options);
+    this.rightOperand = extractVariant(
+      new Expression(ast.rightOperand, options)
+    );
 
     this.updateMetadata(this.leftOperand, this.rightOperand);
 

src/slang-nodes/CallOptionsExpression.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 { Expression } from './Expression.js';
 import { CallOptions } from './CallOptions.js';
@@ -12,25 +12,20 @@ import type { AstNode } from './types.d.ts';
 export class CallOptionsExpression extends SlangNode {
   readonly kind = NonterminalKind.CallOptionsExpression;
 
-  operand: Expression;
+  operand: Expression['variant'];
 
   options: CallOptions;
 
   constructor(ast: ast.CallOptionsExpression, options: ParserOptions<AstNode>) {
     super(ast);
 
-    this.operand = new Expression(ast.operand, options);
+    this.operand = extractVariant(new Expression(ast.operand, options));
     this.options = new CallOptions(ast.options, options);
 
     this.updateMetadata(this.operand, this.options);
   }
 
   print(path: AstPath<CallOptionsExpression>, print: PrintFunction): Doc {
-    return [
-      path.call(printVariant(print), 'operand'),
-      '{',
-      path.call(print, 'options'),
-      '}'
-    ];
+    return [path.call(print, 'operand'), '{', path.call(print, 'options'), '}'];
   }
 }