tsc-ts 0.0.4 → 0.0.6

package/src/compiler/printer/async-helpers.ts

@@ -0,0 +1,183 @@
+// Runtime helpers for lowering async functions, async generators and `for await`.
+import { type CallExpression, FunctionExpression, type Node, type NodeList } from '../ast.js';
+import { SyntaxKind } from '../syntax-kind.js';
+import { EmitFlags } from './emit-flags.js';
+import type { NodeFactory } from './factory.js';
+import { EmitHelper, noPriority } from './helpers.js';
+
+export const awaitHelper = new EmitHelper(
+  'typescript:await',
+  false,
+  `var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }`,
+  noPriority,
+  [],
+  '__await',
+  '',
+);
+
+export const asyncGeneratorHelper = new EmitHelper(
+  'typescript:asyncGenerator',
+  false,
+  `var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};`,
+  noPriority,
+  [awaitHelper],
+  '__asyncGenerator',
+  '',
+);
+
+export const asyncDelegatorHelper = new EmitHelper(
+  'typescript:asyncDelegator',
+  false,
+  `var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};`,
+  noPriority,
+  [awaitHelper],
+  '__asyncDelegator',
+  '',
+);
+
+export const asyncValuesHelper = new EmitHelper(
+  'typescript:asyncValues',
+  false,
+  `var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};`,
+  noPriority,
+  [],
+  '__asyncValues',
+  '',
+);
+
+export const awaiterHelper = new EmitHelper(
+  'typescript:awaiter',
+  false,
+  `var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};`,
+  5,
+  [],
+  '__awaiter',
+  '',
+);
+
+/** Scoped: `const _superIndex = name => super[name];` */
+export const asyncSuperHelper = new EmitHelper(
+  'typescript:async-super',
+  true,
+  '\nconst {name} = name => super[name];',
+  noPriority,
+  [],
+  '',
+  '_superIndex',
+);
+
+/** Scoped: a `_superIndex` whose results can also be assigned to. */
+export const advancedAsyncSuperHelper = new EmitHelper(
+  'typescript:advanced-async-super',
+  true,
+  '\nconst {name} = (function (geti, seti) {\n' +
+    '    const cache = Object.create(null);\n' +
+    '    return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n' +
+    '})(name => super[name], (name, value) => super[name] = value);',
+  noPriority,
+  [],
+  '',
+  '_superIndex',
+);
+
+/** `__await(expression)` */
+export function createAwaitHelper(factory: NodeFactory, expression: Node): CallExpression {
+  factory.context.requestEmitHelper(awaitHelper);
+  return factory.createCallExpression(factory.createUnscopedHelperName('__await'), [expression]);
+}
+
+/** `__asyncGenerator(this, arguments, generatorFunc)` */
+export function createAsyncGeneratorHelper(
+  factory: NodeFactory,
+  generatorFunc: Node,
+  hasLexicalThis: boolean,
+): CallExpression {
+  factory.context.requestEmitHelper(awaitHelper);
+  factory.context.requestEmitHelper(asyncGeneratorHelper);
+  factory.context.addEmitFlags(generatorFunc, EmitFlags.AsyncFunctionBody | EmitFlags.ReuseTempVariableScope);
+  const thisArg = createThisArgument(factory, hasLexicalThis);
+  return factory.createCallExpression(factory.createUnscopedHelperName('__asyncGenerator'), [
+    thisArg,
+    factory.createIdentifier('arguments'),
+    generatorFunc,
+  ]);
+}
+
+/** `__asyncDelegator(expression)` */
+export function createAsyncDelegatorHelper(factory: NodeFactory, expression: Node): CallExpression {
+  factory.context.requestEmitHelper(awaitHelper);
+  factory.context.requestEmitHelper(asyncDelegatorHelper);
+  return factory.createCallExpression(factory.createUnscopedHelperName('__asyncDelegator'), [expression]);
+}
+
+/** `__asyncValues(expression)` */
+export function createAsyncValuesHelper(factory: NodeFactory, expression: Node): CallExpression {
+  factory.context.requestEmitHelper(asyncValuesHelper);
+  return factory.createCallExpression(factory.createUnscopedHelperName('__asyncValues'), [expression]);
+}
+
+/** `__awaiter(this, arguments, void 0, function* (parameters) { body })` */
+export function createAwaiterHelper(
+  factory: NodeFactory,
+  hasLexicalThis: boolean,
+  argumentsExpression: Node | undefined,
+  parameters: NodeList | undefined,
+  body: Node,
+): CallExpression {
+  factory.context.requestEmitHelper(awaiterHelper);
+  const generatorFunc = factory.created(
+    new FunctionExpression(
+      undefined,
+      factory.createToken(SyntaxKind.AsteriskToken),
+      undefined,
+      undefined,
+      parameters !== undefined ? parameters : factory.createNodeList([]),
+      undefined,
+      undefined,
+      body,
+    ),
+  );
+  factory.context.addEmitFlags(generatorFunc, EmitFlags.AsyncFunctionBody | EmitFlags.ReuseTempVariableScope);
+  const thisArg = createThisArgument(factory, hasLexicalThis);
+  return factory.createCallExpression(factory.createUnscopedHelperName('__awaiter'), [
+    thisArg,
+    argumentsExpression !== undefined ? argumentsExpression : factory.createVoidZero(),
+    factory.createVoidZero(),
+    generatorFunc,
+  ]);
+}
+
+/** `this` when the function has a lexical `this`, else `void 0`. */
+function createThisArgument(factory: NodeFactory, hasLexicalThis: boolean): Node {
+  if (hasLexicalThis) return factory.createKeywordExpression(SyntaxKind.ThisKeyword);
+  return factory.createVoidZero();
+}

