From e0ac82efb99e44efe105e91257f51bd4200926c4 Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Fri, 9 Aug 2024 12:34:09 +0200
Subject: [PATCH] module: add --experimental-enable-transformation for
 strip-types

---
 doc/api/cli.md                                |  10 ++
 doc/api/typescript.md                         |  38 ++++--
 doc/node.1                                    |   3 +
 lib/internal/main/eval_string.js              |   4 +-
 lib/internal/modules/cjs/loader.js            |  16 +--
 lib/internal/modules/esm/get_format.js        |   6 +-
 lib/internal/modules/esm/translators.js       |   8 +-
 lib/internal/modules/helpers.js               |  39 +++++-
 src/node_options.cc                           |   6 +
 src/node_options.h                            |   1 +
 test/es-module/test-typescript-transform.mjs  | 124 ++++++++++++++++++
 .../transformation/test-complex-stacktrace.ts |  67 ++++++++++
 .../ts/transformation/test-decorator.ts       |  10 ++
 .../ts/transformation/test-enum-stacktrace.ts |   4 +
 .../typescript/ts/transformation/test-enum.ts |   4 +
 .../ts/transformation/test-legacy-module.ts   |  12 ++
 .../ts/transformation/test-namespace.ts       |   7 +
 .../ts/transformation/test-unused-import.ts   |   3 +
 18 files changed, 324 insertions(+), 38 deletions(-)
 create mode 100644 test/es-module/test-typescript-transform.mjs
 create mode 100644 test/fixtures/typescript/ts/transformation/test-complex-stacktrace.ts
 create mode 100644 test/fixtures/typescript/ts/transformation/test-decorator.ts
 create mode 100644 test/fixtures/typescript/ts/transformation/test-enum-stacktrace.ts
 create mode 100644 test/fixtures/typescript/ts/transformation/test-enum.ts
 create mode 100644 test/fixtures/typescript/ts/transformation/test-legacy-module.ts
 create mode 100644 test/fixtures/typescript/ts/transformation/test-namespace.ts
 create mode 100644 test/fixtures/typescript/ts/transformation/test-unused-import.ts

diff --git a/doc/api/cli.md b/doc/api/cli.md
index c0dfcd418b96a1..78d342f0f90cda 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -933,6 +933,15 @@ files with no extension will be treated as WebAssembly if they begin with the
 WebAssembly magic number (`\0asm`); otherwise they will be treated as ES module
 JavaScript.
 
+### `--experimental-enable-transformation`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Enables the transformation of TypeScript-only syntax into JavaScript code.
+Implies `--experimental-strip-types`.
+
 ### `--experimental-eventsource`
 
 <!-- YAML
@@ -2911,6 +2920,7 @@ one is included in the list below.
 * `--experimental-async-context-frame`
 * `--experimental-default-type`
 * `--experimental-detect-module`
+* `--experimental-enable-transformation`
 * `--experimental-eventsource`
 * `--experimental-import-meta-resolve`
 * `--experimental-json-modules`
diff --git a/doc/api/typescript.md b/doc/api/typescript.md
index cddd0dd29f1d86..088aaf706703ad 100644
--- a/doc/api/typescript.md
+++ b/doc/api/typescript.md
@@ -44,13 +44,15 @@ added: v22.6.0
 > Stability: 1.0 - Early development
 
 The flag [`--experimental-strip-types`][] enables Node.js to run TypeScript
-files that contain only type annotations. Such files contain no TypeScript
-features that require transformation, such as enums or namespaces. Node.js will
-replace inline type annotations with whitespace, and no type checking is
-performed. TypeScript features that depend on settings within `tsconfig.json`,
+files. By default Node.js will execute only files that contain no
+TypeScript features that require transformation, such as enums or namespaces.
+Node.js will replace inline type annotations with whitespace,
+and no type checking is performed.
+To enable the transformation of such features
+use the flag [`--experimental-enable-transformation`][].
+TypeScript features that depend on settings within `tsconfig.json`,
 such as paths or converting newer JavaScript syntax to older standards, are
