tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/checker-declaration-order.js

@@ -25,7 +25,7 @@ export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
     let declaration;
     for (let i = 0; i < declarationCount(result); i++) {
         const d = declarationAt(result, i);
-        if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === 267 /* SyntaxKind.EnumDeclaration */) {
+        if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === 268 /* SyntaxKind.EnumDeclaration */) {
             declaration = d;
             break;
         }
@@ -37,13 +37,13 @@ export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
     const declarationName = declarationNameToString(getSourceFileOfNode(declaration), getNameOfDeclaration(declaration));
     let diagnostic = undefined;
     if ((result.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0)
-        diagnostic = c.error(errorLocation, 616 /* Diagnostics.Block_scoped_variable_0_used_before_its_declaration */, declarationName);
+        diagnostic = c.error(errorLocation, 623 /* Diagnostics.Block_scoped_variable_0_used_before_its_declaration */, declarationName);
     else if ((result.flags & 32 /* SymbolFlags.Class */) !== 0)
-        diagnostic = c.error(errorLocation, 617 /* Diagnostics.Class_0_used_before_its_declaration */, declarationName);
+        diagnostic = c.error(errorLocation, 624 /* Diagnostics.Class_0_used_before_its_declaration */, declarationName);
     else if ((result.flags & 256 /* SymbolFlags.RegularEnum */) !== 0 || c.isolatedModules)
-        diagnostic = c.error(errorLocation, 618 /* Diagnostics.Enum_0_used_before_its_declaration */, declarationName);
+        diagnostic = c.error(errorLocation, 625 /* Diagnostics.Enum_0_used_before_its_declaration */, declarationName);
     if (diagnostic !== undefined)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(declaration, 860 /* Diagnostics.X_0_is_declared_here */, [declarationName]));
