tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/transformers/async-utilities.js

@@ -6,21 +6,21 @@ import { VisitorBase } from './visitor-base.js';
 export function getFunctionFlags(node) {
     let flags = 0 /* FunctionFlags.Normal */;
     switch (node.kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             if (getAsteriskToken(node) !== undefined)
                 flags |= 1 /* FunctionFlags.Generator */;
             if (hasAsyncModifier(node))
                 flags |= 2 /* FunctionFlags.Async */;
             break;
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             if (hasAsyncModifier(node))
                 flags |= 2 /* FunctionFlags.Async */;
             break;
-        case 177 /* SyntaxKind.Constructor */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             break;
         default:
             return 4 /* FunctionFlags.Invalid */;
@@ -35,13 +35,13 @@ function hasAsyncModifier(node) {
 }
 export function isFunctionLikeDeclaration(node) {
     switch (node.kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return true;
     }
     return false;
@@ -143,26 +143,26 @@ export class SuperAccess extends VisitorBase {
     /** Replaces super accesses in an async body, which ends up in a generator where `super` is invalid. */
     visit(node) {
         switch (node.kind) {
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 if (node instanceof CallExpression && isSuperProperty(node.expression))
                     return this.substituteCallExpression(node);
                 break;
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
                 if (node instanceof PropertyAccessExpression && node.expression.kind === 107 /* SyntaxKind.SuperKeyword */)
                     return this.factory.createPropertyAccessExpression(this.superBinding, node.name);
                 break;
-            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
                 if (node instanceof ElementAccessExpression && node.expression.kind === 107 /* SyntaxKind.SuperKeyword */)
                     return this.createSuperElementAccess(node.argumentExpression);
                 break;
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
                 return node;
         }
         return this.visitEachChild(node);

package/dist/api/compiler/transformers/async.d.ts

@@ -48,6 +48,5 @@ export declare class AsyncFunctions extends Transformer {
     private transformAsyncFunctionParameterList;
     private transformAsyncFunctionBody;
     private transformAsyncFunctionBodyWorker;
-    private convertToFunctionBlock;
     private getOriginalIfFunctionLike;
 }

package/dist/api/compiler/transformers/async.js

@@ -1,6 +1,6 @@
 // ES2017 async functions: the body becomes a generator run by `__awaiter`, with `await` as
 // `yield`, and `this`, `arguments` and `super` accesses captured outside of the generator.
-import { ArrowFunction, BindingPattern, Block, CatchClause, ConstructorDeclaration, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, Identifier, MethodDeclaration, ParameterDeclaration, SetAccessorDeclaration, SourceFile, VariableDeclaration, VariableDeclarationList, VariableStatement, YieldExpression, getBody, getName, getParameters, ArrayLiteralExpression, SpreadElement, ReturnStatement, AwaitExpression, QualifiedName, Token, getLabel, getPropertyName, } from '../ast.js';
+import { ArrowFunction, BindingPattern, Block, CatchClause, ConstructorDeclaration, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, Identifier, MethodDeclaration, ParameterDeclaration, SetAccessorDeclaration, SourceFile, VariableDeclaration, VariableDeclarationList, VariableStatement, YieldExpression, getBody, getName, getParameters, ArrayLiteralExpression, SpreadElement, AwaitExpression, QualifiedName, Token, getLabel, getPropertyName, } from '../ast.js';
 import { createAwaiterHelper, advancedAsyncSuperHelper, asyncSuperHelper } from '../printer/async-helpers.js';
 import { SuperAccess, getFunctionFlags, isFunctionLikeDeclaration, isSimpleParameterList, } from './async-utilities.js';
 import { convertBindingNameToTarget } from './destructuring.js';
@@ -56,24 +56,24 @@ export class AsyncFunctions extends Transformer {
         switch (node.kind) {
             case 133 /* SyntaxKind.AsyncKeyword */:
                 return undefined;
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 if (node instanceof SourceFile)
                     return this.visitSourceFile(node);
                 break;
-            case 224 /* SyntaxKind.AwaitExpression */:
+            case 225 /* SyntaxKind.AwaitExpression */:
                 if (node instanceof AwaitExpression)
                     return this.visitAwaitExpression(node);
                 break;
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 232 /* SyntaxKind.ClassExpression */: {
-                const flags = node.kind === 220 /* SyntaxKind.ArrowFunction */
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */: {
+                const flags = node.kind === 221 /* SyntaxKind.ArrowFunction */
                     ? 1 /* ContextFlags.NonTopLevel */
                     : 1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */;
                 const added = flags & ~this.contextFlags;
@@ -108,12 +108,12 @@ export class AsyncFunctions extends Transformer {
             return node;
         this.superAccess.track(node);
         switch (node.kind) {
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 177 /* SyntaxKind.Constructor */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 178 /* SyntaxKind.Constructor */:
                 return node;
             case 79 /* SyntaxKind.Identifier */:
                 if (this.argumentsBinding !== undefined &&
@@ -140,34 +140,34 @@ export class AsyncFunctions extends Transformer {
     // Async bodies
     visitAsyncBodyNode(node) {
         switch (node.kind) {
-            case 244 /* SyntaxKind.VariableStatement */:
+            case 245 /* SyntaxKind.VariableStatement */:
                 if (node instanceof VariableStatement)
                     return this.visitVariableStatementInAsyncBody(node);
                 break;
-            case 249 /* SyntaxKind.ForStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
                 if (node instanceof ForStatement)
                     return this.visitForStatementInAsyncBody(node);
                 break;
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
                 if (node instanceof ForInOrOfStatement)
                     return this.visitForInOrOfStatementInAsyncBody(node);
                 break;
-            case 300 /* SyntaxKind.CatchClause */:
+            case 301 /* SyntaxKind.CatchClause */:
                 if (node instanceof CatchClause)
                     return this.visitCatchClauseInAsyncBody(node);
                 break;
-            case 242 /* SyntaxKind.Block */:
-            case 256 /* SyntaxKind.SwitchStatement */:
-            case 270 /* SyntaxKind.CaseBlock */:
-            case 297 /* SyntaxKind.CaseClause */:
-            case 298 /* SyntaxKind.DefaultClause */:
-            case 259 /* SyntaxKind.TryStatement */:
-            case 247 /* SyntaxKind.DoStatement */:
-            case 248 /* SyntaxKind.WhileStatement */:
-            case 246 /* SyntaxKind.IfStatement */:
-            case 255 /* SyntaxKind.WithStatement */:
-            case 257 /* SyntaxKind.LabeledStatement */:
+            case 243 /* SyntaxKind.Block */:
+            case 257 /* SyntaxKind.SwitchStatement */:
+            case 271 /* SyntaxKind.CaseBlock */:
+            case 298 /* SyntaxKind.CaseClause */:
+            case 299 /* SyntaxKind.DefaultClause */:
+            case 260 /* SyntaxKind.TryStatement */:
+            case 248 /* SyntaxKind.DoStatement */:
+            case 249 /* SyntaxKind.WhileStatement */:
+            case 247 /* SyntaxKind.IfStatement */:
+            case 256 /* SyntaxKind.WithStatement */:
+            case 258 /* SyntaxKind.LabeledStatement */:
                 return this.asyncBodyVisitor.visitEachChild(node);
         }
         return this.visit(node);
@@ -209,7 +209,7 @@ export class AsyncFunctions extends Transformer {
             this.isVariableDeclarationListWithCollidingName(initializer)
             ? this.visitVariableDeclarationListWithCollidingNames(initializer, true)
             : this.visitNode(initializer);
-        return this.factory.updateForInOrOfStatement(node, node.kind === 251 /* SyntaxKind.ForOfStatement */ ? asToken(this.visitNode(node.awaitModifier)) : undefined, visitedInitializer, this.visitNode(node.expression), this.asyncBodyVisitor.visitEmbeddedStatement(node.statement));
+        return this.factory.updateForInOrOfStatement(node, node.kind === 252 /* SyntaxKind.ForOfStatement */ ? asToken(this.visitNode(node.awaitModifier)) : undefined, visitedInitializer, this.visitNode(node.expression), this.asyncBodyVisitor.visitEmbeddedStatement(node.statement));
     }
     visitForStatementInAsyncBody(node) {
         const initializer = node.initializer;
@@ -365,7 +365,7 @@ export class AsyncFunctions extends Transformer {
         if (name instanceof BindingPattern) {
             const elements = name.elements.nodes;
             for (let i = 0; i < elements.length; i++)
-                if (elements[i].kind !== 233 /* SyntaxKind.OmittedExpression */ && this.collidesWithParameterName(elements[i]))
+                if (elements[i].kind !== 234 /* SyntaxKind.OmittedExpression */ && this.collidesWithParameterName(elements[i]))
                     return true;
         }
         return false;
@@ -394,7 +394,7 @@ export class AsyncFunctions extends Transformer {
         else if (name instanceof BindingPattern) {
             const elements = name.elements.nodes;
             for (let i = 0; i < elements.length; i++)
-                if (elements[i].kind !== 233 /* SyntaxKind.OmittedExpression */)
+                if (elements[i].kind !== 234 /* SyntaxKind.OmittedExpression */)
                     this.hoistVariable(elements[i]);
         }
         return true;
@@ -452,7 +452,7 @@ export class AsyncFunctions extends Transformer {
         for (let i = 0; i < list.nodes.length; i++) {
             const parameter = list.nodes[i];
             if (parameter.initializer !== undefined || parameter.dotDotDotToken !== undefined) {
-                if (node.kind === 220 /* SyntaxKind.ArrowFunction */)
+                if (node.kind === 221 /* SyntaxKind.ArrowFunction */)
                     parameters.push(factory.created(new ParameterDeclaration(undefined, factory.createToken(25 /* SyntaxKind.DotDotDotToken */), factory.createUniqueName('args', 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */), undefined, undefined, undefined)));
                 break;
             }
@@ -464,7 +464,7 @@ export class AsyncFunctions extends Transformer {
         return result;
     }
     transformAsyncFunctionBody(node, outerParameters) {
-        const isArrow = node.kind === 220 /* SyntaxKind.ArrowFunction */;
+        const isArrow = node.kind === 221 /* SyntaxKind.ArrowFunction */;
         const factory = this.factory;
         const context = this.context;
         const superAccess = this.superAccess;
@@ -533,7 +533,9 @@ export class AsyncFunctions extends Transformer {
         else {
             result = createAwaiterHelper(factory, hasLexicalThis, argumentsExpression, innerParameters, asyncBody);
             if (captureLexicalArguments && this.argumentsUsed) {
-                const block = this.convertToFunctionBlock(result);
+                const block = context.convertToFunctionBlock(result, true);
+                if (!(result instanceof Block))
+                    context.setOriginal(block.statements.nodes[0], result);
                 result = factory.updateBlock(block, context.mergeEnvironmentList(block.statements, [this.createCaptureArgumentsStatement()]), block.multiLine);
             }
         }
@@ -569,21 +571,6 @@ export class AsyncFunctions extends Transformer {
         block.end = body.end;
         return block;
     }
-    convertToFunctionBlock(node) {
-        if (node instanceof Block)
-            return node;
-        const factory = this.factory;
-        const statement = factory.created(new ReturnStatement(node));
-        statement.pos = node.pos;
-        statement.end = node.end;
-        this.context.setOriginal(statement, node);
-        const block = factory.createBlock([statement], true);
-        block.statements.pos = node.pos;
-        block.statements.end = node.end;
-        block.pos = node.pos;
-        block.end = node.end;
-        return block;
-    }
     getOriginalIfFunctionLike(node) {
         const original = this.context.mostOriginal(node);
         return isFunctionLikeDeclaration(original) ? original : node;
@@ -598,7 +585,7 @@ function recordDeclarationName(node, names) {
     else if (name instanceof BindingPattern) {
         const elements = name.elements.nodes;
         for (let i = 0; i < elements.length; i++)
-            if (elements[i].kind !== 233 /* SyntaxKind.OmittedExpression */)
+            if (elements[i].kind !== 234 /* SyntaxKind.OmittedExpression */)
                 recordDeclarationName(elements[i], names);
     }
     return true;
@@ -609,30 +596,30 @@ function isIdentifierNameOrLabel(node) {
     if (parent === undefined)
         return false;
     switch (parent.kind) {
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 306 /* SyntaxKind.EnumMember */:
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 307 /* SyntaxKind.EnumMember */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
             return getName(parent) === node;
-        case 167 /* SyntaxKind.QualifiedName */:
+        case 168 /* SyntaxKind.QualifiedName */:
             return parent instanceof QualifiedName && parent.right === node;
-        case 209 /* SyntaxKind.BindingElement */:
-        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
             return getPropertyName(parent) === node;
-        case 282 /* SyntaxKind.ExportSpecifier */:
-        case 292 /* SyntaxKind.JsxAttribute */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 288 /* SyntaxKind.JsxClosingElement */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
+        case 293 /* SyntaxKind.JsxAttribute */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 289 /* SyntaxKind.JsxClosingElement */:
             return true;
-        case 257 /* SyntaxKind.LabeledStatement */:
-        case 253 /* SyntaxKind.BreakStatement */:
-        case 252 /* SyntaxKind.ContinueStatement */:
+        case 258 /* SyntaxKind.LabeledStatement */:
+        case 254 /* SyntaxKind.BreakStatement */:
+        case 253 /* SyntaxKind.ContinueStatement */:
             return getLabel(parent) === node;
     }
     return false;

package/dist/api/compiler/transformers/class-fields.d.ts

@@ -122,6 +122,7 @@ export declare class ClassFieldsTransformer extends Transformer {
     /** `super.x` in a static initializer, with the class and its base available. */
     private staticSuperData;
     private visitPropertyAccessExpression;
+    /** Visits only the expression of a property access, with `visitor`, so that its name is never substituted. */
     private visitPropertyAccessExpressionForSubstitution;
     private visitElementAccessExpression;
     private visitPreOrPostfixUnaryExpression;