updating StrictAstNode so we can remove an unneeded check and multiple also unneeded type castings

Author: Janther

src/slang-nodes/ConditionalExpression.ts

@@ -14,11 +14,11 @@ const { group, hardline, ifBreak, indent, line } = doc.builders;
 
 function experimentalTernaries(
   node: ConditionalExpression,
-  path: AstPath<ConditionalExpression>,
+  path: AstPath<StrictAstNode>,
   print: PrintFunction,
   { useTabs, tabWidth }: ParserOptions<AstNode>
 ): Doc {
-  const parent = path.parent as StrictAstNode;
+  const parent = path.parent!;
   const isNested = parent.kind === NonterminalKind.ConditionalExpression;
   const isNestedAsTrueExpression = isNested && parent.trueExpression === node;
   const falseExpressionVariantKind = node.falseExpression.kind;
@@ -77,16 +77,15 @@ function experimentalTernaries(
 }
 
 function traditionalTernaries(
-  path: AstPath<ConditionalExpression>,
+  path: AstPath<StrictAstNode>,
   print: PrintFunction
 ): Doc {
   return group([
     path.call(print, 'operand'),
     indent([
       // Nested trueExpression and falseExpression are always printed in a new
       // line
-      (path.parent as StrictAstNode).kind ===
-      NonterminalKind.ConditionalExpression
+      path.parent!.kind === NonterminalKind.ConditionalExpression
         ? hardline
         : line,
       '? ',

src/slang-nodes/TupleValues.ts

@@ -3,7 +3,6 @@ import { printSeparatedList } from '../slang-printers/print-separated-list.js';
 import { isBinaryOperation } from '../slang-utils/is-binary-operation.js';
 import { SlangNode } from './SlangNode.js';
 import { TupleValue } from './TupleValue.js';
-import { TerminalNode } from './TerminalNode.js';
 
 import type * as ast from '@nomicfoundation/slang/ast';
 import type { AstPath, Doc, ParserOptions } from 'prettier';
@@ -36,9 +35,7 @@ export class TupleValues extends SlangNode {
   print(path: AstPath<TupleValues>, print: PrintFunction): Doc {
     const singleExpression = this.getSingleExpression();
     const items = path.map(print, 'items');
-    return singleExpression &&
-      !(singleExpression instanceof TerminalNode) &&
-      isBinaryOperation(singleExpression)
+    return singleExpression && isBinaryOperation(singleExpression)
       ? items
       : printSeparatedList(items);
   }

src/slang-nodes/types.d.ts

@@ -240,6 +240,7 @@ export type LineComment = SingleLineComment | SingleLineNatSpecComment;
 export type Comment = BlockComment | LineComment;
 
 export type StrictAstNode =
+  | TerminalNode
   | SourceUnit
   | PragmaDirective
   | AbicoderPragma
@@ -494,6 +495,11 @@ export type BinaryOperation = Extract<
   }
 >;
 
+export type ChainableExpression =
+  | FunctionCallExpression
+  | IndexAccessExpression
+  | MemberAccessExpression;
+
 export type AstNode =
   | StrictAstNode
   | Comment

src/slang-printers/create-binary-operation-printer.ts

@@ -1,7 +1,6 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { doc } from 'prettier';
 import { isBinaryOperation } from '../slang-utils/is-binary-operation.js';
-import { TerminalNode } from '../slang-nodes/TerminalNode.js';
 
 import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type {
@@ -15,7 +14,7 @@ const { group, line } = doc.builders;
 
 function rightOperandPrint(
   { operator, leftOperand }: BinaryOperation,
-  path: AstPath<BinaryOperation>,
+  path: AstPath<StrictAstNode>,
   print: PrintFunction,
   options: ParserOptions<AstNode>
 ): Doc {
@@ -27,9 +26,9 @@ function rightOperandPrint(
 
   // If there's only a single binary expression, we want to create a group in
   // order to avoid having a small right part like -1 be on its own line.
-  const parent = path.parent as StrictAstNode;
+  const parent = path.parent!;
   const shouldGroup =
-    (leftOperand instanceof TerminalNode || !isBinaryOperation(leftOperand)) &&
+    !isBinaryOperation(leftOperand) &&
     (!isBinaryOperation(parent) ||
       parent.kind === NonterminalKind.AssignmentExpression);
 
@@ -38,17 +37,15 @@ function rightOperandPrint(
 
 export const createBinaryOperationPrinter =
   (
-    groupRulesBuilder: (
-      path: AstPath<BinaryOperation>
-    ) => (document: Doc) => Doc,
+    groupRulesBuilder: (path: AstPath<StrictAstNode>) => (document: Doc) => Doc,
     indentRulesBuilder: (
-      path: AstPath<BinaryOperation>,
+      path: AstPath<StrictAstNode>,
       options: ParserOptions<AstNode>
     ) => (document: Doc) => Doc
   ) =>
   (
     node: BinaryOperation,
-    path: AstPath<BinaryOperation>,
+    path: AstPath<StrictAstNode>,
     print: PrintFunction,
     options: ParserOptions<AstNode>
   ): Doc => {

src/slang-printers/print-binary-operation.ts

@@ -16,9 +16,9 @@ const { group, indent } = doc.builders;
 
 export const binaryGroupRulesBuilder =
   (shouldGroup: (node: BinaryOperation) => boolean) =>
-  (path: AstPath<BinaryOperation>) =>
+  (path: AstPath<StrictAstNode>) =>
   (document: Doc): Doc => {
-    const parent = path.parent as StrictAstNode;
+    const parent = path.parent!;
     if (!isBinaryOperation(parent)) return group(document);
     if (shouldGroup(parent)) return group(document);
     return document;
@@ -32,20 +32,19 @@ const isStatementWithoutIndentedOperation = createKindCheckFunction([
 
 export const shouldNotIndent = (
   node: StrictAstNode,
-  path: AstPath<BinaryOperation>,
+  path: AstPath<StrictAstNode>,
   index: number
 ): boolean =>
   isStatementWithoutIndentedOperation(node) ||
   (node.kind === NonterminalKind.ExpressionStatement &&
-    (path.getNode(index + 1) as StrictAstNode).kind ===
-      NonterminalKind.ForStatement);
+    path.getNode(index + 1)!.kind === NonterminalKind.ForStatement);
 
 export const binaryIndentRulesBuilder =
   (shouldIndent: (node: BinaryOperation) => boolean) =>
-  (path: AstPath<BinaryOperation>) =>
+  (path: AstPath<StrictAstNode>) =>
   (document: Doc): Doc => {
     for (let i = 1, node = path.node; ; i++) {
-      const parent = path.getNode(i) as StrictAstNode;
+      const parent = path.getNode(i)!;
       if (shouldNotIndent(parent, path, i)) break;
       if (!isBinaryOperation(parent)) return indent(document);
       if (shouldIndent(parent)) return indent(document);
@@ -59,7 +58,7 @@ export const printBinaryOperation = (
   shouldGroupAndIndent: (node: StrictAstNode) => boolean
 ): ((
   node: BinaryOperation,
-  path: AstPath<BinaryOperation>,
+  path: AstPath<StrictAstNode>,
   print: PrintFunction,
   options: ParserOptions<AstNode>
 ) => Doc) =>

src/slang-printers/print-logical-operation.ts

@@ -8,21 +8,17 @@ import {
 } from './print-binary-operation.js';
 
 import type { AstPath, Doc, ParserOptions } from 'prettier';
-import type {
-  AstNode,
-  BinaryOperation,
-  StrictAstNode
-} from '../slang-nodes/types.d.ts';
+import type { AstNode, StrictAstNode } from '../slang-nodes/types.d.ts';
 
 const { indent } = doc.builders;
 
 const logicalGroupRulesBuilder = binaryGroupRulesBuilder(() => false);
 
 const logicalIndentRulesBuilder =
-  (path: AstPath<BinaryOperation>, options: ParserOptions<AstNode>) =>
+  (path: AstPath<StrictAstNode>, options: ParserOptions<AstNode>) =>
   (document: Doc): Doc => {
     for (let i = 1, node = path.node; ; i++) {
-      const parent = path.getNode(i) as StrictAstNode;
+      const parent = path.getNode(i)!;
       if (shouldNotIndent(parent, path, i)) break;
       if (
         options.experimentalTernaries &&

src/slang-utils/create-hug-function.ts

@@ -2,7 +2,6 @@ import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { TupleExpression } from '../slang-nodes/TupleExpression.js';
 import { TupleValues } from '../slang-nodes/TupleValues.js';
 import { TupleValue } from '../slang-nodes/TupleValue.js';
-import { TerminalNode } from '../slang-nodes/TerminalNode.js';
 import { isBinaryOperation } from './is-binary-operation.js';
 
 import type { Expression } from '../slang-nodes/Expression.ts';
@@ -12,11 +11,7 @@ export function createHugFunction(
 ): (node: Expression['variant']) => Expression['variant'] {
   const operators = new Set(huggableOperators);
   return (node: Expression['variant']): Expression['variant'] => {
-    if (
-      !(node instanceof TerminalNode) &&
-      isBinaryOperation(node) &&
-      operators.has(node.operator)
-    ) {
+    if (isBinaryOperation(node) && operators.has(node.operator)) {
       const loc = node.loc;
       return Object.assign(
         Object.create(TupleExpression.prototype) as TupleExpression,

src/slang-utils/is-chainable-expression.ts

@@ -1,10 +1,13 @@
 import { NonterminalKind } from '@nomicfoundation/slang/cst';
 import { createKindCheckFunction } from './create-kind-check-function.js';
 
-import type { Expression } from '../slang-nodes/Expression.js';
+import type {
+  ChainableExpression,
+  StrictAstNode
+} from '../slang-nodes/types.js';
 
 export const isChainableExpression = createKindCheckFunction([
   NonterminalKind.FunctionCallExpression,
   NonterminalKind.IndexAccessExpression,
   NonterminalKind.MemberAccessExpression
-]) as (node: Expression['variant']) => boolean;
+]) as (node: StrictAstNode) => node is ChainableExpression;