tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/checker-signatures.js

@@ -45,20 +45,20 @@ export function getSignaturesOfSymbol(c, symbol) {
 }
 export function isFunctionLikeNode(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 174 /* SyntaxKind.MethodSignature */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 181 /* SyntaxKind.ConstructSignature */:
-        case 182 /* SyntaxKind.IndexSignature */:
-        case 185 /* SyntaxKind.FunctionType */:
-        case 186 /* SyntaxKind.ConstructorType */:
-        case 318 /* SyntaxKind.JSDocSignature */:
+        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 */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 182 /* SyntaxKind.ConstructSignature */:
+        case 183 /* SyntaxKind.IndexSignature */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 187 /* SyntaxKind.ConstructorType */:
+        case 319 /* SyntaxKind.JSDocSignature */:
             return true;
     }
     return false;
@@ -71,7 +71,7 @@ export function isOptionalDeclaration(node) {
 }
 function getAnnotatedAccessorThisParameter(accessor) {
     const params = getParameters(accessor).nodes;
-    if (params.length !== (accessor.kind === 178 /* SyntaxKind.GetAccessor */ ? 1 : 2))
+    if (params.length !== (accessor.kind === 179 /* SyntaxKind.GetAccessor */ ? 1 : 2))
         return undefined;
     const name = getName(params[0]);
     return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && getText(name) === 'this'
@@ -105,7 +105,7 @@ export function getSignatureFromDeclaration(c, declaration) {
             thisParameter = getSymbol(param);
         else
             parameters.push(paramSymbol);
-        if (typeNode !== undefined && typeNode.kind === 202 /* SyntaxKind.LiteralType */)
+        if (typeNode !== undefined && typeNode.kind === 203 /* SyntaxKind.LiteralType */)
             flags |= 2 /* SignatureFlags.HasLiteralTypes */;
         const iifeArgs = iife !== undefined ? getArguments(iife).nodes.length : 0;
         const isOptionalParameter = isOptionalDeclaration(param) ||
@@ -116,28 +116,28 @@ export function getSignatureFromDeclaration(c, declaration) {
             minArgumentCount = parameters.length;
     }
     // An accessor without a `this` annotation takes the one of its counterpart.
-    if ((declaration.kind === 178 /* SyntaxKind.GetAccessor */ || declaration.kind === 179 /* SyntaxKind.SetAccessor */) &&
+    if ((declaration.kind === 179 /* SyntaxKind.GetAccessor */ || declaration.kind === 180 /* SyntaxKind.SetAccessor */) &&
         hasBindableName(declaration) &&
         thisParameter === undefined) {
         const symbol = getSymbol(declaration);
         const other = symbol !== undefined
-            ? getDeclarationOfKind(symbol, declaration.kind === 178 /* SyntaxKind.GetAccessor */ ? 179 /* SyntaxKind.SetAccessor */ : 178 /* SyntaxKind.GetAccessor */)
+            ? getDeclarationOfKind(symbol, declaration.kind === 179 /* SyntaxKind.GetAccessor */ ? 180 /* SyntaxKind.SetAccessor */ : 179 /* SyntaxKind.GetAccessor */)
             : undefined;
         if (other !== undefined)
             thisParameter = getAnnotatedAccessorThisParameter(other);
     }
-    const classType = declaration.kind === 177 /* SyntaxKind.Constructor */
+    const classType = declaration.kind === 178 /* SyntaxKind.Constructor */
         ? getDeclaredTypeOfClassOrInterface(c, getMergedSymbol(c, getSymbol(declaration.parent)))
         : undefined;
     const typeParameters = classType !== undefined ? classType.localTypeParameters() : getTypeParametersFromDeclaration(c, declaration);
     if (params.length !== 0 && isRestParameter(params[params.length - 1]))
         flags |= 1 /* SignatureFlags.HasRestParameter */;
-    if (declaration.kind === 186 /* SyntaxKind.ConstructorType */ ||
-        declaration.kind === 177 /* SyntaxKind.Constructor */ ||
-        declaration.kind === 181 /* SyntaxKind.ConstructSignature */)
+    if (declaration.kind === 187 /* SyntaxKind.ConstructorType */ ||
+        declaration.kind === 178 /* SyntaxKind.Constructor */ ||
+        declaration.kind === 182 /* SyntaxKind.ConstructSignature */)
         flags |= 4 /* SignatureFlags.Construct */;
-    if ((declaration.kind === 186 /* SyntaxKind.ConstructorType */ && hasSyntacticModifier(declaration, 64 /* ModifierFlags.Abstract */)) ||
-        (declaration.kind === 177 /* SyntaxKind.Constructor */ && hasSyntacticModifier(declaration.parent, 64 /* ModifierFlags.Abstract */)))
+    if ((declaration.kind === 187 /* SyntaxKind.ConstructorType */ && hasSyntacticModifier(declaration, 64 /* ModifierFlags.Abstract */)) ||
+        (declaration.kind === 178 /* SyntaxKind.Constructor */ && hasSyntacticModifier(declaration.parent, 64 /* ModifierFlags.Abstract */)))
         flags |= 8 /* SignatureFlags.Abstract */;
     const signature = c.newSignature(flags, declaration, typeParameters, thisParameter, parameters, undefined, minArgumentCount);
     c.resolvedSignatures.set(declaration.id, signature);
@@ -169,8 +169,23 @@ export function getReturnTypeOfSignature(c, sig) {
     if (sig.resolvedReturnType !== undefined)
         return sig.resolvedReturnType;
     const side = signatureSideOf(c, sig);
-    if (side.resolvedReturnType !== undefined)
+    if (side.resolvedReturnType !== undefined) {
+        if (c.threadSharing !== undefined)
+            noteReturnTypeUse(c, sig);
         return side.resolvedReturnType;
+    }
+    // TSC_TS_SHARE: checker threads share the return types of declared signatures (shared-results.ts).
+    if (c.threadSharing !== undefined && isSharedReturnSignature(c, sig)) {
+        const sharing = c.threadSharing;
+        if (sharing.computingSignature === sig)
+            sharing.computingSignature = undefined;
+        else {
+            const t = threadReturnType(c, sig);
+            if (side.resolvedReturnType === undefined)
+                side.resolvedReturnType = t;
+            return side.resolvedReturnType;
+        }
+    }
     if (!pushTypeResolution(c, sig, 3 /* TypeSystemPropertyName.ResolvedReturnType */))
         return c.errorType;
     let t;
@@ -197,13 +212,13 @@ export function getReturnTypeOfSignature(c, sig) {
         if (declaration !== undefined) {
             const typeNode = getType(declaration);
             if (typeNode !== undefined)
-                c.error(typeNode, 728 /* Diagnostics.Return_type_annotation_circularly_references_itself */);
+                c.error(typeNode, 735 /* Diagnostics.Return_type_annotation_circularly_references_itself */);
             else if (c.noImplicitAny) {
                 const name = getNameOfDeclaration(declaration);
                 if (name !== undefined)
-                    c.error(name, 1694 /* Diagnostics.X_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions */, declarationNameToString(getSourceFileOfNode(name), name));
+                    c.error(name, 1713 /* Diagnostics.X_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions */, declarationNameToString(getSourceFileOfNode(name), name));
                 else
-                    c.error(declaration, 1695 /* Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions */);
+                    c.error(declaration, 1714 /* Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions */);
             }
         }
         t = c.anyType;
@@ -213,6 +228,7 @@ export function getReturnTypeOfSignature(c, sig) {
     return side.resolvedReturnType;
 }
 import { getOptionalType as getOptionalTypeLocal, addOptionalTypeMarker } from './checker-symbol-types.js';
+import { isSharedReturnSignature, noteReturnTypeUse, threadReturnType } from './shared-results.js';
 export function isResolvingReturnTypeOfSignature(c, sig) {
     if (sig.composite !== undefined)
         for (const s of sig.composite.signatures)
@@ -229,15 +245,15 @@ function isThisParameterDeclaration(p) {
     return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && getText(name) === 'this';
 }
 export function getReturnTypeFromAnnotation(c, declaration) {
-    if (declaration.kind === 177 /* SyntaxKind.Constructor */)
+    if (declaration.kind === 178 /* SyntaxKind.Constructor */)
         return getDeclaredTypeOfClassOrInterface(c, getMergedSymbol(c, getSymbol(declaration.parent)));
     const returnType = getType(declaration);
     if (returnType !== undefined)
         return getTypeFromTypeNode(c, returnType);
-    if (declaration.kind === 178 /* SyntaxKind.GetAccessor */) {
+    if (declaration.kind === 179 /* SyntaxKind.GetAccessor */) {
         const symbol = getSymbolOfDeclaration(c, declaration);
         if (symbol !== undefined) {
-            const setter = getDeclarations(symbol).find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */);
+            const setter = getDeclarations(symbol).find((d) => d.kind === 180 /* SyntaxKind.SetAccessor */);
             if (setter !== undefined) {
                 const parameters = getParameters(setter);
                 if (parameters !== undefined) {
@@ -272,7 +288,7 @@ export function getTypePredicateOfSignature(c, sig) {
             const returnType = resolvedReturnTypeOf(c, sig);
             const typeNode = getType(sig.declaration);
             if (typeNode !== undefined) {
-                if (typeNode.kind === 183 /* SyntaxKind.TypePredicate */)
+                if (typeNode.kind === 184 /* SyntaxKind.TypePredicate */)
                     side.resolvedTypePredicate = createTypePredicateFromTypePredicateNode(c, typeNode, sig);
             }
             else if (isFunctionLikeDeclarationKind(sig.declaration.kind) &&
@@ -314,7 +330,7 @@ function getUnionOrIntersectionTypePredicate(c, signatures, isUnion) {
 function createTypePredicateFromTypePredicateNode(c, node, signature) {
     const shape = node;
     const t = shape.type !== undefined ? getTypeFromTypeNode(c, shape.type) : undefined;
-    if (shape.parameterName.kind === 198 /* SyntaxKind.ThisType */)
+    if (shape.parameterName.kind === 199 /* SyntaxKind.ThisType */)
         return new TypePredicate(shape.assertsModifier !== undefined ? 2 /* TypePredicateKind.AssertsThis */ : 0 /* TypePredicateKind.This */, '', 0, t);
     const name = getText(shape.parameterName);
     const index = signature.parameters.findIndex((p) => p.name === name);
@@ -453,9 +469,9 @@ function getNameableDeclarationAtPosition(c, signature, pos) {
     return undefined;
 }
 function isValidDeclarationForTupleLabel(d) {
-    if (d.kind === 203 /* SyntaxKind.NamedTupleMember */)
+    if (d.kind === 204 /* SyntaxKind.NamedTupleMember */)
         return true;
-    const name = d.kind === 170 /* SyntaxKind.Parameter */ ? getName(d) : undefined;
+    const name = d.kind === 171 /* SyntaxKind.Parameter */ ? getName(d) : undefined;
     return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */;
 }
 export function getNonArrayRestType(c, signature) {
@@ -599,9 +615,9 @@ export function getOrCreateTypeFromSignature(c, sig) {
         const kind = sig.declaration !== undefined ? sig.declaration.kind : 0 /* SyntaxKind.Unknown */;
         // No declaration means a default constructor.
         const isConstructor = kind === 0 /* SyntaxKind.Unknown */ ||
-            kind === 177 /* SyntaxKind.Constructor */ ||
-            kind === 181 /* SyntaxKind.ConstructSignature */ ||
-            kind === 186 /* SyntaxKind.ConstructorType */;
+            kind === 178 /* SyntaxKind.Constructor */ ||
+            kind === 182 /* SyntaxKind.ConstructSignature */ ||
+            kind === 187 /* SyntaxKind.ConstructorType */;
         const t = newObjectType(c, 16 /* ObjectFlags.Anonymous */ | 33554432 /* ObjectFlags.SingleSignatureType */, sig.declaration !== undefined ? getSymbol(sig.declaration) : undefined);
         if (isConstructor)
             setStructuredTypeMembers(c, t, undefined, [], [sig], []);
@@ -657,7 +673,7 @@ export function getIndexInfosOfIndexSymbol(c, indexSymbol, siblingSymbols) {
     let readonlySymbol = true;
     const propertySymbols = [];
     for (const declaration of getDeclarations(indexSymbol)) {
-        if (declaration.kind === 182 /* SyntaxKind.IndexSignature */) {
+        if (declaration.kind === 183 /* SyntaxKind.IndexSignature */) {
             const parameters = getParameters(declaration)?.nodes ?? [];
             const returnTypeNode = getType(declaration);
             if (parameters.length !== 1)
@@ -725,7 +741,7 @@ function isSymbolWithSymbolName(c, symbol) {
         return true;
     const name = declarationCount(symbol) !== 0 ? getName(symbol.declaration) : undefined;
     return (name !== undefined &&
-        name.kind === 168 /* SyntaxKind.ComputedPropertyName */ &&
+        name.kind === 169 /* SyntaxKind.ComputedPropertyName */ &&
         isTypeAssignableToKind(c, checkComputedPropertyName(c, name), 512 /* TypeFlags.ESSymbol */));
 }
 /** Whether `symbol` has a numeric name, or a computed name of a number type. */
@@ -735,7 +751,7 @@ function isSymbolWithNumericName(c, symbol) {
     const name = declarationCount(symbol) !== 0 ? getName(symbol.declaration) : undefined;
     if (name === undefined)
         return false;
-    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         return isTypeAssignableToKind(c, checkComputedPropertyName(c, name), 67648 /* TypeFlags.NumberLike */);
     return ((name.kind === 79 /* SyntaxKind.Identifier */ ||
         name.kind === 10 /* SyntaxKind.StringLiteral */ ||
@@ -763,7 +779,7 @@ function isSymbolWithComputedName(symbol) {
     if (declarationCount(symbol) === 0)
         return false;
     const name = getName(symbol.declaration);
-    return name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */;
+    return name !== undefined && name.kind === 169 /* SyntaxKind.ComputedPropertyName */;
 }
 export { getIndexInfosOfType, instantiateTypes, getConstraintOfTypeParameter, getClassLikeDeclarationOfSymbol, getSymbolOfDeclaration, };
 /** A JavaScript function without parameter types or a contextual signature: all its parameters are optional. */
@@ -771,13 +787,13 @@ function isUntypedSignatureInJSFile(c, declaration, params) {
     if (!isInJSFile(declaration))
         return false;
     switch (declaration.kind) {
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 177 /* SyntaxKind.Constructor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
             break;
         default:
             return false;

package/dist/api/compiler/checker-source-file.d.ts

@@ -17,6 +17,11 @@ export declare function checkSourceFile(c: Checker, file: SourceFile, checkUnuse
  * and a check that a symbol's first declaration runs reports on all its declarations.
  */
 export declare function checkSourceFileRange(c: Checker, file: SourceFile, start: number, end: number): boolean;
+/**
+ * Reports the deferred diagnostics, in the order they were deferred. Diagnostics deferred while they
+ * are reported are dropped.
+ */
+export declare function produceDeferredDiagnostics(c: Checker): void;
 /** Checks a statement, declaration, class member or type node. */
 export declare function checkSourceElement(c: Checker, node: Node | undefined): void;
 /** Resolves the `@link` names of a node's JSDoc, which marks what they name referenced. */