fix(test): use ctx.skip() for explicit vitest skip state in erlang suite

Replace early-return guards with ctx.skip() so vitest reports these
tests as explicitly skipped rather than silently passed when the
Erlang WASM is absent.

Author: carlos-alm

tests/parsers/erlang.test.ts

@@ -19,42 +19,42 @@ describe('Erlang parser', () => {
     return extractErlangSymbols(tree, 'test.erl');
   }
 
-  it('extracts module declarations', () => {
-    if (!erlangAvailable) return;
+  it('extracts module declarations', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     const symbols = parseErlang(`-module(mymodule).`);
     expect(symbols.definitions).toContainEqual(
       expect.objectContaining({ name: 'mymodule', kind: 'module' }),
     );
   });
 
-  it('extracts function definitions', () => {
-    if (!erlangAvailable) return;
+  it('extracts function definitions', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     const symbols = parseErlang(`greet(Name) ->
     io:format("Hello ~s~n", [Name]).`);
     expect(symbols.definitions).toContainEqual(expect.objectContaining({ kind: 'function' }));
   });
 
-  it('extracts record definitions', () => {
-    if (!erlangAvailable) return;
+  it('extracts record definitions', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     const symbols = parseErlang(`-record(person, {name, age}).`);
     expect(symbols.definitions).toContainEqual(expect.objectContaining({ kind: 'record' }));
   });
 
-  it('extracts import attributes', () => {
-    if (!erlangAvailable) return;
+  it('extracts import attributes', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     const symbols = parseErlang(`-import(lists, [map/2, filter/2]).`);
     expect(symbols.imports.length).toBeGreaterThanOrEqual(1);
   });
 
-  it('extracts function calls', () => {
-    if (!erlangAvailable) return;
+  it('extracts function calls', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     const symbols = parseErlang(`start() ->
     io:format("Hello~n").`);
     expect(symbols.calls.length).toBeGreaterThanOrEqual(1);
   });
 
-  it('keeps distinct arities for the same function name', () => {
-    if (!erlangAvailable) return;
+  it('keeps distinct arities for the same function name', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     // Erlang overloads by arity; foo/1 and foo/2 are distinct definitions.
     const symbols = parseErlang(`foo(X) -> X.
 foo(X, Y) -> X + Y.
@@ -65,17 +65,17 @@ foo(X, Y, Z) -> X + Y + Z.`);
     expect(arities).toEqual([1, 2, 3]);
   });
 
-  it('counts complex pattern arguments as parameters', () => {
-    if (!erlangAvailable) return;
+  it('counts complex pattern arguments as parameters', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     // Tuple, list, and binary pattern arguments must still count toward arity.
     const symbols = parseErlang(`handle({ok, X}, [H | T]) -> {X, H, T}.`);
     const f = symbols.definitions.find((d) => d.name === 'handle' && d.kind === 'function');
     expect(f).toBeDefined();
     expect(f?.children?.length).toBe(2);
   });
 
-  it('extracts -type aliases', () => {
-    if (!erlangAvailable) return;
+  it('extracts -type aliases', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     // Type-alias names are wrapped in a `type_name` node containing an atom in
     // the current grammar; the extractor handles both the wrapped form and a
     // direct atom fallback.
@@ -85,25 +85,25 @@ foo(X, Y, Z) -> X + Y + Z.`);
     );
   });
 
-  it('extracts -opaque types', () => {
-    if (!erlangAvailable) return;
+  it('extracts -opaque types', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     // -opaque uses the same `type_alias` node shape and must produce a type def.
     const symbols = parseErlang(`-opaque handle() :: reference().`);
     expect(symbols.definitions).toContainEqual(
       expect.objectContaining({ name: 'handle', kind: 'type' }),
     );
   });
 
-  it('extracts -define macros as variables', () => {
-    if (!erlangAvailable) return;
+  it('extracts -define macros as variables', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     const symbols = parseErlang(`-define(MAX_SIZE, 1024).`);
     expect(symbols.definitions).toContainEqual(
       expect.objectContaining({ name: 'MAX_SIZE', kind: 'variable' }),
     );
   });
 
-  it('extracts uppercase parametric macro names', () => {
-    if (!erlangAvailable) return;
+  it('extracts uppercase parametric macro names', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     // Parametric macros wrap the name in `macro_lhs(name, args)`; the leading
     // child is the name (var for uppercase).
     const symbols = parseErlang(`-define(FOO(X), X + 1).`);
@@ -112,8 +112,8 @@ foo(X, Y, Z) -> X + Y + Z.`);
     );
   });
 
-  it('extracts lowercase parametric macro names without mislabeling on argument vars', () => {
-    if (!erlangAvailable) return;
+  it('extracts lowercase parametric macro names without mislabeling on argument vars', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     // For lowercase parametric macros, macro_lhs children are
     // `atom("foo"), '(', var("X"), ')'`. The macro name must come from the
     // atom, not from `findChild(.., 'var')` which would land on the argument.
@@ -125,16 +125,16 @@ foo(X, Y, Z) -> X + Y + Z.`);
     expect(symbols.definitions.some((d) => d.name === 'X')).toBe(false);
   });
 
-  it('records -include with kind "include" so consumers resolve locally', () => {
-    if (!erlangAvailable) return;
+  it('records -include with kind "include" so consumers resolve locally', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     const symbols = parseErlang(`-include("foo.hrl").`);
     const imp = symbols.imports.find((i) => i.source === 'foo.hrl');
     expect(imp).toBeDefined();
     expect(imp?.names).toEqual(['include']);
   });
 
-  it('records -include_lib with kind "include_lib" so consumers resolve against OTP paths', () => {
-    if (!erlangAvailable) return;
+  it('records -include_lib with kind "include_lib" so consumers resolve against OTP paths', (ctx) => {
+    if (!erlangAvailable) return ctx.skip();
     const symbols = parseErlang(`-include_lib("kernel/include/file.hrl").`);
     const imp = symbols.imports.find((i) => i.source === 'kernel/include/file.hrl');
     expect(imp).toBeDefined();