feat: expand public API exports and improve comment annotation

- Add CI triggers for feature branch
- Export commonly used Stmt, Expr, and Scalar node types from index
- Replace naive comment assignment with position-based annotation
  using binary search to attach comments to their nearest following node

Author: rainx

.github/workflows/ci.yml

@@ -2,7 +2,7 @@ name: CI
 
 on:
   push:
-    branches: [main]
+    branches: [main, feature/pure-typescript-port-of-php-parser]
   pull_request:
     branches: [main]
 

src/index.ts

@@ -40,11 +40,48 @@ export { CloningVisitor } from './node-visitor/cloning-visitor';
 // Token constants
 export * from './php-token';
 
-// Node types
+// Node types - base classes
 export { Expr } from './node/expr';
 export { Stmt } from './node/stmt';
 export { Scalar } from './node/scalar';
 export { Name, FullyQualified, Relative } from './node/name';
+
+// Stmt node types
+export { Namespace_ } from './node/stmt/namespace';
+export { Class_ } from './node/stmt/class';
+export { ClassLike } from './node/stmt/class-like';
+export { Interface_ } from './node/stmt/interface';
+export { Trait_ } from './node/stmt/trait';
+export { Enum_ } from './node/stmt/enum';
+export { ClassMethod } from './node/stmt/class-method';
+export { Property } from './node/stmt/property';
+export { ClassConst } from './node/stmt/class-const';
+export { Use_ } from './node/stmt/use';
+export { EnumCase } from './node/stmt/enum-case';
+export { TraitUse } from './node/stmt/trait-use';
+export { Function_ } from './node/stmt/function';
+export { Return_ } from './node/stmt/return';
+export { Expression } from './node/stmt/expression';
+
+// Expr node types
+export { Variable } from './node/expr/variable';
+export { Assign } from './node/expr/assign';
+export { FuncCall } from './node/expr/func-call';
+export { MethodCall } from './node/expr/method-call';
+export { StaticCall } from './node/expr/static-call';
+export { ClassConstFetch } from './node/expr/class-const-fetch';
+export { Array_ } from './node/expr/array';
+export { ArrayDimFetch } from './node/expr/array-dim-fetch';
+export { BinaryOp } from './node/expr/binary-op';
+export { Concat as BinaryOpConcat } from './node/expr/binary-op/concat';
+export { New_ } from './node/expr/new';
+export { Closure } from './node/expr/closure';
+export { ArrowFunction } from './node/expr/arrow-function';
+
+// Scalar node types
+export { String_ } from './node/scalar/string';
+export { Int_ } from './node/scalar/int';
+export { Float_ } from './node/scalar/float';
 export { Identifier, VarLikeIdentifier } from './node/identifier';
 export { Param } from './node/param';
 export { Arg } from './node/arg';

src/parser/php8.ts

@@ -328,7 +328,7 @@ export class Php8Parser implements Parser {
   // ─── Comment annotation ────────────────────────────────────────
 
   private annotateComments(stmts: Node[]): void {
-    // Collect all comments from the token stream and assign them to adjacent nodes
+    // Collect all comments from the token stream
     const comments: Comment[] = [];
     for (const token of this.tokens) {
       if (token.id === T.T_COMMENT) {
@@ -339,11 +339,73 @@ export class Php8Parser implements Parser {
           token.getEndLine(), token.getEndPos() - 1, 0));
       }
     }
-    // Simple approach: assign comments to the first statement
-    if (comments.length > 0 && stmts.length > 0) {
-      const firstNode = stmts[0];
-      if (firstNode && typeof firstNode.setAttribute === 'function') {
-        firstNode.setAttribute('comments', comments);
+
+    if (comments.length === 0) return;
+
+    // Collect all nodes in the AST with their file positions
+    const allNodes: Node[] = [];
+    this.collectAllNodes(stmts, allNodes);
+
+    // Sort nodes by startFilePos ascending
+    allNodes.sort((a, b) => a.getStartFilePos() - b.getStartFilePos());
+
+    // For each comment, find the node whose startFilePos comes after the comment ends
+    // and attach the comment to that node
+    const nodeComments = new Map<Node, Comment[]>();
+
+    for (const comment of comments) {
+      const commentEndPos = comment.getEndFilePos();
+      // Binary search for the first node with startFilePos > commentEndPos
+      let lo = 0;
+      let hi = allNodes.length;
+      while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (allNodes[mid].getStartFilePos() <= commentEndPos) {
+          lo = mid + 1;
+        } else {
+          hi = mid;
+        }
+      }
+      if (lo < allNodes.length) {
+        const targetNode = allNodes[lo];
+        if (!nodeComments.has(targetNode)) {
+          nodeComments.set(targetNode, []);
+        }
+        nodeComments.get(targetNode)!.push(comment);
+      }
+    }
+
+    // Assign collected comments to their respective nodes
+    for (const [node, nodeCommentList] of nodeComments) {
+      node.setAttribute('comments', nodeCommentList);
+    }
+  }
+
+  private collectAllNodes(nodes: Node | Node[], result: Node[]): void {
+    if (Array.isArray(nodes)) {
+      for (const node of nodes) {
+        this.collectAllNodes(node, result);
+      }
+      return;
+    }
+
+    const node = nodes;
+    if (!node || typeof node.getType !== 'function') return;
+
+    result.push(node);
+
+    for (const rawName of node.getSubNodeNames()) {
+      const name = (node as any)[rawName] !== undefined ? rawName : rawName + '_';
+      const subNode = (node as any)[name];
+      if (subNode === null || subNode === undefined) continue;
+      if (Array.isArray(subNode)) {
+        for (const item of subNode) {
+          if (item && typeof item === 'object' && typeof item.getType === 'function') {
+            this.collectAllNodes(item, result);
+          }
+        }
+      } else if (typeof subNode === 'object' && typeof subNode.getType === 'function') {
+        this.collectAllNodes(subNode, result);
       }
     }
   }