test: move amaro checks after common import

Move the amaro availability check immediately after importing
common module in test files, as requested in PR feedback.

Changes:
- Place amaro check after common import but before other
  imports
- Update test-node-output-sourcemaps.mjs to dynamically skip
  .ts tests based on file extension
- Add individual skip conditions for TypeScript-specific tests
- Fix linting errors (missing semicolon, line length issues)

Refs: nodejs#60815

Author: y-okt

src/node_options.cc

@@ -1092,12 +1092,7 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "Type-stripping for TypeScript files.",
             &EnvironmentOptions::strip_types,
             kAllowedInEnvvar,
-#if HAVE_AMARO
-            true
-#else
-            false
-#endif  // HAVE_AMARO
-);
+            HAVE_AMARO);
   AddAlias("--experimental-strip-types", "--strip-types");
   AddOption("--experimental-transform-types",
             "enable transformation of TypeScript-only"

test/es-module/test-esm-detect-ambiguous.mjs

@@ -1,14 +1,9 @@
-import * as common from '../common/index.mjs';
+import { spawnPromisified } from '../common/index.mjs';
 import * as fixtures from '../common/fixtures.mjs';
 import { spawn } from 'node:child_process';
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
 
-if (!process.config.variables.node_use_amaro) {
-  common.skip('Requires Amaro');
-}
-const { spawnPromisified } = common;
-
 describe('Module syntax detection', { concurrency: !process.env.TEST_PARALLEL }, () => {
   describe('string input', { concurrency: !process.env.TEST_PARALLEL }, () => {
     it('permits ESM syntax in --eval input without requiring --input-type=module', async () => {
@@ -268,17 +263,19 @@ describe('Module syntax detection', { concurrency: !process.env.TEST_PARALLEL },
       assert.strictEqual(signal, null);
     });
 
-    it('still throws on `await` in an ordinary sync function', async () => {
-      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
-        '--eval',
-        'function fn() { await Promise.resolve(); } fn();',
-      ]);
+    it('still throws on `await` in an ordinary sync function',
+       { skip: !process.config.variables.node_use_amaro },
+       async () => {
+         const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+           '--eval',
+           'function fn() { await Promise.resolve(); } fn();',
+         ]);
 
-      assert.match(stderr, /SyntaxError: await is only valid in async function/);
-      assert.strictEqual(stdout, '');
-      assert.strictEqual(code, 1);
-      assert.strictEqual(signal, null);
-    });
+         assert.match(stderr, /SyntaxError: await is only valid in async function/);
+         assert.strictEqual(stdout, '');
+         assert.strictEqual(code, 1);
+         assert.strictEqual(signal, null);
+       });
 
     it('throws on undefined `require` when top-level `await` triggers ESM parsing', async () => {
       const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
@@ -319,17 +316,19 @@ describe('Module syntax detection', { concurrency: !process.env.TEST_PARALLEL },
       assert.strictEqual(signal, null);
     });
 
-    it('still throws on double `const` declaration not at the top level', async () => {
-      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
-        '--eval',
-        'function fn() { const require = 1; const require = 2; } fn();',
-      ]);
-
-      assert.match(stderr, /SyntaxError: Identifier 'require' has already been declared/);
-      assert.strictEqual(stdout, '');
-      assert.strictEqual(code, 1);
-      assert.strictEqual(signal, null);
-    });
+    it('still throws on double `const` declaration not at the top level',
+       { skip: !process.config.variables.node_use_amaro },
+       async () => {
+         const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+           '--eval',
+           'function fn() { const require = 1; const require = 2; } fn();',
+         ]);
+
+         assert.match(stderr, /SyntaxError: Identifier 'require' has already been declared/);
+         assert.strictEqual(stdout, '');
+         assert.strictEqual(code, 1);
+         assert.strictEqual(signal, null);
+       });
   });
 
   describe('warn about typeless packages for .js files with ESM syntax', { concurrency: true }, () => {

test/es-module/test-esm-import-meta-main-eval.mjs

@@ -1,13 +1,8 @@
-import * as common from '../common/index.mjs';
+import { spawnPromisified } from '../common/index.mjs';
 import * as fixtures from '../common/fixtures.js';
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 
-if (!process.config.variables.node_use_amaro) {
-  common.skip('Requires Amaro');
-}
-const { spawnPromisified } = common;
-
 function wrapScriptInEvalWorker(script) {
   return `
   import { Worker } from 'node:worker_threads';
@@ -38,7 +33,7 @@ const { isMain: importedModuleIsMain } = await import(
 assert.strictEqual(importedModuleIsMain, false, 'import.meta.main should evaluate false in imported module');
 `;
 
-  it('should evaluate true in evaluated script', async () => {
+  it('should evaluate true in evaluated script', { skip: !process.config.variables.node_use_amaro }, async () => {
     const result = await spawnPromisified(
       process.execPath,
       ['--input-type=module', '--eval', importMetaMainScript],
@@ -103,35 +98,39 @@ assert.strictEqual(importedModuleIsMain, false, 'import.meta.main should evaluat
     });
   });
 
-  it('should evaluate true in worker instantiated with module source by evaluated script', async () => {
-    const result = await spawnPromisified(
-      process.execPath,
-      ['--input-type=module-typescript',
-       '--disable-warning=ExperimentalWarning',
-       '--eval',
-       wrapScriptInEvalWorker(importMetaMainTSScript)],
-    );
-    assert.deepStrictEqual(result, {
-      stderr: '',
-      stdout: '',
-      code: 0,
-      signal: null,
-    });
-  });
-
-  it('should evaluate true in worker instantiated with `data:` URL by evaluated script', async () => {
-    const result = await spawnPromisified(
-      process.execPath,
-      ['--input-type=module',
-       '--input-type=module-typescript',
-       '--disable-warning=ExperimentalWarning',
-       '--eval', wrapScriptInUrlWorker(importMetaMainTSScript)],
-    );
-    assert.deepStrictEqual(result, {
-      stderr: '',
-      stdout: '',
-      code: 0,
-      signal: null,
-    });
-  });
+  it('should evaluate true in worker instantiated with module source by evaluated script',
+     { skip: !process.config.variables.node_use_amaro },
+     async () => {
+       const result = await spawnPromisified(
+         process.execPath,
+         ['--input-type=module-typescript',
+          '--disable-warning=ExperimentalWarning',
+          '--eval',
+          wrapScriptInEvalWorker(importMetaMainTSScript)],
+       );
+       assert.deepStrictEqual(result, {
+         stderr: '',
+         stdout: '',
+         code: 0,
+         signal: null,
+       });
+     });
+
+  it('should evaluate true in worker instantiated with `data:` URL by evaluated script',
+     { skip: !process.config.variables.node_use_amaro },
+     async () => {
+       const result = await spawnPromisified(
+         process.execPath,
+         ['--input-type=module',
+          '--input-type=module-typescript',
+          '--disable-warning=ExperimentalWarning',
+          '--eval', wrapScriptInUrlWorker(importMetaMainTSScript)],
+       );
+       assert.deepStrictEqual(result, {
+         stderr: '',
+         stdout: '',
+         code: 0,
+         signal: null,
+       });
+     });
 });

test/es-module/test-esm-tla-syntax-errors-not-recognized-as-tla-error.mjs

@@ -1,12 +1,7 @@
-import * as common from '../common/index.mjs';
+import { spawnPromisified } from '../common/index.mjs';
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
 
-if (!process.config.variables.node_use_amaro) {
-  common.skip('Requires Amaro');
-}
-const { spawnPromisified } = common;
-
 describe('unusual top-level await syntax errors', () => {
   const expressions = [
     // string
@@ -54,30 +49,32 @@ describe('unusual top-level await syntax errors', () => {
     }
   });
 
-  it('should throw the error for unrelated syntax errors', async () => {
-    const expression = 'foo bar';
-    const wrapperExpressions = [
-      [`function callSyntaxError() {}; callSyntaxError(${expression});`, /missing \) after argument list/],
-      [`if (${expression}) {}`, /Unexpected identifier/],
-      [`{ key: ${expression} }`, /Unexpected identifier/],
-      [`[${expression}]`, /Unexpected identifier/],
-      [`(${expression})`, /Unexpected identifier/],
-      [`const ${expression} = 1;`, /Missing initializer in const declaration/],
-      [`console.log('PI: ' Math.PI);`, /missing \) after argument list/],
-      [`callAwait(await "" "");`, /missing \) after argument list/],
-    ];
+  it('should throw the error for unrelated syntax errors',
+     { skip: !process.config.variables.node_use_amaro },
+     async () => {
+       const expression = 'foo bar';
+       const wrapperExpressions = [
+         [`function callSyntaxError() {}; callSyntaxError(${expression});`, /missing \) after argument list/],
+         [`if (${expression}) {}`, /Unexpected identifier/],
+         [`{ key: ${expression} }`, /Unexpected identifier/],
+         [`[${expression}]`, /Unexpected identifier/],
+         [`(${expression})`, /Unexpected identifier/],
+         [`const ${expression} = 1;`, /Missing initializer in const declaration/],
+         [`console.log('PI: ' Math.PI);`, /missing \) after argument list/],
+         [`callAwait(await "" "");`, /missing \) after argument list/],
+       ];
 
-    for (const [wrapperExpression, error] of wrapperExpressions) {
-      const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-        '--eval',
-        `
+       for (const [wrapperExpression, error] of wrapperExpressions) {
+         const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
+           '--eval',
+           `
           ${wrapperExpression}
           `,
-      ]);
-      assert.match(stderr, error);
-      assert.strictEqual(stdout, '');
-      assert.strictEqual(code, 1);
-      assert.strictEqual(signal, null);
-    }
-  });
+         ]);
+         assert.match(stderr, error);
+         assert.strictEqual(stdout, '');
+         assert.strictEqual(code, 1);
+         assert.strictEqual(signal, null);
+       }
+     });
 });

test/parallel/test-compile-cache-typescript-commonjs.js

@@ -3,15 +3,14 @@
 // This tests NODE_COMPILE_CACHE works for CommonJS with types.
 
 const common = require('../common');
+if (!process.config.variables.node_use_amaro) {
+  common.skip('Requires Amaro');
+}
 const { spawnSyncAndAssert } = require('../common/child_process');
 const assert = require('assert');
 const tmpdir = require('../common/tmpdir');
 const fixtures = require('../common/fixtures');
 
-if (!process.config.variables.node_use_amaro) {
-  common.skip('Requires Amaro');
-}
-
 // Check cache for .ts files that would be run as CommonJS.
 {
   tmpdir.refresh();

test/parallel/test-compile-cache-typescript-esm.js

@@ -3,15 +3,14 @@
 // This tests NODE_COMPILE_CACHE works for ESM with types.
 
 const common = require('../common');
+if (!process.config.variables.node_use_amaro) {
+  common.skip('Requires Amaro');
+}
 const { spawnSyncAndAssert } = require('../common/child_process');
 const assert = require('assert');
 const tmpdir = require('../common/tmpdir');
 const fixtures = require('../common/fixtures');
 
-if (!process.config.variables.node_use_amaro) {
-  common.skip('Requires Amaro');
-}
-
 // Check cache for .ts files that would be run as ESM.
 {
   tmpdir.refresh();

test/parallel/test-compile-cache-typescript-strip-miss.js

@@ -4,15 +4,14 @@
 // between strip-only TypeScript and transformed TypeScript.
 
 const common = require('../common');
+if (!process.config.variables.node_use_amaro) {
+  common.skip('Requires Amaro');
+}
 const { spawnSyncAndAssert } = require('../common/child_process');
 const assert = require('assert');
 const tmpdir = require('../common/tmpdir');
 const fixtures = require('../common/fixtures');
 
-if (!process.config.variables.node_use_amaro) {
-  common.skip('Requires Amaro');
-}
-
 tmpdir.refresh();
 const dir = tmpdir.resolve('.compile_cache_dir');
 const script = fixtures.path('typescript', 'ts', 'test-typescript.ts');

test/parallel/test-compile-cache-typescript-strip-sourcemaps.js

@@ -4,15 +4,14 @@
 // --enable-source-maps as there's no difference in the code generated.
 
 const common = require('../common');
+if (!process.config.variables.node_use_amaro) {
+  common.skip('Requires Amaro');
+}
 const { spawnSyncAndAssert } = require('../common/child_process');
 const assert = require('assert');
 const tmpdir = require('../common/tmpdir');
 const fixtures = require('../common/fixtures');
 
-if (!process.config.variables.node_use_amaro) {
-  common.skip('Requires Amaro');
-}
-
 tmpdir.refresh();
 const dir = tmpdir.resolve('.compile_cache_dir');
 const script = fixtures.path('typescript', 'ts', 'test-typescript.ts');

test/parallel/test-compile-cache-typescript-transform.js

@@ -3,15 +3,14 @@
 // This tests NODE_COMPILE_CACHE works with --experimental-transform-types.
 
 const common = require('../common');
+if (!process.config.variables.node_use_amaro) {
+  common.skip('Requires Amaro');
+}
 const { spawnSyncAndAssert } = require('../common/child_process');
 const assert = require('assert');
 const tmpdir = require('../common/tmpdir');
 const fixtures = require('../common/fixtures');
 
-if (!process.config.variables.node_use_amaro) {
-  common.skip('Requires Amaro');
-}
-
 
 tmpdir.refresh();
 const dir = tmpdir.resolve('.compile_cache_dir');