-intentionally unsupported. To get fuller TypeScript support, including support
-for enums and namespaces and paths, see [Full TypeScript support][].
+intentionally unsupported. To get fuller TypeScript support, see [Full TypeScript support][].
 
 The type stripping feature is designed to be lightweight.
 By intentionally not supporting syntaxes that require JavaScript code
@@ -82,20 +84,24 @@ The `tsconfig.json` option `allowImportingTsExtensions` will allow the
 TypeScript compiler `tsc` to type-check files with `import` specifiers that
 include the `.ts` extension.
 
-### Unsupported TypeScript features
+### TypeScript features
 
 Since Node.js is only removing inline types, any TypeScript features that
-involve _replacing_ TypeScript syntax with new JavaScript syntax will error.
-This is by design. To run TypeScript with such features, see
-[Full TypeScript support][].
+involve _replacing_ TypeScript syntax with new JavaScript syntax will error,
+unless the flag [`--experimental-enable-transformation`][] is passed.
 
-The most prominent unsupported features that require transformation are:
+The most prominent features that require transformation are:
 
 * `Enum`
-* `experimentalDecorators`
 * `namespaces`
+* `legacy module`
 * parameter properties
 
+Since Decorators are currently a [TC39 ECMA402 stage 3 proposal](https://github.com/tc39/proposal-decorators)
+and will soon be supported by the JavaScript engine,
+they are not transformed and will result in a runtime error.
+This is a temporary limitation and will be resolved in the future.
+
 In addition, Node.js does not read `tsconfig.json` files and does not support
 features that depend on settings within `tsconfig.json`, such as paths or
 converting newer JavaScript syntax into older standards.
@@ -132,8 +138,11 @@ TypeScript syntax is unsupported in the REPL, STDIN input, `--print`, `--check`,
 ### Source maps
 
 Since inline types are replaced by whitespace, source maps are unnecessary for
-correct line numbers in stack traces; and Node.js does not generate them. For
-source maps support, see [Full TypeScript support][].
+correct line numbers in stack traces; and Node.js does not generate them.
+When [`--experimental-enable-transformation`][] is enabled, by passing the flag
+`--enable-source-maps`, source maps will be generated for the transformed code.
+If `--enable-source-maps` is not passed the stack traces might not have correct
+locations.
 
 ### Type stripping in dependencies
 
@@ -144,6 +153,7 @@ a `node_modules` path.
 [CommonJS]: modules.md
 [ES Modules]: esm.md
 [Full TypeScript support]: #full-typescript-support
+[`--experimental-enable-transformation`]: cli.md#--experimental-enable-transformation
 [`--experimental-strip-types`]: cli.md#--experimental-strip-types
 [`tsx`]: https://tsx.is/
 [`verbatimModuleSyntax`]: https://www.typescriptlang.org/tsconfig/#verbatimModuleSyntax
diff --git a/doc/node.1 b/doc/node.1
index 0d0473670535f8..be710db70bc02a 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -194,6 +194,9 @@ Enable snapshot testing in the test runner.
 .It Fl -experimental-strip-types
 Enable experimental type-stripping for TypeScript files.
 .
+.It Fl -experimental-enable-transformation
+Enable transformation of TypeScript-only syntax into JavaScript code.
+.
 .It Fl -experimental-eventsource
 Enable experimental support for the EventSource Web API.
 .
diff --git a/lib/internal/main/eval_string.js b/lib/internal/main/eval_string.js
index 395dee90ad916b..0f4b2850ac5f20 100644
--- a/lib/internal/main/eval_string.js
+++ b/lib/internal/main/eval_string.js
@@ -14,7 +14,7 @@ const {
   markBootstrapComplete,
 } = require('internal/process/pre_execution');
 const { evalModuleEntryPoint, evalScript } = require('internal/process/execution');
-const { addBuiltinLibsToObject, tsParse } = require('internal/modules/helpers');
+const { addBuiltinLibsToObject, stripTypes } = require('internal/modules/helpers');
 
 const { getOptionValue } = require('internal/options');
 
@@ -24,7 +24,7 @@ markBootstrapComplete();
 
 const code = getOptionValue('--eval');
 const source = getOptionValue('--experimental-strip-types') ?
-  tsParse(code) :
+  stripTypes(code) :
   code;
 
 const print = getOptionValue('--print');
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index 9f9e37692a5929..5170c9d56aacda 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -1362,8 +1362,8 @@ function loadESMFromCJS(mod, filename) {
     if (isUnderNodeModules(filename)) {
       throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename);
     }
-    const { tsParse } = require('internal/modules/helpers');
-    source = tsParse(source);
+    const { stripTypes } = require('internal/modules/helpers');
+    source = stripTypes(source, filename);
   }
   const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();
   const isMain = mod[kIsMainSymbol];