package/src/compiler/printer/auto-generate.ts

@@ -0,0 +1,27 @@
+// Generated names: what each one is generated from, and the ids that tie the printed text of its copies together.
+import type { Node } from '../ast.js';
+import type { GeneratedIdentifierFlags } from './emit-flags.js';
+
+export class AutoGenerateInfo {
+  readonly flags: GeneratedIdentifierFlags;
+  /** Generated names with the same id print the same text; clones keep it. */
+  readonly id: number;
+  readonly prefix: string;
+  readonly suffix: string;
+  /** For `GeneratedIdentifierFlags.Node`, the node the name is generated from. */
+  readonly node: Node | undefined;
+
+  constructor(flags: GeneratedIdentifierFlags, id: number, prefix: string, suffix: string, node: Node | undefined) {
+    this.flags = flags;
+    this.id = id;
+    this.prefix = prefix;
+    this.suffix = suffix;
+    this.node = node;
+  }
+}
+
+let nextAutoGenerateId = 1;
+
+export function newAutoGenerateId(): number {
+  return nextAutoGenerateId++;
+}

package/src/compiler/printer/decorator-helpers.ts

@@ -0,0 +1,218 @@
+// Runtime helpers for legacy (`experimentalDecorators`) and standard decorators, and the
+// function-naming helpers class transforms share.
+import { ArrayLiteralExpression, type CallExpression, type Node } from '../ast.js';
+import { TokenFlags } from '../types.js';
+import type { NodeFactory } from './factory.js';
+import { EmitHelper, noPriority } from './helpers.js';
+
+export const decorateHelper = new EmitHelper(
+  'typescript:decorate',
+  false,
+  `var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};`,
+  2,
+  [],
+  '__decorate',
+  '',
+);
+
+export const metadataHelper = new EmitHelper(
+  'typescript:metadata',
+  false,
+  `var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};`,
+  3,
+  [],
+  '__metadata',
+  '',
+);
+
+export const paramHelper = new EmitHelper(
+  'typescript:param',
+  false,
+  `var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};`,
+  4,
+  [],
+  '__param',
+  '',
+);
+
+export const esDecorateHelper = new EmitHelper(
+  'typescript:esDecorate',
+  false,
+  `var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};`,
+  2,
+  [],
+  '__esDecorate',
+  '',
+);
+
+export const runInitializersHelper = new EmitHelper(
+  'typescript:runInitializers',
+  false,
+  `var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};`,
+  2,
+  [],
+  '__runInitializers',
+  '',
+);
+
+export const propKeyHelper = new EmitHelper(
+  'typescript:propKey',
+  false,
+  `var __propKey = (this && this.__propKey) || function (x) {
+    return typeof x === "symbol" ? x : "".concat(x);
+};`,
+  noPriority,
+  [],
+  '__propKey',
+  '',
+);
+
+export const setFunctionNameHelper = new EmitHelper(
+  'typescript:setFunctionName',
+  false,
+  `var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};`,
+  noPriority,
+  [],
+  '__setFunctionName',
+  '',
+);
+
+/** `__decorate([decorators], target, memberName, descriptor)`; the member name and descriptor are optional. */
+export function createDecorateHelper(
+  factory: NodeFactory,
+  decorators: Node[],
+  target: Node,
+  memberName: Node | undefined,
+  descriptor: Node | undefined,
+): CallExpression {
+  factory.context.requestEmitHelper(decorateHelper);
+  const args: Node[] = [factory.created(new ArrayLiteralExpression(factory.createNodeList(decorators), true)), target];
+  if (memberName !== undefined) {
+    args.push(memberName);
+    if (descriptor !== undefined) args.push(descriptor);
+  }
+  return factory.createCallExpression(factory.createUnscopedHelperName('__decorate'), args);
+}
+
+/** `__metadata("key", value)` */
+export function createMetadataHelper(factory: NodeFactory, key: string, value: Node): CallExpression {
+  factory.context.requestEmitHelper(metadataHelper);
+  return factory.createCallExpression(factory.createUnscopedHelperName('__metadata'), [
+    factory.createStringLiteral(key, TokenFlags.None),
+    value,
+  ]);
+}
+
+/** `__param(index, decorator)`, with the range of the decorator. */
+export function createParamHelper(
+  factory: NodeFactory,
+  expression: Node,
+  parameterOffset: number,
+  pos: number,
+  end: number,
+): CallExpression {
+  factory.context.requestEmitHelper(paramHelper);
+  const helper = factory.createCallExpression(factory.createUnscopedHelperName('__param'), [
+    factory.createNumericLiteral(String(parameterOffset)),
+    expression,
+  ]);
+  helper.pos = pos | 0;
+  helper.end = end | 0;
+  return helper;
+}
+
+/** `__esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers)` */
+export function createESDecorateHelper(
+  factory: NodeFactory,
+  ctor: Node,
+  descriptorIn: Node,
+  decorators: Node,
+  contextIn: Node,
+  initializers: Node,
+  extraInitializers: Node,
+): CallExpression {
+  factory.context.requestEmitHelper(esDecorateHelper);
+  return factory.createCallExpression(factory.createUnscopedHelperName('__esDecorate'), [
+    ctor,
+    descriptorIn,
+    decorators,
+    contextIn,
+    initializers,
+    extraInitializers,
+  ]);
+}
+
+/** `__runInitializers(thisArg, initializers, value)`; the value is optional. */
+export function createRunInitializersHelper(
+  factory: NodeFactory,
+  thisArg: Node,
+  initializers: Node,
+  value: Node | undefined,
+): CallExpression {
+  factory.context.requestEmitHelper(runInitializersHelper);
+  const args = value !== undefined ? [thisArg, initializers, value] : [thisArg, initializers];
+  return factory.createCallExpression(factory.createUnscopedHelperName('__runInitializers'), args);
+}
+
+/** `__propKey(expression)` */
+export function createPropKeyHelper(factory: NodeFactory, expression: Node): CallExpression {
+  factory.context.requestEmitHelper(propKeyHelper);
+  return factory.createCallExpression(factory.createUnscopedHelperName('__propKey'), [expression]);
+}
+
+/** `__setFunctionName(fn, name, "prefix")`; an empty prefix is omitted. */
+export function createSetFunctionNameHelper(
+  factory: NodeFactory,
+  fn: Node,
+  name: Node,
+  prefix: string,
+): CallExpression {
+  factory.context.requestEmitHelper(setFunctionNameHelper);
+  const args: Node[] = [fn, name];
+  if (prefix.length > 0) args.push(factory.createStringLiteral(prefix, TokenFlags.None));
+  return factory.createCallExpression(factory.createUnscopedHelperName('__setFunctionName'), args);
+}