fix several bugs in handler closures - schema generation now works correctly except one remaining edge case; and, method calls are no longer being incorrectly captured

Author: mathpirate

packages/html/src/jsx.d.ts

@@ -1763,8 +1763,8 @@ declare namespace CTDOM {
 
   export interface HTMLAttributes<T> extends AriaAttributes, DOMAttributes<T> {
     // CT extensions
-    "onClick"?: CellLike<HandlerEvent<unknown>>;
-    "onChange"?: CellLike<HandlerEvent<unknown>>;
+    "onClick"?: EventHandler<unknown>;
+    "onChange"?: EventHandler<unknown>;
     "children"?: RenderNode | undefined;
     // Allow React-isms
     "key"?: number;
@@ -2825,10 +2825,12 @@ interface CTThemeDef {
 
 type CTThemeInput = Partial<CTThemeDef> & Record<string, unknown>;
 
-type HandlerEvent<T> = {
+type CTEvent<T> = {
   detail: T;
 };
 
+type EventHandler<T> = CellLike<CTEvent<T>> | ((event?: CTEvent<T>) => void);
+
 // `Charm` is not a recipe type.
 type Charm = any;
 
@@ -2889,16 +2891,16 @@ interface CTPlaidLinkElement extends CTHTMLElement {}
 
 interface CTDraggableAttributes<T> extends CTHTMLAttributes<T> {
   "key"?: number;
-  "x"?: CellLike<HandlerEvent<any>>;
-  "y"?: CellLike<HandlerEvent<any>>;
+  "x"?: CellLike<CTEvent<any>>;
+  "y"?: CellLike<CTEvent<any>>;
   "hidden"?: Booleanish;
-  "onpositionchange"?: CellLike<HandlerEvent<any>>;
+  "onpositionchange"?: EventHandler<any>;
 }
 
 interface CTCanvasAttributes<T> extends CTHTMLAttributes<T> {
   "width"?: string | number;
   "height"?: string | number;
-  "onct-canvas-click"?: CellLike<HandlerEvent<any>>;
+  "onct-canvas-click"?: EventHandler<any>;
 }
 
 interface CTPlaidLinkAttributes<T> extends CTHTMLAttributes<T> {
@@ -2944,7 +2946,7 @@ interface CTAttachmentsBarAttributes<T> extends CTHTMLAttributes<T> {
 
 interface CTTagsAttributes<T> extends CTHTMLAttributes<T> {
   "tags"?: string[];
-  "onct-change"?: CellLike<HandlerEvent<any>>;
+  "onct-change"?: EventHandler<any>;
 }
 
 interface CTToolbarAttributes<T> extends CTHTMLAttributes<T> {
@@ -3017,7 +3019,7 @@ interface CTSendMessageAttributes<T> extends CTHTMLAttributes<T> {
   "value"?: any;
   "placeholder"?: string;
   "appearance"?: "rounded";
-  "onmessagesend"?: CellLike<HandlerEvent<{ message: string }>>;
+  "onmessagesend"?: EventHandler<{ message: string }>;
   "inline"?: Booleanish;
 }
 
@@ -3031,7 +3033,7 @@ interface CTScrollAttributes<T> extends CTHTMLAttributes<T> {
 interface CTOutlinerAttributes<T> extends CTHTMLAttributes<T> {
   "$value": CellLike<{ root: OutlinerNode }>;
   "$mentionable"?: CellLike<Charm[]>;
-  "oncharm-link-click"?: CellLike<HandlerEvent<{ charm: Cell<Charm> }>>;
+  "oncharm-link-click"?: EventHandler<{ charm: Cell<Charm> }>;
 }
 
 interface CTChatMessageAttributes<T> extends CTHTMLAttributes<T> {
@@ -3075,7 +3077,7 @@ interface CTListAttributes<T> extends CTHTMLAttributes<T> {
   /** setting this hides the 'add item' form built into the list */
   "readonly"?: boolean;
   "title"?: string;
-  "onct-remove-item"?: CellLike<HandlerEvent<{ item: CtListItem }>>;
+  "onct-remove-item"?: EventHandler<{ item: CtListItem }>;
 }
 
 interface CTListItemAttributes<T> extends CTHTMLAttributes<T> {
@@ -3150,17 +3152,15 @@ interface CTCheckboxAttributes<T> extends CTHTMLAttributes<T> {
   "indeterminate"?: boolean;
   "name"?: string;
   "value"?: string;
-  "onct-change"?: CellLike<HandlerEvent<any>>;
+  "onct-change"?: EventHandler<any>;
 }
 
 interface CTSelectAttributes<T> extends CTHTMLAttributes<T> {
   "$value": CellLike<any | any[]>;
   "items": { label: string; value: any }[];
   "multiple"?: boolean;
-  "onct-change"?: CellLike<
-    HandlerEvent<
-      { items: { label: string; value: any }[]; value: any | any[] }
-    >
+  "onct-change"?: EventHandler<
+    { items: { label: string; value: any }[]; value: any | any[] }
   >;
 }
 

packages/schema-generator/src/schema-generator.ts

@@ -612,6 +612,9 @@ export class SchemaGenerator implements ISchemaGenerator {
         return { type: "boolean" };
       case ts.SyntaxKind.NullKeyword:
         return { type: "null" };
+      case ts.SyntaxKind.NeverKeyword:
+        // Reject all values (never type can never occur)
+        return false as SchemaDefinition;
       case ts.SyntaxKind.UndefinedKeyword:
       case ts.SyntaxKind.VoidKeyword:
       case ts.SyntaxKind.AnyKeyword:

packages/ts-transformers/src/ast/dataflow.ts

@@ -4,6 +4,7 @@ import {
   getExpressionText,
   getMemberSymbol,
   isFunctionParameter,
+  isMethodCall,
 } from "./utils.ts";
 import { symbolDeclaresCommonToolsDefault } from "../core/mod.ts";
 import { isOpaqueRefType } from "../transformers/opaque-ref/opaque-ref.ts";
@@ -428,11 +429,7 @@ export function createDataFlowAnalyzer(
 
               // Don't capture property accesses that are method calls.
               // For example, `element.trim` in `element.trim()` should not be captured.
-              if (
-                expression.parent &&
-                ts.isCallExpression(expression.parent) &&
-                expression.parent.expression === expression
-              ) {
+              if (isMethodCall(expression)) {
                 // This is a method call like element.trim() - don't capture it
                 return merged;
               }

packages/ts-transformers/src/ast/mod.ts

@@ -8,7 +8,9 @@ export {
 export {
   getExpressionText,
   getMemberSymbol,
+  getMethodCallTarget,
   isFunctionParameter,
+  isMethodCall,
   visitEachChildWithJsx,
 } from "./utils.ts";
 export {

packages/ts-transformers/src/ast/type-inference.ts

@@ -175,3 +175,42 @@ export function typeToSchemaTypeNode(
   const result = typeToTypeNode(type, checker, location);
   return result;
 }
+
+/**
+ * If a parameter has an explicit type annotation that's not Any,
+ * return it and register in TypeRegistry.
+ * This is useful for transformers that need to preserve explicit types.
+ */
+export function tryExplicitParameterType(
+  param: ts.ParameterDeclaration | undefined,
+  checker: ts.TypeChecker,
+  typeRegistry?: WeakMap<ts.Node, ts.Type>,
+): { typeNode: ts.TypeNode; type: ts.Type } | null {
+  if (!param?.type) return null;
+
+  const annotationType = checker.getTypeFromTypeNode(param.type);
+
+  if (annotationType.flags & ts.TypeFlags.Any) return null;
+
+  if (typeRegistry) {
+    typeRegistry.set(param.type, annotationType);
+  }
+
+  return { typeNode: param.type, type: annotationType };
+}
+
+/**
+ * Create a TypeNode and register it with a Type in TypeRegistry.
+ * Handles the common pattern of synthetic TypeNode creation.
+ * This ensures that later transformer stages can retrieve the Type from synthetic nodes.
+ */
+export function registerTypeForNode(
+  typeNode: ts.TypeNode,
+  type: ts.Type,
+  typeRegistry?: WeakMap<ts.Node, ts.Type>,
+): ts.TypeNode {
+  if (typeRegistry) {
+    typeRegistry.set(typeNode, type);
+  }
+  return typeNode;
+}

packages/ts-transformers/src/ast/utils.ts

@@ -228,3 +228,46 @@ export function visitEachChildWithJsx(
   // For all other nodes, use the default behavior
   return ts.visitEachChild(node, visitor, context);
 }
+
+/**
+ * Check if a property access expression is being invoked as a method call.
+ *
+ * @example
+ * ```typescript
+ * // Returns true:
+ * obj.method()  // node is obj.method
+ *
+ * // Returns false:
+ * const x = obj.method  // node is obj.method (not being called)
+ * ```
+ */
+export function isMethodCall(node: ts.PropertyAccessExpression): boolean {
+  return !!(
+    node.parent &&
+    ts.isCallExpression(node.parent) &&
+    node.parent.expression === node
+  );
+}
+
+/**
+ * When a property access is a method call, get the object being called on.
+ * This is useful for closures that should capture the object, not the method.
+ *
+ * @example
+ * ```typescript
+ * state.counter.set()  // Returns PropertyAccessExpression for state.counter
+ * obj.method()         // Returns undefined (obj is not a PropertyAccessExpression)
+ * obj.prop             // Returns undefined (not a method call)
+ * ```
+ *
+ * @returns The object PropertyAccessExpression if this is a method call on a property chain,
+ *          undefined otherwise
+ */
+export function getMethodCallTarget(
+  node: ts.PropertyAccessExpression,
+): ts.PropertyAccessExpression | undefined {
+  if (!isMethodCall(node)) return undefined;
+
+  const obj = node.expression;
+  return ts.isPropertyAccessExpression(obj) ? obj : undefined;
+}