@@ -1576,9 +1576,9 @@ function loadCTS(module, filename) {
     throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename);
   }
   const source = getMaybeCachedSource(module, filename);
-  const { tsParse } = require('internal/modules/helpers');
-  const content = tsParse(source);
-  module._compile(content, filename, 'commonjs');
+  const { stripTypes } = require('internal/modules/helpers');
+  const code = stripTypes(source, filename);
+  module._compile(code, filename, 'commonjs');
 }
 
 /**
@@ -1592,8 +1592,8 @@ function loadTS(module, filename) {
   }
   // If already analyzed the source, then it will be cached.
   const source = getMaybeCachedSource(module, filename);
-  const { tsParse } = require('internal/modules/helpers');
-  const content = tsParse(source);
+  const { stripTypes } = require('internal/modules/helpers');
+  const content = stripTypes(source, filename);
   let format;
   const pkg = packageJsonReader.getNearestParentPackageJSON(filename);
   // Function require shouldn't be used in ES modules.
@@ -1613,7 +1613,7 @@ function loadTS(module, filename) {
     if (Module._cache[parentPath]) {
       let parentSource;
       try {
-        parentSource = tsParse(fs.readFileSync(parentPath, 'utf8'));
+        parentSource = stripTypes(fs.readFileSync(parentPath, 'utf8'), parentPath);
       } catch {
         // Continue regardless of error.
       }
diff --git a/lib/internal/modules/esm/get_format.js b/lib/internal/modules/esm/get_format.js
index 0a15d5b87d4f95..6bba6659589ae0 100644
--- a/lib/internal/modules/esm/get_format.js
+++ b/lib/internal/modules/esm/get_format.js
@@ -161,9 +161,9 @@ function getFileProtocolModuleFormat(url, context = { __proto__: null }, ignoreE
       default: { // The user did not pass `--experimental-default-type`.
         // `source` is undefined when this is called from `defaultResolve`;
         // but this gets called again from `defaultLoad`/`defaultLoadSync`.
-        const { tsParse } = require('internal/modules/helpers');
-        const parsedSource = tsParse(source);
-        const detectedFormat = detectModuleFormat(parsedSource, url);
+        const { stripTypes } = require('internal/modules/helpers');
+        const code = stripTypes(source, url);
+        const detectedFormat = detectModuleFormat(code, url);
         // When source is undefined, default to module-typescript.
         const format = detectedFormat ? `${detectedFormat}-typescript` : 'module-typescript';
         if (format === 'module-typescript' && foundPackageJson) {
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index d931d72f5ec1e0..e3d850d5363e29 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -38,7 +38,7 @@ const { readFileSync } = require('fs');
 const { dirname, extname, isAbsolute } = require('path');
 const {
   loadBuiltinModule,
-  tsParse,
+  stripTypes,
   stripBOM,
   urlToFilename,
 } = require('internal/modules/helpers');
@@ -309,7 +309,7 @@ translators.set('require-commonjs', (url, source, isMain) => {
 translators.set('require-commonjs-typescript', (url, source, isMain) => {
   emitExperimentalWarning('Type Stripping');
   assert(cjsParse);
-  const code = tsParse(stringify(source));
+  const code = stripTypes(stringify(source), url);
   return createCJSModuleWrap(url, code);
 });
 
@@ -526,7 +526,7 @@ translators.set('wasm', async function(url, source) {
 translators.set('commonjs-typescript', function(url, source) {
   emitExperimentalWarning('Type Stripping');
   assertBufferSource(source, false, 'load');
-  const code = tsParse(stringify(source));
+  const code = stripTypes(stringify(source), url);
   debug(`Translating TypeScript ${url}`);
   return FunctionPrototypeCall(translators.get('commonjs'), this, url, code, false);
 });
@@ -535,7 +535,7 @@ translators.set('commonjs-typescript', function(url, source) {
 translators.set('module-typescript', function(url, source) {
   emitExperimentalWarning('Type Stripping');
   assertBufferSource(source, false, 'load');
-  const code = tsParse(stringify(source));
+  const code = stripTypes(stringify(source), url);
   debug(`Translating TypeScript ${url}`);
   return FunctionPrototypeCall(translators.get('module'), this, url, code, false);
 });
diff --git a/lib/internal/modules/helpers.js b/lib/internal/modules/helpers.js
index b84312f2def6fb..24ac0d9868627c 100644
--- a/lib/internal/modules/helpers.js
+++ b/lib/internal/modules/helpers.js
@@ -24,7 +24,7 @@ const internalFS = require('internal/fs/utils');
 const path = require('path');
 const { pathToFileURL, fileURLToPath } = require('internal/url');
 const assert = require('internal/assert');
-
+const { Buffer } = require('buffer');
 const { getOptionValue } = require('internal/options');
 const { setOwnProperty } = require('internal/util');
 const { inspect } = require('internal/util/inspect');
@@ -300,7 +300,21 @@ function getBuiltinModule(id) {
   return normalizedId ? require(normalizedId) : undefined;
 }
 
+/**
+ * TypeScript parsing function, by default Amaro.transformSync.
+ *  @type {Function}
+ */
 let typeScriptParser;
