feat: generate NodeType as enum and mapping to interface for better type hints

Author: rainx

README.md

@@ -47,6 +47,7 @@ import {
   FullyQualifiedScalarString,
   FullyQualifiedStmtEcho,
   NodeRetrieverHelpers,
+  NodeType,
   NodeTypeInheritingFromNodeAbstract,
 } from '@rightcapital/php-parser';
 
@@ -68,7 +69,7 @@ console.log(rootNodes);
 const echoNode =
   NodeRetrieverHelpers.findNodeByNodeType<FullyQualifiedStmtEcho>(
     rootNodes,
-    'Stmt_Echo',
+    NodeType.Stmt_Echo,
   );
 
 // Get the specified node with type annotation
@@ -84,7 +85,7 @@ console.log(echoNode);
 const scalarStringNode =
   NodeRetrieverHelpers.findNodeByNodeType<FullyQualifiedScalarString>(
     echoNode!.exprs,
-    'Scalar_String',
+    NodeType.Scalar_String,
   );
 console.log(scalarStringNode?.value);
 // Hello

change/@rightcapital-php-parser-2e350fc2-57c1-4707-a4fd-476044d8eded.json

@@ -0,0 +1,7 @@
+{
+  "type": "minor",
+  "comment": "feat: generate NodeType as enum and mapping to interface for better type hints",
+  "packageName": "@rightcapital/php-parser",
+  "email": "[email protected]",
+  "dependentChangeType": "patch"
+}

src/php-parser/helpers/node-retriever-helpers.ts

@@ -9,7 +9,10 @@ import type { Namespace_ } from '../types/node/stmt/namespace';
 import type { Property } from '../types/node/stmt/property';
 import type { Return_ } from '../types/node/stmt/return';
 import type { Use_ } from '../types/node/stmt/use';
-import type { NodeTypeInheritingFromNodeAbstract } from '../types/types';
+import {
+  NodeType,
+  type NodeTypeInheritingFromNodeAbstract,
+} from '../types/types';
 
 export type IUseFullQualifiedNameParts = string[];
 export type IUses = {
@@ -37,11 +40,14 @@ export class NodeRetrieverHelpers {
   ): Class_ {
     const namespaceNode = NodeRetrieverHelpers.findNodeByNodeType<Namespace_>(
       rootNode as INode[],
-      'Stmt_Namespace',
+      NodeType.Stmt_Namespace,
     );
 
     if (namespaceNode?.stmts) {
-      return this.findNodeByNodeType<Class_>(namespaceNode.stmts, 'Stmt_Class');
+      return this.findNodeByNodeType<Class_>(
+        namespaceNode.stmts,
+        NodeType.Stmt_Class,
+      );
     }
 
     return undefined;
@@ -56,7 +62,7 @@ export class NodeRetrieverHelpers {
     if (classNode.stmts) {
       return this.filterNodeByNodeType<Property>(
         classNode.stmts,
-        'Stmt_Property',
+        NodeType.Stmt_Property,
       )
         .filter(
           /**
@@ -113,12 +119,12 @@ export class NodeRetrieverHelpers {
   ): IUses {
     const namespaceNode = NodeRetrieverHelpers.findNodeByNodeType<Namespace_>(
       rootNode,
-      'Stmt_Namespace',
+      NodeType.Stmt_Namespace,
     );
 
     if (namespaceNode?.stmts) {
       return Object.fromEntries(
-        this.filterNodeByNodeType<Use_>(namespaceNode.stmts, 'Stmt_Use')
+        this.filterNodeByNodeType<Use_>(namespaceNode.stmts, NodeType.Stmt_Use)
           .map((useNode) => useNode.uses[0].name.parts)
           .map((parts) => [parts.slice(-1), parts]),
       ) as IUses;
@@ -133,7 +139,7 @@ export class NodeRetrieverHelpers {
     if (classNode.stmts) {
       const classMethodNodes = this.filterNodeByNodeType<ClassMethod>(
         classNode.stmts,
-        'Stmt_ClassMethod',
+        NodeType.Stmt_ClassMethod,
       );
 
       const getTypeMethodNode = classMethodNodes.find(
@@ -143,7 +149,7 @@ export class NodeRetrieverHelpers {
       if (getTypeMethodNode) {
         const returnNode = this.findNodeByNodeType<Return_>(
           getTypeMethodNode.stmts,
-          'Stmt_Return',
+          NodeType.Stmt_Return,
         );
 
         if (returnNode) {

src/php-parser/helpers/type-generation-helpers.ts

@@ -1,5 +1,5 @@
 import { join } from 'path';
-import type { ICliContext } from '../generate-types';
+import type { ICliContext, IContextNodeItem } from '../generate-types';
 
 export class TypeGenerationHelpers {
   public static getGroupedTypeNameForNode(nodeName: string) {
@@ -48,6 +48,41 @@ ${importNodeNamesPart}
 ${combinationTypesPart}
 
 ${exportNodeNamesPart}
+
+${TypeGenerationHelpers.generateNodeTypeEnum(cliContext)}
       `;
   }
+
+  public static generateNodeTypeEnum(cliContext: ICliContext): string {
+    const { allNodes } = cliContext;
+
+    const nodesThatHasNodeType: [string, IContextNodeItem][] = Object.values(
+      allNodes,
+    )
+      .filter((node) => node.nodeType !== undefined && node.nodeType !== '')
+      .map((node) => [node.nodeType, node]);
+    const nodeEnum = `export enum NodeType {
+${nodesThatHasNodeType
+  .map(([nodeType, _]) => {
+    return `  ${nodeType} = '${nodeType}',`;
+  })
+  .join('\n')}
+}
+`;
+
+    const nodeTypeToInterfaceMap = `
+export interface NodeTypeToInterfaceMap {
+${nodesThatHasNodeType
+  .map(([nodeType, node]) => {
+    return `  [NodeType.${nodeType}]: ${node.name};`;
+  })
+  .join('\n')}
+}
+    `;
+
+    return `
+${nodeEnum};
+${nodeTypeToInterfaceMap}
+`;
+  }
 }