tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/reparser.js

@@ -127,7 +127,7 @@ export class Reparser {
                 type = this.reparseJSDocTypeLiteral(typeExpression);
             else
                 throw new Error('typedef tag type expression should be a name reference or a type expression');
-            const typeAlias = new TypeAliasDeclaration(345 /* SyntaxKind.JSTypeAliasDeclaration */, modifiers, name, typeParameters, type);
+            const typeAlias = new TypeAliasDeclaration(346 /* SyntaxKind.JSTypeAliasDeclaration */, modifiers, name, typeParameters, type);
             this.finishReparsedNode(typeAlias, tag);
             this.attachReparsedJSDoc(typeAlias, jsDoc);
             p.reparseList.push(this.wrapInJSDocNamespace(fullName, typeAlias, false));
@@ -139,7 +139,7 @@ export class Reparser {
             const functionType = this.reparseJSDocSignature(tag.typeExpression, tag, jsDoc, tag, undefined);
             const name = this.cloneTypeAliasName(this.getInnermostNameOfJSDocNamespace(fullName));
             const typeParameters = this.gatherTypeParameters(jsDoc, true);
-            const typeAlias = new TypeAliasDeclaration(345 /* SyntaxKind.JSTypeAliasDeclaration */, modifiers, name, typeParameters, functionType);
+            const typeAlias = new TypeAliasDeclaration(346 /* SyntaxKind.JSTypeAliasDeclaration */, modifiers, name, typeParameters, functionType);
             this.finishReparsedNode(typeAlias, tag);
             this.attachReparsedJSDoc(typeAlias, jsDoc);
             p.reparseList.push(this.wrapInJSDocNamespace(fullName, typeAlias, false));
@@ -162,16 +162,16 @@ export class Reparser {
                 p.reparsedClones.push(copy);
                 attributes = copy;
             }
-            const importDeclaration = new ImportDeclaration(346 /* SyntaxKind.JSImportDeclaration */, undefined, importClause, moduleSpecifier, attributes);
+            const importDeclaration = new ImportDeclaration(347 /* SyntaxKind.JSImportDeclaration */, undefined, importClause, moduleSpecifier, attributes);
             this.finishReparsedNode(importDeclaration, tag);
             p.reparseList.push(importDeclaration);
             return true;
         }
         if (tag instanceof JSDocOverloadTag) {
             // Overload signatures only for functions, methods and constructors outside object literals.
-            if ((parent.kind === 263 /* SyntaxKind.FunctionDeclaration */ ||
-                parent.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
-                parent.kind === 177 /* SyntaxKind.Constructor */) &&
+            if ((parent.kind === 264 /* SyntaxKind.FunctionDeclaration */ ||
+                parent.kind === 176 /* SyntaxKind.MethodDeclaration */ ||
+                parent.kind === 178 /* SyntaxKind.Constructor */) &&
                 !p.inObjectLiteralMembers())
                 p.reparseList.push(this.reparseJSDocSignature(tag.typeExpression, parent, jsDoc, tag, getModifiers(parent)));
             return true;
@@ -207,10 +207,10 @@ export class Reparser {
         else if (fun instanceof MethodDeclaration) {
             methodName = this.deepCloneReparse(this.checkNonIdentifierName(fun.name));
         }
-        else if (fun.kind !== 177 /* SyntaxKind.Constructor */ && fun.kind !== 331 /* SyntaxKind.JSDocCallbackTag */) {
+        else if (fun.kind !== 178 /* SyntaxKind.Constructor */ && fun.kind !== 332 /* SyntaxKind.JSDocCallbackTag */) {
             throw new Error('Unexpected kind ' + fun.kind);
         }
-        const typeParameters = tag.kind !== 331 /* SyntaxKind.JSDocCallbackTag */ ? this.gatherTypeParameters(jsDoc, false) : undefined;
+        const typeParameters = tag.kind !== 332 /* SyntaxKind.JSDocCallbackTag */ ? this.gatherTypeParameters(jsDoc, false) : undefined;
         const parameters = [];
         const signatureParameters = jsSignature instanceof JSDocSignature ? jsSignature.parameters : undefined;
         if (signatureParameters !== undefined) {
@@ -348,7 +348,7 @@ export class Reparser {
             return undefined;
         for (const tag of tags.nodes) {
             // With a @typedef or @callback, @template declares the defined type's type parameters.
-            if (!typedefOrCallback && (tag.kind === 338 /* SyntaxKind.JSDocTypedefTag */ || tag.kind === 331 /* SyntaxKind.JSDocCallbackTag */))
+            if (!typedefOrCallback && (tag.kind === 339 /* SyntaxKind.JSDocTypedefTag */ || tag.kind === 332 /* SyntaxKind.JSDocCallbackTag */))
                 return undefined;
             if (!(tag instanceof JSDocTemplateTag))
                 continue;
@@ -382,13 +382,13 @@ export class Reparser {
     }
     reparseHosted(tag, parent, jsDoc) {
         switch (tag.kind) {
-            case 336 /* SyntaxKind.JSDocTypeTag */:
+            case 337 /* SyntaxKind.JSDocTypeTag */:
                 return this.reparseTypeTag(tag, parent);
-            case 342 /* SyntaxKind.JSDocSatisfiesTag */:
+            case 343 /* SyntaxKind.JSDocSatisfiesTag */:
                 if (tag instanceof JSDocSatisfiesTag)
                     this.reparseSatisfiesTag(tag, parent);
                 return true;
-            case 337 /* SyntaxKind.JSDocTemplateTag */: {
+            case 338 /* SyntaxKind.JSDocTemplateTag */: {
                 const fun = getFunctionLikeHost(parent);
                 if (fun !== undefined) {
                     if (getTypeParameters(fun) === undefined && getFullSignature(fun) === undefined) {
@@ -396,7 +396,7 @@ export class Reparser {
                         this.finishMutatedNode(fun);
                     }
                 }
-                else if (parent.kind === 264 /* SyntaxKind.ClassDeclaration */ || parent.kind === 232 /* SyntaxKind.ClassExpression */) {
+                else if (parent.kind === 265 /* SyntaxKind.ClassDeclaration */ || parent.kind === 233 /* SyntaxKind.ClassExpression */) {
                     if (getClassTypeParameters(parent) === undefined) {
                         setClassTypeParameters(parent, this.gatherTypeParameters(jsDoc, false));
                         this.finishMutatedNode(parent);
@@ -404,7 +404,7 @@ export class Reparser {
                 }
                 return true;
             }
-            case 333 /* SyntaxKind.JSDocParameterTag */: {
+            case 334 /* SyntaxKind.JSDocParameterTag */: {
                 const fun = getFunctionLikeHost(parent);
                 if (fun !== undefined && getFullSignature(fun) === undefined && tag instanceof JSDocParameterOrPropertyTag) {
                     const param = findMatchingParameter(fun, tag, jsDoc);
@@ -422,7 +422,7 @@ export class Reparser {
                 }
                 return true;
             }
-            case 335 /* SyntaxKind.JSDocThisTag */: {
+            case 336 /* SyntaxKind.JSDocThisTag */: {
                 const fun = getFunctionLikeHost(parent);
                 if (fun !== undefined && tag instanceof JSDocThisTag) {
                     const parameters = getParameters(fun);
@@ -445,7 +445,7 @@ export class Reparser {
                 }
                 return true;
             }
-            case 334 /* SyntaxKind.JSDocReturnTag */: {
+            case 335 /* SyntaxKind.JSDocReturnTag */: {
                 const fun = getFunctionLikeHost(parent);
                 if (fun !== undefined && getFullSignature(fun) === undefined) {
                     const typeExpression = getTypeExpression(tag);
@@ -456,17 +456,17 @@ export class Reparser {
                 }
                 return true;
             }
-            case 329 /* SyntaxKind.JSDocReadonlyTag */:
-            case 327 /* SyntaxKind.JSDocPrivateTag */:
-            case 326 /* SyntaxKind.JSDocPublicTag */:
-            case 328 /* SyntaxKind.JSDocProtectedTag */:
-            case 330 /* SyntaxKind.JSDocOverrideTag */:
+            case 330 /* SyntaxKind.JSDocReadonlyTag */:
+            case 328 /* SyntaxKind.JSDocPrivateTag */:
+            case 327 /* SyntaxKind.JSDocPublicTag */:
+            case 329 /* SyntaxKind.JSDocProtectedTag */:
+            case 331 /* SyntaxKind.JSDocOverrideTag */:
                 return this.reparseModifierTag(tag, parent);
-            case 324 /* SyntaxKind.JSDocImplementsTag */:
+            case 325 /* SyntaxKind.JSDocImplementsTag */:
                 if (tag instanceof JSDocImplementsTag)
                     this.reparseImplementsTag(tag, parent);
                 return true;
-            case 323 /* SyntaxKind.JSDocAugmentsTag */:
+            case 324 /* SyntaxKind.JSDocAugmentsTag */:
                 if (tag instanceof JSDocAugmentsTag)
                     this.reparseAugmentsTag(tag, parent);
                 return true;
@@ -476,7 +476,7 @@ export class Reparser {
     reparseTypeTag(tag, parent) {
         const typeExpression = getTypeExpression(tag);
         switch (parent.kind) {
-            case 244 /* SyntaxKind.VariableStatement */:
+            case 245 /* SyntaxKind.VariableStatement */:
                 if (parent instanceof VariableStatement)
                     for (const declaration of parent.declarationList.declarations.nodes)
                         if (declaration instanceof VariableDeclaration &&
@@ -487,26 +487,26 @@ export class Reparser {
                             return true;
                         }
                 break;
-            case 261 /* SyntaxKind.VariableDeclaration */:
-            case 278 /* SyntaxKind.ExportAssignment */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 303 /* SyntaxKind.PropertyAssignment */:
-            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
+            case 279 /* SyntaxKind.ExportAssignment */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 if (getType(parent) === undefined && typeExpression !== undefined) {
                     setType(parent, this.addDeepCloneReparse(getType(typeExpression)));
                     this.finishMutatedNode(parent);
                     return true;
                 }
                 break;
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 if (getType(parent) === undefined && typeExpression !== undefined) {
                     setType(parent, this.reparseJSDocTypeLiteral(getType(typeExpression)));
                     this.finishMutatedNode(parent);
                     return true;
                 }
                 break;
-            case 245 /* SyntaxKind.ExpressionStatement */:
+            case 246 /* SyntaxKind.ExpressionStatement */:
                 if (parent instanceof ExpressionStatement) {
                     const bin = parent.expression;
                     if (bin instanceof BinaryExpression && isAssignmentDeclaration(bin) && typeExpression !== undefined) {
@@ -516,8 +516,8 @@ export class Reparser {
                     }
                 }
                 break;
-            case 254 /* SyntaxKind.ReturnStatement */:
-            case 218 /* SyntaxKind.ParenthesizedExpression */: {
+            case 255 /* SyntaxKind.ReturnStatement */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */: {
                 const expression = getExpressionOfReturnOrParenthesized(parent);
                 if (expression !== undefined && typeExpression !== undefined) {
                     setExpression(parent, this.makeNewCast(this.addDeepCloneReparse(getType(typeExpression)), expression, true));
@@ -560,9 +560,9 @@ export class Reparser {
                     break;
                 }
         }
-        else if (parent.kind === 261 /* SyntaxKind.VariableDeclaration */ ||
-            parent.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
-            parent.kind === 303 /* SyntaxKind.PropertyAssignment */) {
+        else if (parent.kind === 262 /* SyntaxKind.VariableDeclaration */ ||
+            parent.kind === 174 /* SyntaxKind.PropertyDeclaration */ ||
+            parent.kind === 304 /* SyntaxKind.PropertyAssignment */) {
             const initializer = getInitializer(parent);
             if (initializer !== undefined) {
                 setInitializer(parent, this.makeNewCast(this.addDeepCloneReparse(getType(typeExpression)), initializer, false));
@@ -576,9 +576,9 @@ export class Reparser {
                 this.finishMutatedNode(parent);
             }
         }
-        else if (parent.kind === 254 /* SyntaxKind.ReturnStatement */ ||
-            parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */ ||
-            parent.kind === 278 /* SyntaxKind.ExportAssignment */) {
+        else if (parent.kind === 255 /* SyntaxKind.ReturnStatement */ ||
+            parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */ ||
+            parent.kind === 279 /* SyntaxKind.ExportAssignment */) {
             const expression = getExpressionOfReturnOrParenthesized(parent);
             if (expression !== undefined) {
                 setExpression(parent, this.makeNewCast(this.addDeepCloneReparse(getType(typeExpression)), expression, false));
@@ -598,32 +598,32 @@ export class Reparser {
         if (parent instanceof ExpressionStatement)
             parent = parent.expression;
         switch (parent.kind) {
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 // In object literals these aren't class members: reparsed modifiers would cause spurious grammar errors.
                 if (this.p.inObjectLiteralMembers())
                     return false;
                 break;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 227 /* SyntaxKind.BinaryExpression */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 228 /* SyntaxKind.BinaryExpression */:
                 break;
             default:
                 return false;
         }
         let keyword = 0 /* SyntaxKind.Unknown */;
         switch (tag.kind) {
-            case 329 /* SyntaxKind.JSDocReadonlyTag */:
+            case 330 /* SyntaxKind.JSDocReadonlyTag */:
                 keyword = 148 /* SyntaxKind.ReadonlyKeyword */;
                 break;
-            case 327 /* SyntaxKind.JSDocPrivateTag */:
+            case 328 /* SyntaxKind.JSDocPrivateTag */:
                 keyword = 122 /* SyntaxKind.PrivateKeyword */;
                 break;
-            case 326 /* SyntaxKind.JSDocPublicTag */:
+            case 327 /* SyntaxKind.JSDocPublicTag */:
                 keyword = 124 /* SyntaxKind.PublicKeyword */;
                 break;
-            case 328 /* SyntaxKind.JSDocProtectedTag */:
+            case 329 /* SyntaxKind.JSDocProtectedTag */:
                 keyword = 123 /* SyntaxKind.ProtectedKeyword */;
                 break;
             default:
@@ -648,7 +648,7 @@ export class Reparser {
         return true;
     }
     reparseImplementsTag(tag, parent) {
-        if (parent.kind !== 264 /* SyntaxKind.ClassDeclaration */ && parent.kind !== 232 /* SyntaxKind.ClassExpression */)
+        if (parent.kind !== 265 /* SyntaxKind.ClassDeclaration */ && parent.kind !== 233 /* SyntaxKind.ClassExpression */)
             return false;
         const className = tag.className;
         const heritageClauses = getHeritageClauses(parent);
@@ -688,10 +688,14 @@ export class Reparser {
                 return false;
             const target = clause.types.nodes[0];
             const source = tag.className;
+            // The tag's type arguments apply to an `extends` clause without any: one naming the same
+            // entity, or another expression such as a call (`extends mixin(Base)`), but not `null`.
             if (target instanceof ExpressionWithTypeArguments &&
-                hasSamePropertyAccessName(target.expression, source.expression) &&
                 target.typeArguments === undefined &&
-                source.typeArguments !== undefined) {
+                source.typeArguments !== undefined &&
+                target.expression.kind !== 105 /* SyntaxKind.NullKeyword */ &&
+                (!isEntityNameExpression(target.expression, false) ||
+                    hasSamePropertyAccessName(target.expression, source.expression))) {
                 const newArguments = [];
                 for (const arg of source.typeArguments.nodes)
                     newArguments.push(this.addDeepCloneReparse(arg));
@@ -748,7 +752,7 @@ export class Reparser {
         const block = new ModuleBlock(this.p.newNodeList(fullName.pos, fullName.end, [wrapped]));
         this.finishReparsedNode(block, fullName);
         const modifiers = nested ? this.createExportModifier(fullName) : undefined;
-        const result = new ModuleDeclaration(modifiers, 145 /* SyntaxKind.NamespaceKeyword */, this.addDeepCloneReparse(fullName.name), block);
+        const result = new ModuleDeclaration(modifiers, 145 /* SyntaxKind.NamespaceKeyword */, this.addDeepCloneReparse(fullName.name), undefined, block);
         this.finishReparsedNode(result, fullName);
         this.p.reparsedClones.push(result);
         return result;
@@ -760,7 +764,7 @@ function findMatchingParameter(fun, parameterTag, jsDoc) {
     let paramCount = -1;
     if (jsDoc.tags !== undefined)
         for (const tag of jsDoc.tags.nodes)
-            if (tag.kind === 333 /* SyntaxKind.JSDocParameterTag */) {
+            if (tag.kind === 334 /* SyntaxKind.JSDocParameterTag */) {
                 paramCount++;
                 if (tag === parameterTag) {
                     tagIndex = paramCount;
@@ -816,7 +820,7 @@ function getFunctionLikeHost(host) {
             fun = first instanceof VariableDeclaration ? first.initializer : undefined;
         }
     }
-    else if (host.kind === 303 /* SyntaxKind.PropertyAssignment */ || host.kind === 173 /* SyntaxKind.PropertyDeclaration */) {
+    else if (host.kind === 304 /* SyntaxKind.PropertyAssignment */ || host.kind === 174 /* SyntaxKind.PropertyDeclaration */) {
         fun = getInitializer(host);
     }
     else if (host instanceof ExportAssignment) {

package/dist/api/compiler/scanner.d.ts

@@ -172,10 +172,19 @@ export declare class Scanner {
     /** Scans a merge conflict marker; returns true if it is skipped as trivia. */
     private scanConflictMarker;
     private processCommentDirective;
-    /** @internal Scans an identifier after `prefixLength` units; sets the token value. */
-    scanIdentifier(prefixLength: number): boolean;
+    /**
+     * @internal Scans an identifier after `prefixLength` units; sets the token value. `variant`
+     * decides the identifier parts: JSX and JSDoc names also take `-`, and regular expression group
+     * names take a surrogate pair written as two `\u` escapes.
+     */
+    scanIdentifier(prefixLength: number, variant: IdentifierVariant): boolean;
     /** Scans identifier parts including `\u` escapes and returns their cooked text. */
     private scanIdentifierParts;
+    /**
+     * At `\`: scans a `\u` escape of an identifier start (`isStart`) or part and returns its code point,
+     * or returns -1 and leaves the scanner unchanged.
+     */
+    private scanIdentifierEscape;
     private scanInvalidCharacter;
     /** Scans a quoted string and sets its cooked value. */
     private scanString;
@@ -238,6 +247,14 @@ export declare class Scanner {
     canFollowJSDocAt(): boolean;
     scanJSDocToken(): SyntaxKind;
 }
+/** Which characters an identifier scan takes after its start. */
+export declare const enum IdentifierVariant {
+    Standard = 0,
+    /** JSX and JSDoc names, which take `-`. */
+    JSX = 1,
+    /** Regular expression group names, which take a surrogate pair written as two `\u` escapes. */
+    RegExpGroupName = 2
+}
 /** Whether `text` has a `<<<<<<<`, `|||||||`, `=======` or `>>>>>>>` marker at `pos`. */
 export declare function isConflictMarkerTrivia(text: string, pos: number): boolean;
 /** The `#!` line at the start of `text`, or `''`. */