+        diagnostic.addRelatedInfo(createDiagnosticForNode(declaration, 867 /* Diagnostics.X_0_is_declared_here */, [declarationName]));
 }
 /** Reports a class property read in an initializer before it's initialized. */
 export function checkPropertyNotUsedBeforeDeclaration(c, prop, node, right) {
@@ -56,33 +56,33 @@ export function checkPropertyNotUsedBeforeDeclaration(c, prop, node, right) {
         !isOptionalPropertyDeclaration(valueDeclaration) &&
         !(isAccessExpression(node) && isAccessExpression(getExpression(node))) &&
         !isBlockScopedNameDeclaredBeforeUse(c, valueDeclaration, right) &&
-        !(valueDeclaration.kind === 175 /* SyntaxKind.MethodDeclaration */ && isStatic(valueDeclaration)) &&
+        !(valueDeclaration.kind === 176 /* SyntaxKind.MethodDeclaration */ && isStatic(valueDeclaration)) &&
         (getUseDefineForClassFields(c) || !isPropertyDeclaredInAncestorClass(c, prop)))
-        diagnostic = c.error(right, 861 /* Diagnostics.Property_0_is_used_before_its_initialization */, declarationName);
-    else if (valueDeclaration.kind === 264 /* SyntaxKind.ClassDeclaration */ &&
-        node.parent.kind !== 184 /* SyntaxKind.TypeReference */ &&
+        diagnostic = c.error(right, 868 /* Diagnostics.Property_0_is_used_before_its_initialization */, declarationName);
+    else if (valueDeclaration.kind === 265 /* SyntaxKind.ClassDeclaration */ &&
+        node.parent.kind !== 185 /* SyntaxKind.TypeReference */ &&
         (valueDeclaration.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
         !isBlockScopedNameDeclaredBeforeUse(c, valueDeclaration, right))
-        diagnostic = c.error(right, 617 /* Diagnostics.Class_0_used_before_its_declaration */, declarationName);
+        diagnostic = c.error(right, 624 /* Diagnostics.Class_0_used_before_its_declaration */, declarationName);
     if (diagnostic !== undefined)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(valueDeclaration, 860 /* Diagnostics.X_0_is_declared_here */, [declarationName]));
+        diagnostic.addRelatedInfo(createDiagnosticForNode(valueDeclaration, 867 /* Diagnostics.X_0_is_declared_here */, [declarationName]));
 }
 export function isInPropertyInitializerOrClassStaticBlock(node, ignoreArrowFunctions) {
     for (let current = node; current !== undefined; current = current.parent) {
         switch (current.kind) {
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
                 return true;
-            case 187 /* SyntaxKind.TypeQuery */:
-            case 288 /* SyntaxKind.JsxClosingElement */:
+            case 188 /* SyntaxKind.TypeQuery */:
+            case 289 /* SyntaxKind.JsxClosingElement */:
                 return false;
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 if (!ignoreArrowFunctions)
                     return false;
                 break;
-            case 242 /* SyntaxKind.Block */: {
+            case 243 /* SyntaxKind.Block */: {
                 const parent = current.parent;
-                if (isFunctionLike(parent) && parent.kind !== 220 /* SyntaxKind.ArrowFunction */)
+                if (isFunctionLike(parent) && parent.kind !== 221 /* SyntaxKind.ArrowFunction */)
                     return false;
             }
         }
@@ -90,7 +90,7 @@ export function isInPropertyInitializerOrClassStaticBlock(node, ignoreArrowFunct
     return false;
 }
 function isOptionalPropertyDeclaration(node) {
-    if (node.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+    if (node.kind !== 174 /* SyntaxKind.PropertyDeclaration */)
         return false;
     const postfix = getPostfixToken(node);
     return postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */;
@@ -120,25 +120,25 @@ export function isBlockScopedNameDeclaredBeforeUse(c, declaration, usage) {
     if ((usage.flags & 4194304 /* NodeFlags.JSDoc */) !== 0 || isPartOfTypeQuery(usage) || isInAmbientOrTypeNode(usage))
         return true;
     if (declaration.pos <= usage.pos &&
-        !(declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+        !(declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
             isThisProperty(usage.parent) &&
             getInitializer(declaration) === undefined &&
             declaration.postfixToken?.kind !== 53 /* SyntaxKind.ExclamationToken */)) {
-        if (declaration.kind === 209 /* SyntaxKind.BindingElement */) {
+        if (declaration.kind === 210 /* SyntaxKind.BindingElement */) {
             // Binding elements may use earlier siblings only (`var [a = b, b = b] = ...` is an error).
-            const errorBindingElement = findAncestorOfKind(usage, 209 /* SyntaxKind.BindingElement */);
+            const errorBindingElement = findAncestorOfKind(usage, 210 /* SyntaxKind.BindingElement */);
             if (errorBindingElement !== undefined)
-                return (findAncestorOfKind(errorBindingElement, 209 /* SyntaxKind.BindingElement */) !==
-                    findAncestorOfKind(declaration, 209 /* SyntaxKind.BindingElement */) || declaration.pos < errorBindingElement.pos);
+                return (findAncestorOfKind(errorBindingElement, 210 /* SyntaxKind.BindingElement */) !==
+                    findAncestorOfKind(declaration, 210 /* SyntaxKind.BindingElement */) || declaration.pos < errorBindingElement.pos);
             // `var [a] = a` uses the variable before its declaration.
-            return isBlockScopedNameDeclaredBeforeUse(c, findAncestorOfKind(declaration, 261 /* SyntaxKind.VariableDeclaration */), usage);
+            return isBlockScopedNameDeclaredBeforeUse(c, findAncestorOfKind(declaration, 262 /* SyntaxKind.VariableDeclaration */), usage);
         }
-        if (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */)
+        if (declaration.kind === 262 /* SyntaxKind.VariableDeclaration */)
             // `var a = a` uses the variable in its own initializer.
             return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage, declContainer);
         if (isClassLike(declaration))
             return !isUsedInClassComputedNameOrDecorator(c, declaration, usage);
-        if (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */)
+        if (declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */)
             // A self-referencing property initializer, as in `x = this.x`.
             return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, false);
         if (isParameterPropertyDeclaration(declaration, declaration.parent))
@@ -151,12 +151,12 @@ export function isBlockScopedNameDeclaredBeforeUse(c, declaration, usage) {
     // Uses after the declaration are legal when deferred: in export specifiers and `export =`,
     // functions, and instance property initializers referencing other members.
     const parent = usage.parent;
-    if (parent.kind === 282 /* SyntaxKind.ExportSpecifier */ || isExportEquals(parent) || isExportEquals(usage))
+    if (parent.kind === 283 /* SyntaxKind.ExportSpecifier */ || isExportEquals(parent) || isExportEquals(usage))
         return true;
     if (isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer)) {
         if (getEmitStandardClassFields(c) &&
             getContainingClass(declaration) !== undefined &&
-            (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
+            (declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ ||
                 isParameterPropertyDeclaration(declaration, declaration.parent)))
             return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, true);
         return true;
@@ -164,7 +164,7 @@ export function isBlockScopedNameDeclaredBeforeUse(c, declaration, usage) {
     return false;
 }
 function isExportEquals(node) {
-    return node.kind === 278 /* SyntaxKind.ExportAssignment */ && node.isExportEquals;
+    return node.kind === 279 /* SyntaxKind.ExportAssignment */ && node.isExportEquals;
 }
 /**
  * Whether a use of a class within its own declaration happens before the class exists: in a
@@ -174,24 +174,24 @@ function isUsedInClassComputedNameOrDecorator(c, declaration, usage) {
     const legacyDecorators = c.compilerOptions.experimentalDecorators === true;
     let container = usage;
     while (container !== undefined && container !== declaration) {
-        if (container.kind === 168 /* SyntaxKind.ComputedPropertyName */ && container.parent.parent === declaration)
+        if (container.kind === 169 /* SyntaxKind.ComputedPropertyName */ && container.parent.parent === declaration)
             break;
-        if (!legacyDecorators && container.kind === 171 /* SyntaxKind.Decorator */) {
+        if (!legacyDecorators && container.kind === 172 /* SyntaxKind.Decorator */) {
             const decorated = container.parent;
             if (decorated === declaration ||
-                ((decorated.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
-                    decorated.kind === 178 /* SyntaxKind.GetAccessor */ ||
-                    decorated.kind === 179 /* SyntaxKind.SetAccessor */ ||
-                    decorated.kind === 173 /* SyntaxKind.PropertyDeclaration */) &&
+                ((decorated.kind === 176 /* SyntaxKind.MethodDeclaration */ ||
+                    decorated.kind === 179 /* SyntaxKind.GetAccessor */ ||
+                    decorated.kind === 180 /* SyntaxKind.SetAccessor */ ||
+                    decorated.kind === 174 /* SyntaxKind.PropertyDeclaration */) &&
                     decorated.parent === declaration) ||
-                (decorated.kind === 170 /* SyntaxKind.Parameter */ && decorated.parent.parent === declaration))
+                (decorated.kind === 171 /* SyntaxKind.Parameter */ && decorated.parent.parent === declaration))
                 break;
         }
         container = container.parent;
     }
     if (container === undefined || container === declaration)
         return false;
-    if (!legacyDecorators && container.kind === 171 /* SyntaxKind.Decorator */) {
+    if (!legacyDecorators && container.kind === 172 /* SyntaxKind.Decorator */) {
         let n = usage;
         while (n !== undefined && n !== container) {
             if (isFunctionLike(n) && getImmediatelyInvokedFunctionExpression(n) === undefined)
@@ -215,36 +215,36 @@ function isInAmbientOrTypeNode(node) {
     if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
         return true;
     for (let current = node; current !== undefined; current = current.parent)
-        if (current.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
-            current.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ ||
-            current.kind === 188 /* SyntaxKind.TypeLiteral */)
+        if (current.kind === 266 /* SyntaxKind.InterfaceDeclaration */ ||
+            current.kind === 267 /* SyntaxKind.TypeAliasDeclaration */ ||
+            current.kind === 189 /* SyntaxKind.TypeLiteral */)
             return true;
     return false;
 }
 export function getEnclosingBlockScopeContainer(node) {
     for (let current = node.parent; current !== undefined; current = current.parent) {
         switch (current.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
-            case 270 /* SyntaxKind.CaseBlock */:
-            case 300 /* SyntaxKind.CatchClause */:
-            case 268 /* SyntaxKind.ModuleDeclaration */:
-            case 249 /* SyntaxKind.ForStatement */:
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 308 /* SyntaxKind.SourceFile */:
+            case 271 /* SyntaxKind.CaseBlock */:
+            case 301 /* SyntaxKind.CatchClause */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
+            case 250 /* SyntaxKind.ForStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
                 return current;
-            case 242 /* SyntaxKind.Block */: {
+            case 243 /* SyntaxKind.Block */: {
                 // Function bodies aren't block scope containers of their own.
                 const parent = current.parent;
-                if (!isFunctionLike(parent) && parent.kind !== 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+                if (!isFunctionLike(parent) && parent.kind !== 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
                     return current;
             }
         }
@@ -260,25 +260,25 @@ function isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer
                 return true;
             continue;
         }
-        if (current.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */) {
+        if (current.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */) {
             if (declaration.pos < usage.pos)
                 return true;
             continue;
         }
         const parent = current.parent;
-        if (parent !== undefined && parent.kind === 173 /* SyntaxKind.PropertyDeclaration */ && getInitializer(parent) === current) {
+        if (parent !== undefined && parent.kind === 174 /* SyntaxKind.PropertyDeclaration */ && getInitializer(parent) === current) {
             if (isStatic(parent)) {
-                if (declaration.kind === 175 /* SyntaxKind.MethodDeclaration */)
+                if (declaration.kind === 176 /* SyntaxKind.MethodDeclaration */)
                     return true;
                 // A static property assigned in a static block before the initializer.
-                if (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+                if (declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
                     getContainingClass(usage) === getContainingClass(declaration)) {
                     const propName = getName(declaration);
                     if (propName.kind === 79 /* SyntaxKind.Identifier */ || propName.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
                         const symbol = getSymbolOfDeclaration(c, declaration);
                         const staticBlocks = [];
                         for (const m of getMembers(declaration.parent).nodes)
-                            if (m.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+                            if (m.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
                                 staticBlocks.push(m);
                         if (symbol !== undefined &&
                             isPropertyInitializedInStaticBlocks(c, propName, getTypeOfSymbol(c, symbol), staticBlocks, declaration.parent.pos, current.pos))
@@ -287,16 +287,16 @@ function isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer
                 }
             }
             else {
-                const isDeclarationInstanceProperty = declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ && !isStatic(declaration);
+                const isDeclarationInstanceProperty = declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !isStatic(declaration);
                 if (!isDeclarationInstanceProperty || getContainingClass(usage) !== getContainingClass(declaration))
                     return true;
             }
         }
-        if (parent !== undefined && parent.kind === 171 /* SyntaxKind.Decorator */ && getExpression(parent) === current) {
+        if (parent !== undefined && parent.kind === 172 /* SyntaxKind.Decorator */ && getExpression(parent) === current) {
             const decorated = parent.parent;
-            if (decorated.kind === 170 /* SyntaxKind.Parameter */)
+            if (decorated.kind === 171 /* SyntaxKind.Parameter */)
                 return isUsedInFunctionOrInstanceProperty(c, decorated.parent.parent, declaration, declContainer);
-            if (decorated.kind === 175 /* SyntaxKind.MethodDeclaration */)
+            if (decorated.kind === 176 /* SyntaxKind.MethodDeclaration */)
                 return isUsedInFunctionOrInstanceProperty(c, decorated.parent, declaration, declContainer);
         }
     }
@@ -305,15 +305,15 @@ function isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer
 function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage, declContainer) {
     const grandparent = declaration.parent.parent;
     switch (grandparent.kind) {
-        case 244 /* SyntaxKind.VariableStatement */:
-        case 249 /* SyntaxKind.ForStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
+        case 245 /* SyntaxKind.VariableStatement */:
+        case 250 /* SyntaxKind.ForStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
             // The use is within the declaration: its initializer or a binding element.
             if (isSameScopeDescendentOf(usage, declaration, declContainer))
                 return true;
     }
     // In `for (... in/of expr)`, the use is within the expression.
-    return ((grandparent.kind === 250 /* SyntaxKind.ForInStatement */ || grandparent.kind === 251 /* SyntaxKind.ForOfStatement */) &&
+    return ((grandparent.kind === 251 /* SyntaxKind.ForInStatement */ || grandparent.kind === 252 /* SyntaxKind.ForOfStatement */) &&
         isSameScopeDescendentOf(usage, getExpression(grandparent), declContainer));
 }
 /** Whether `initial` is within `parent` without crossing `stopAt` or a function that isn't an IIFE. */
@@ -337,19 +337,19 @@ function isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, st
         return false;
     for (let node = usage; node !== undefined && node !== declaration; node = node.parent) {
         switch (node.kind) {
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 return false;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 // Even when stopping at any property declaration, it must be in the same class.
                 return (stopAtAnyPropertyDeclaration &&
-                    ((declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ && node.parent === declaration.parent) ||
+                    ((declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ && node.parent === declaration.parent) ||
                         (isParameterPropertyDeclaration(declaration, declaration.parent) &&
                             node.parent === declaration.parent.parent)));
-            case 242 /* SyntaxKind.Block */:
+            case 243 /* SyntaxKind.Block */:
                 switch (node.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 */:
                         return false;
                 }
         }

package/dist/api/compiler/checker-declarations.d.ts

@@ -5,6 +5,7 @@ export declare function checkVariableStatement(c: Checker, node: Node): void;
 export declare function checkVariableDeclarationList(c: Checker, node: Node): void;
 /** Checks a variable, parameter, property or binding element declaration. */
 export declare function checkVariableLikeDeclaration(c: Checker, node: Node): void;
+export declare function isVariableLike(node: Node): boolean;
 export declare function checkFunctionDeclaration(c: Checker, node: Node): void;
 export declare function checkTypeParameter(c: Checker, node: Node): void;
 /** Variance annotations are only allowed on type aliases of object, function, constructor and mapped types. */