Feature: Add method handling to mixin processing in KDL

inputfiles/addedTypes.jsonc

@@ -1,28 +1,4 @@
 {
-    "mixins": {
-        "mixin": {
-            "DocumentOrShadowRoot": {
-                // Manually moved from Document
-                // See https://github.com/w3c/csswg-drafts/issues/5886 and https://github.com/w3c/csswg-drafts/issues/556
-                "methods": {
-                    "method": {
-                        "elementFromPoint": {
-                            "name": "elementFromPoint",
-                            "overrideSignatures": [
-                                "elementFromPoint(x: number, y: number): Element | null"
-                            ]
-                        },
-                        "elementsFromPoint": {
-                            "name": "elementsFromPoint",
-                            "overrideSignatures": [
-                                "elementsFromPoint(x: number, y: number): Element[]"
-                            ]
-                        }
-                    }
-                }
-            }
-        }
-    },
     "interfaces": {
         "interface": {
             // ImportMeta is not a true DOM interface, but we are forced to declare it as one in order to emit method definitions.

inputfiles/patches/cssom-view.kdl

@@ -0,0 +1,15 @@
+// Manually moved from Document
+// See https://github.com/w3c/csswg-drafts/issues/5886 and https://github.com/w3c/csswg-drafts/issues/556
+interface-mixin DocumentOrShadowRoot {
+  method elementFromPoint returns=Element nullable=#true {
+    param x type=long
+    param y type=long
+  }
+  method elementsFromPoint {
+    type sequence {
+      type Element
+    }
+    param x type=long
+    param y type=long
+  }
+}

src/build/patches.ts

@@ -1,5 +1,5 @@
 import { parse, type Value, type Node } from "kdljs";
-import type { Enum, Event, Property, Interface, WebIdl } from "./types";
+import type { Enum, Event, Property, Interface, WebIdl, Method } from "./types";
 import { readdir, readFile } from "fs/promises";
 import { merge } from "./helpers.js";
 
@@ -94,6 +94,7 @@ function handleMixin(node: Node): DeepPartial<Interface> {
 
   const event: Event[] = [];
   const property: Record<string, Partial<Property>> = {};
+  const method: Record<string, Partial<Method>> = {};
 
   for (const child of node.children) {
     switch (child.name) {
@@ -105,6 +106,11 @@ function handleMixin(node: Node): DeepPartial<Interface> {
         property[propName] = handleProperty(child);
         break;
       }
+      case "method": {
+        const methodName = child.values[0] as string;
+        method[methodName] = handleMethod(child);
+        break;
+      }
       default:
         throw new Error(`Unknown node name: ${child.name}`);
     }
@@ -114,6 +120,7 @@ function handleMixin(node: Node): DeepPartial<Interface> {
     name,
     events: { event },
     properties: { property },
+    methods: { method },
     ...optionalMember("extends", "string", node.properties?.extends),
   } as DeepPartial<Interface>;
 }
@@ -142,6 +149,37 @@ function handleProperty(child: Node): Partial<Property> {
   };
 }
 
+/**
+ * Handles a child node of type "method" and adds it to the method object.
+ * @param child The child node to handle.
+ */
+function handleMethod(child: Node): Partial<Method> {
+  const name = child.values[0] as string;
+  const type = child.children[0];
+  const returnType = child.properties.returns as string;
+  const nullable = child.properties.nullable as boolean;
+
+  const params = child.children
+    .filter((c) => c.values[0] != "sequence")
+    .map((c) => ({
+      name: c.values[0] as string,
+      type: c.properties.type as string,
+    }));
+
+  const signature: Method["signature"] = [
+    {
+      type: type.name == "type" ? (type.values[0] as string) : returnType,
+      param: params,
+      nullable,
+      subtype:
+        type.name == "type"
+          ? { type: type.children[0].values[0] as string }
+          : undefined,
+    },
+  ];
+  return { name, signature };
+}
+
 /**
  * Collect all file URLs in a directory.
  */