+/**
+ * The TypeScript parsing mode, either 'strip-only' or 'transform'.
+ * @type {string}
+ */
+let typeScriptParsingMode;
+/**
+ * Whether source maps are enabled for TypeScript parsing.
+ * @type {boolean}
+ */
+let sourceMapEnabled;
 
 /**
  * Load the TypeScript parser.
@@ -318,23 +332,34 @@ function loadTypeScriptParser(parser) {
   } else {
     const amaro = require('internal/deps/amaro/dist/index');
     // Default option for Amaro is to perform Type Stripping only.
-    const defaultOptions = { __proto__: null, mode: 'strip-only' };
+    typeScriptParsingMode = getOptionValue('--experimental-enable-transformation') ? 'transform' : 'strip-only';
+    sourceMapEnabled = getOptionValue('--enable-source-maps');
     // Curry the transformSync function with the default options.
-    typeScriptParser = (source) => amaro.transformSync(source, defaultOptions);
+    typeScriptParser = amaro.transformSync;
   }
   return typeScriptParser;
 }
 
 /**
+ * @typedef {object} TransformOutput
+ * @property {string} code - The compiled code.
+ * @property {string} [map] - The source maps (optional).
+ *
  * Performs type-stripping to TypeScript source code.
  * @param {string} source TypeScript code to parse.
- * @returns {string} JavaScript code.
+ * @param {string} filename The filename of the source code.
+ * @returns {TransformOutput} The stripped TypeScript code.
  */
