@kernlang/test 3.5.9-canary.218.1.77aa9b0c → 4.0.0

package/dist/index.js

@@ -2569,18 +2569,18 @@ function runtimeHandlerLines(node, spaces = 4) {
         return [];
     return code.split('\n').map((line) => `${prefix}${line}`);
 }
-function runtimeClassFieldInitializers(node) {
+function runtimeClassFieldLines(node) {
     const lines = [];
     for (const field of getChildren(node, 'field')) {
         const props = getProps(field);
-        if (isTruthy(props.static))
-            continue;
         const name = str(props.name);
         if (!isRuntimeBindingName(name))
-            return [];
+            return undefined;
         const value = exprPropToRuntimeSource(field, 'value') || rawPropToRuntimeSource(field, 'default');
-        if (value)
-            lines.push(`    this.${name} = (${value});`);
+        if (!value)
+            continue;
+        const staticKw = isTruthy(props.static) ? 'static ' : '';
+        lines.push(`  ${staticKw}${name} = (${value});`);
     }
     return lines;
 }
@@ -2630,17 +2630,21 @@ function runtimeClassExpr(node) {
     const name = str(getProps(node).name);
     if (!isRuntimeBindingName(name))
         return '';
+    const baseName = str(getProps(node).extends);
+    if (baseName && !isRuntimeBindingName(baseName))
+        return '';
     const ctorNode = getChildren(node, 'constructor')[0];
     const ctorParams = ctorNode ? runtimeParamNames(ctorNode) : [];
     if (!ctorParams.every(isRuntimeBindingName))
         return '';
-    const fieldInitializers = runtimeClassFieldInitializers(node);
-    const lines = ['(class {'];
-    if (ctorNode || fieldInitializers.length > 0) {
+    const fieldLines = runtimeClassFieldLines(node);
+    if (!fieldLines)
+        return '';
+    const lines = [`(class ${name}${baseName ? ` extends ${baseName}` : ''} {`];
+    lines.push(...fieldLines);
+    if (ctorNode) {
         lines.push(`  constructor(${ctorParams.join(', ')}) {`);
-        lines.push(...fieldInitializers);
-        if (ctorNode)
-            lines.push(...runtimeHandlerLines(ctorNode));
+        lines.push(...runtimeHandlerLines(ctorNode));
         lines.push('  }');
     }
     for (const method of getChildren(node, 'method')) {
@@ -3940,7 +3944,7 @@ function orderRuntimeBindings(bindings, entryExpr) {
         visiting.add(name);
         stack.push(name);
         for (const dep of depsIn(binding.expr)) {
-            if (dep === name && binding.kind === 'fn')
+            if (dep === name && (binding.kind === 'fn' || binding.kind === 'class'))
                 continue;
             const error = visit(dep);
             if (error)
@@ -5372,6 +5376,24 @@ function nativeInvariantFindings(node, target, context) {
     const propName = 'has' in props ? 'has' : 'no';
     return { message: `Unsupported native invariant: ${propName}=${str(props.has) || str(props.no)}` };
 }
+function evaluateFindingsMatch(invariant, pattern, findings) {
+    const message = findings.join('; ');
+    try {
+        const regex = new RegExp(pattern);
+        return findings.some((finding) => regex.test(finding))
+            ? { passed: true }
+            : {
+                passed: false,
+                message: `Expected ${invariant || '<missing>'} findings to match /${pattern}/, got: ${message || '<none>'}`,
+            };
+    }
+    catch (error) {
+        return {
+            passed: false,
+            message: `Native has assertion has invalid matches regex: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
 function evaluateHasInvariant(node, target, context) {
     const props = getProps(node);
     const invariant = str(props.has);
@@ -5398,22 +5420,7 @@ function evaluateHasInvariant(node, target, context) {
         }
         if ('matches' in props) {
             const pattern = runtimePatternValue(node, 'matches') || '';
-            const message = findings.join('; ');
-            try {
-                const regex = new RegExp(pattern);
-                return regex.test(message)
-                    ? { passed: true }
-                    : {
-                        passed: false,
-                        message: `Expected ${invariant || '<missing>'} findings to match /${pattern}/, got: ${message || '<none>'}`,
-                    };
-            }
-            catch (error) {
-                return {
-                    passed: false,
-                    message: `Native has assertion has invalid matches regex: ${error instanceof Error ? error.message : String(error)}`,
-                };
-            }
+            return evaluateFindingsMatch(invariant, pattern, findings);
         }
         return { passed: true };
     }
@@ -5422,6 +5429,20 @@ function evaluateHasInvariant(node, target, context) {
         if (blocking)
             return { passed: false, message: blocking };
     }
+    if ('matches' in props) {
+        const collected = nativeInvariantFindings(node, target, context);
+        if (collected.message)
+            return { passed: false, message: collected.message };
+        const findings = collected.findings || [];
+        if (findings.length === 0) {
+            return {
+                passed: false,
+                message: `Expected target to have ${invariant || '<missing>'}, but none was found`,
+            };
+        }
+        const pattern = runtimePatternValue(node, 'matches') || '';
+        return evaluateFindingsMatch(invariant, pattern, findings);
+    }
     const evaluated = evaluateNoInvariant(nodeWithProps(node, { ...props, no: invariant }), target, context);
     if (isAssertionConfigurationFailure(evaluated.message)) {
         return { passed: false, message: evaluated.message };
@@ -5432,24 +5453,6 @@ function evaluateHasInvariant(node, target, context) {
             message: `Expected target to have ${invariant || '<missing>'}, but none was found`,
         };
     }
-    if ('matches' in props) {
-        const pattern = runtimePatternValue(node, 'matches') || '';
-        try {
-            const regex = new RegExp(pattern);
-            return regex.test(evaluated.message || '')
-                ? { passed: true }
-                : {
-                    passed: false,
-                    message: `Expected ${invariant || '<missing>'} message to match /${pattern}/, got: ${evaluated.message || '<none>'}`,
-                };
-        }
-        catch (error) {
-            return {
-                passed: false,
-                message: `Native has assertion has invalid matches regex: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
     return { passed: true };
 }
 function evaluateMachineReachability(node, target) {