-function tsParse(source) {
+function stripTypes(source, filename) {
   // TODO(@marco-ippolito) Checking empty string or non string input should be handled in Amaro.
   if (!source || typeof source !== 'string') { return ''; }
   const parse = loadTypeScriptParser();
-  const { code } = parse(source);
+  const options = { __proto__: null, mode: typeScriptParsingMode, sourceMap: sourceMapEnabled, filename };
+  const { code, map } = parse(source, options);
+  if (map) {
+    const base64SourceMap = Buffer.from(map).toString('base64');
+    return `${code}\n\n//# sourceMappingURL=data:application/json;base64,${base64SourceMap}`;
+  }
   return code;
 }
 
@@ -354,7 +379,7 @@ module.exports = {
   loadBuiltinModule,
   makeRequireFunction,
   normalizeReferrerURL,
-  tsParse,
+  stripTypes,
   stripBOM,
   toRealPath,
   hasStartedUserCJSExecution() {
diff --git a/src/node_options.cc b/src/node_options.cc
index 210e3647d0b7eb..5a80e8689befb3 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -789,6 +789,12 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "Experimental type-stripping for TypeScript files.",
             &EnvironmentOptions::experimental_strip_types,
             kAllowedInEnvvar);
+  AddOption("--experimental-enable-transformation",
+            "enable transformation of TypeScript-only"
+            "syntax in JavaScript code",
+            &EnvironmentOptions::experimental_enable_transformation,
+            kAllowedInEnvvar);
+  Implies("--experimental-enable-transformation", "--experimental-strip-types");
   AddOption("--interactive",
             "always enter the REPL even if stdin does not appear "
             "to be a terminal",
diff --git a/src/node_options.h b/src/node_options.h
index a2ed8b1cd4d1d0..71f38861723931 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -239,6 +239,7 @@ class EnvironmentOptions : public Options {
   std::vector<std::string> preload_esm_modules;
 
   bool experimental_strip_types = false;
+  bool experimental_enable_transformation = false;
 
   std::vector<std::string> user_argv;
 
diff --git a/test/es-module/test-typescript-transform.mjs b/test/es-module/test-typescript-transform.mjs
new file mode 100644
index 00000000000000..926e2b8079ea2a
--- /dev/null
+++ b/test/es-module/test-typescript-transform.mjs
@@ -0,0 +1,124 @@
+import { skip, spawnPromisified } from '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
+import { match, strictEqual } from 'node:assert';
+import { test } from 'node:test';
+
+if (!process.config.variables.node_use_amaro) skip('Requires Amaro');
+
+test('execute a TypeScript file with transformation enabled', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-enable-transformation',
+    '--no-warnings',
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ]);
+
+  strictEqual(result.stderr, '');
+  match(result.stdout, /Hello, TypeScript!/);
+  strictEqual(result.code, 0);
+});
+
+test('execute a TypeScript file with transformation enabled and sourcemaps', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-enable-transformation',
+    '--enable-source-maps',
+    '--no-warnings',
+    fixtures.path('typescript/ts/transformation/test-enum.ts'),
+  ]);
+
+  strictEqual(result.stderr, '');
+  match(result.stdout, /Hello, TypeScript!/);
+  strictEqual(result.code, 0);
+});
+
+test('reconstruct error of a TypeScript file with transformation enabled and sourcemaps', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-enable-transformation',
+    '--enable-source-maps',
+    '--no-warnings',
+    fixtures.path('typescript/ts/transformation/test-enum-stacktrace.ts'),
+  ]);
+
+  match(result.stderr, /test-enum-stacktrace\.ts:4:7/);
+  strictEqual(result.stdout, '');
+  strictEqual(result.code, 1);
+});
+
+test('reconstruct error of a complex TypeScript file with transformation enabled and sourcemaps', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-enable-transformation',
+    '--enable-source-maps',
+    '--no-warnings',
+    fixtures.path('typescript/ts/transformation/test-complex-stacktrace.ts'),
+  ]);
+
+  match(result.stderr, /Calculation failed: Division by zero!/);
+  match(result.stderr, /test-complex-stacktrace\.ts:64/);
+  match(result.stderr, /test-complex-stacktrace\.ts:64:19/);
+  strictEqual(result.stdout, '');
+  strictEqual(result.code, 1);
+});
+
+test('reconstruct error of a complex TypeScript file with transformation enabled without sourcemaps', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-enable-transformation',
+    '--no-warnings',
+    fixtures.path('typescript/ts/transformation/test-complex-stacktrace.ts'),
+  ]);
+  // The stack trace is not reconstructed without sourcemaps.
+  match(result.stderr, /Calculation failed: Division by zero!/);
+  match(result.stderr, /test-complex-stacktrace\.ts:50/);
+  match(result.stderr, /test-complex-stacktrace\.ts:50:19/);
+  strictEqual(result.stdout, '');
+  strictEqual(result.code, 1);
+});
+
+// TODO (@marco-ippolito) this should fail
+test('elide unused imports', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-enable-transformation',
+    '--no-warnings',
+    fixtures.path('typescript/ts/transformation/test-unused-import.ts'),
+  ]);
+  strictEqual(result.stderr, '');
+  strictEqual(result.stdout, '');
+  strictEqual(result.code, 0);
+});
+
+test('execute a TypeScript file with namespace', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-enable-transformation',
+    '--no-warnings',
+    fixtures.path('typescript/ts/transformation/test-namespace.ts'),
+  ]);
+
+  strictEqual(result.stderr, '');
+  match(result.stdout, /Hello, TypeScript!/);
+  strictEqual(result.code, 0);
+});
+
+// Decorators are currently ignored by transpilation
+// and will be unusable until V8 adds support for them.
+test('execute a TypeScript file with decorator', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-enable-transformation',
+    '--no-warnings',
+    fixtures.path('typescript/ts/transformation/test-decorator.ts'),
+  ]);
+
+  strictEqual(result.stdout, '');
+  match(result.stderr, /Invalid or unexpected token/);
+  strictEqual(result.code, 1);
+});
+
+// Legacy module are supported, we probably should not.
+test('execute a TypeScript file with legacy-module', async () => {
+  const result = await spawnPromisified(process.execPath, [
+    '--experimental-enable-transformation',
+    '--no-warnings',
+    fixtures.path('typescript/ts/transformation/test-legacy-module.ts'),
+  ]);
+
+  strictEqual(result.stderr, '');
+  match(result.stdout, /Hello, TypeScript!/);
+  strictEqual(result.code, 0);
+});
diff --git a/test/fixtures/typescript/ts/transformation/test-complex-stacktrace.ts b/test/fixtures/typescript/ts/transformation/test-complex-stacktrace.ts
new file mode 100644
index 00000000000000..bc712ccf61e400
--- /dev/null
+++ b/test/fixtures/typescript/ts/transformation/test-complex-stacktrace.ts
@@ -0,0 +1,67 @@
+// Namespace
+namespace Mathematics {
+    // Enum
+    export enum Operation {
+        Add,
+        Subtract,
+        Multiply,
+        Divide
+    }
+
+    // Interface
+    export interface MathOperation {
+        perform(a: number, b: number): number;
+    }
+
+    // Generic function
+    export function executeOperation<T extends MathOperation>(op: T, x: number, y: number): number {
+        return op.perform(x, y);
+    }
+
+    // Class implementing interface
+    export class Calculator implements MathOperation {
+        constructor(private op: Operation) { }
+
+        perform(a: number, b: number): number {
+            switch (this.op) {
+                case Operation.Add: return a + b;
+                case Operation.Subtract: return a - b;
+                case Operation.Multiply: return a * b;
+                case Operation.Divide:
+                    if (b === 0) throw new Error("Division by zero!");
+                    return a / b;
+                default:
+                    throw new Error("Unknown operation");
+            }
+        }
+    }
+}
+
+// Using the namespace
+const calc = new Mathematics.Calculator(Mathematics.Operation.Divide);
+
+// Union type
+type Result = number | string;
+
+// Function with rest parameters and arrow syntax
+const processResults = (...results: Result[]): string => {
+    return results.map(r => r.toString()).join(", ");
+};
+
+// Async function with await
+async function performAsyncCalculation(a: number, b: number): Promise<number> {
+    const result = await Promise.resolve(Mathematics.executeOperation(calc, a, b));
+    return result;
+}
+
+// IIFE to create a block scope
+(async () => {
+    try {
+        const result = await performAsyncCalculation(10, 0);
+    } catch (error) {
+        if (error instanceof Error) {
+            // This line will throw an error
+            throw new Error("Calculation failed: " + error.message);
+        }
+    }
+})();
diff --git a/test/fixtures/typescript/ts/transformation/test-decorator.ts b/test/fixtures/typescript/ts/transformation/test-decorator.ts
new file mode 100644
index 00000000000000..9590ee2591398d
--- /dev/null
+++ b/test/fixtures/typescript/ts/transformation/test-decorator.ts
@@ -0,0 +1,10 @@
+function greet(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    descriptor.value = () => console.log('Hello, TypeScript!');
+}
+
+class Greeter {
+    @greet
+    sayHi() { }
+}
+
+new Greeter().sayHi();
diff --git a/test/fixtures/typescript/ts/transformation/test-enum-stacktrace.ts b/test/fixtures/typescript/ts/transformation/test-enum-stacktrace.ts
new file mode 100644
index 00000000000000..de6a9eda0a73e5
--- /dev/null
+++ b/test/fixtures/typescript/ts/transformation/test-enum-stacktrace.ts
@@ -0,0 +1,4 @@
+enum Foo {
+    A = "Hello, TypeScript!",
+}
+throw new Error(Foo.A);
diff --git a/test/fixtures/typescript/ts/transformation/test-enum.ts b/test/fixtures/typescript/ts/transformation/test-enum.ts
new file mode 100644
index 00000000000000..2c874cdfae7564
--- /dev/null
+++ b/test/fixtures/typescript/ts/transformation/test-enum.ts
@@ -0,0 +1,4 @@
+enum Foo {
+    A = "Hello, TypeScript!",
+}
+console.log(Foo.A);
diff --git a/test/fixtures/typescript/ts/transformation/test-legacy-module.ts b/test/fixtures/typescript/ts/transformation/test-legacy-module.ts
new file mode 100644
index 00000000000000..917adf23d82815
--- /dev/null
+++ b/test/fixtures/typescript/ts/transformation/test-legacy-module.ts
@@ -0,0 +1,12 @@
+module Greeter {
+    export interface Person {
+        name: string;
+    }
+
+    export function greet(person: Person): string {
+        return `Hello, ${person.name}!`;
+    }
+}
+
+const user: Greeter.Person = { name: "TypeScript" };
+console.log(Greeter.greet(user));
diff --git a/test/fixtures/typescript/ts/transformation/test-namespace.ts b/test/fixtures/typescript/ts/transformation/test-namespace.ts
new file mode 100644
index 00000000000000..a69134cb6cd1c1
--- /dev/null
+++ b/test/fixtures/typescript/ts/transformation/test-namespace.ts
@@ -0,0 +1,7 @@
+namespace Greeting {
+    export function sayHello(name: string) {
+        return `Hello, ${name}!`;
+    }
+}
+
+console.log(Greeting.sayHello("TypeScript!"));
diff --git a/test/fixtures/typescript/ts/transformation/test-unused-import.ts b/test/fixtures/typescript/ts/transformation/test-unused-import.ts
new file mode 100644
index 00000000000000..5390abeb96abf6
--- /dev/null
+++ b/test/fixtures/typescript/ts/transformation/test-unused-import.ts
@@ -0,0 +1,3 @@
+// @ts-ignore
+import { missing } from ".";
+export { };