tsc-ts 0.0.10 → 0.1.0

package/src/compiler/checker-calls.ts

@@ -43,6 +43,7 @@ import {
   isOptionalChain,
   isOutermostOptionalChain,
   isDottedName,
+  isFunctionExpressionOrArrowFunction,
 } from './binder-utilities.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics, chainDiagnostic } from './diagnostics.js';
 import { resolveInstanceofExpression } from './checker-operators.js';
@@ -147,6 +148,7 @@ import {
   checkNonNullType,
   checkNonNullTypeEx,
   checkTypeQueryExpression,
+  getResolvedSymbol,
 } from './checker-expressions.js';
 import { IterationUse, checkIteratedTypeOrElementType } from './checker-iteration.js';
 import { isContextSensitive } from './checker-functions.js';
@@ -182,6 +184,7 @@ import {
   everyInferenceHasCandidates,
   someInferenceHasCandidates,
   inferTypes,
+  inferTypesFromUnstarted,
   isConstTypeVariable,
   isMutableArrayLikeType,
 } from './checker-inference.js';
@@ -207,7 +210,14 @@ import {
   resolveJsxOpeningLikeElement,
 } from './checker-jsx.js';
 import { isCommonJSRequire, resolveExternalModuleTypeByLiteral } from './checker-javascript.js';
-import { declarationCount, getDeclarations, InternalSymbolName, type Symbol, SymbolFlags } from './symbol.js';
+import {
+  copyDeclarations,
+  declarationCount,
+  getDeclarations,
+  InternalSymbolName,
+  type Symbol,
+  SymbolFlags,
+} from './symbol.js';
 
 /** The type of an optional chain's expression with the chain's `undefined` removed. */
 export function getOptionalExpressionType(c: Checker, exprType: Type, expression: Node): Type {
@@ -430,7 +440,7 @@ function resolveNewExpression(c: Checker, node: NewExpression, checkMode: CheckM
   }
   const constructSignatures = getSignaturesOfType(c, expressionType, SignatureKind.Construct);
   if (constructSignatures.length !== 0) {
-    if (!isConstructorAccessible(c, node, constructSignatures[0]!)) return resolveErrorCall(c, node);
+    if (!isConstructorAccessible(c, node, constructSignatures)) return resolveErrorCall(c, node);
     if (someSignature(constructSignatures, (s) => (s.flags & SignatureFlags.Abstract) !== 0)) {
       c.error(node, Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
       return resolveErrorCall(c, node);
@@ -892,6 +902,8 @@ class CallState {
   candidates: Signature[];
   argCheckMode: CheckMode = CheckMode.Normal;
   isSingleNonGenericCandidate = false;
+  /** The call is resolved while its own resolution is in progress. */
+  recursiveResolution = false;
   candidatesForArgumentError: Signature[] = [];
   candidateForArgumentArityError: Signature | undefined = undefined;
   candidateForTypeArgumentError: Signature | undefined = undefined;
@@ -933,8 +945,19 @@ export function resolveCall(
     s.argCheckMode = CheckMode.SkipContextSensitive;
   // A subtype pass picks the best overload; assignability decides whether the call is an error.
   let result: Signature | undefined = undefined;
+  const callResolutionDepth = c.callResolutionDepth;
+  const callResolutionStack = c.callResolutionStack;
+  for (let i = 0; i < callResolutionDepth; i++)
+    if (callResolutionStack[i] === node) {
+      s.recursiveResolution = true;
+      break;
+    }
+  if (callResolutionDepth < callResolutionStack.length) callResolutionStack[callResolutionDepth] = node;
+  else callResolutionStack.push(node);
+  c.callResolutionDepth = callResolutionDepth + 1;
   if (candidates.length > 1) result = chooseOverload(c, s, c.subtypeRelation);
   if (result === undefined) result = chooseOverload(c, s, c.assignableRelation);
+  c.callResolutionDepth = callResolutionDepth;
   if (result !== undefined) return result;
   result = getCandidateForOverloadFailure(c, node, s.candidates, s.args, checkMode);
   // Cache now so that error reporting below handles circularities like getResolvedSignature would.
@@ -1031,7 +1054,11 @@ function chooseOverload(c: Checker, s: CallState, relation: Relation): Signature
           c,
           candidate.typeParameters,
           candidate,
-          isInJSFile(s.node) ? InferenceFlags.AnyDefault : InferenceFlags.None,
+          // A recursive resolution of a call with one candidate skips constraint checks during inference, which
+          // would otherwise report circularities.
+          (s.recursiveResolution && s.candidates.length === 1
+            ? InferenceFlags.NoConstraintChecks
+            : InferenceFlags.None) | (isInJSFile(s.node) ? InferenceFlags.AnyDefault : InferenceFlags.None),
           undefined,
         );
         typeArgumentTypes = inferTypeArguments(
@@ -1408,13 +1435,13 @@ function inferTypeArguments(
               )
             : instantiatedType;
         // Return type inferences have the lowest priority.
-        inferTypes(
+        inferTypesFromUnstarted(
           c,
+          signature,
           context.inferences,
           inferenceSourceType,
           inferenceTargetType,
           InferencePriority.ReturnType,
-          false,
         );
       }
       // A separate pass for the mapper used to instantiate generic contextual types, from the outer
@@ -1422,7 +1449,14 @@ function inferTypeArguments(
       const returnContext = createInferenceContext(c, signature.typeParameters, signature, context.flags, undefined);
       const outerReturnMapper = outerContext !== undefined ? createOuterReturnMapper(c, outerContext) : undefined;
       const returnSourceType = instantiateType(c, contextualType, outerReturnMapper);
-      inferTypes(c, returnContext.inferences, returnSourceType, inferenceTargetType, InferencePriority.None, false);
+      inferTypesFromUnstarted(
+        c,
+        signature,
+        returnContext.inferences,
+        returnSourceType,
+        inferenceTargetType,
+        InferencePriority.None,
+      );
       context.returnMapper = someInferenceHasCandidates(returnContext.inferences)
         ? getMapperFromContext(cloneInferredPartOfContext(c, returnContext))
         : undefined;
@@ -1708,6 +1742,26 @@ function withHeadMessage(diagnostic: Diagnostic, headMessage: DiagnosticMessage
   return headMessage !== undefined ? chainDiagnostic(diagnostic, headMessage) : diagnostic;
 }
 
+/** Whether `node` calls the `resolve` parameter of an executor passed to the global `new Promise`. */
+function isPromiseResolveArityError(c: Checker, node: Node): boolean {
+  if (node.kind !== SyntaxKind.CallExpression) return false;
+  const callee = getExpression(node)!;
+  if (callee.kind !== SyntaxKind.Identifier) return false;
+  const symbol = resolveName(c, callee, getText(callee), SymbolFlags.Value, undefined, false, false);
+  const declaration = symbol?.valueDeclaration;
+  if (
+    declaration === undefined ||
+    declaration.kind !== SyntaxKind.Parameter ||
+    !isFunctionExpressionOrArrowFunction(declaration.parent!) ||
+    declaration.parent!.parent?.kind !== SyntaxKind.NewExpression
+  )
+    return false;
+  const constructor = getExpression(declaration.parent!.parent!);
+  if (constructor === undefined || constructor.kind !== SyntaxKind.Identifier) return false;
+  const globalPromiseSymbol = getGlobalValueSymbol(c, 'Promise', false);
+  return globalPromiseSymbol !== undefined && getResolvedSymbol(c, constructor) === globalPromiseSymbol;
+}
+
 function getArgumentArityError(
   c: Checker,
   node: Node,
@@ -1750,7 +1804,16 @@ function getArgumentArityError(
     : minCount < maxCount
       ? minCount + '-' + maxCount
       : String(minCount);
+  // `resolve()` without an argument, where `resolve` is the parameter of a `new Promise` executor.
+  const isVoidPromiseError =
+    !hasRestParameter && parameterRange === '1' && args.length === 0 && isPromiseResolveArityError(c, node);
   const errorNode = getErrorNodeForCallNode(node);
+  if (isVoidPromiseError && isInJSFile(node))
+    return createDiagnosticForNode(
+      errorNode,
+      Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments,
+      [],
+    );
   const message =
     node.kind === SyntaxKind.Decorator
       ? hasRestParameter
@@ -1758,7 +1821,9 @@ function getArgumentArityError(
         : Diagnostics.The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_0
       : hasRestParameter
         ? Diagnostics.Expected_at_least_0_arguments_but_got_1
-        : Diagnostics.Expected_0_arguments_but_got_1;
+        : isVoidPromiseError
+          ? Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise
+          : Diagnostics.Expected_0_arguments_but_got_1;
   if (minCount < args.length && args.length < maxCount)
     // Between min and max, but no overload matches.
     return withHeadMessage(
@@ -2106,10 +2171,13 @@ class InstantiationExpressionInstantiator {
       if (resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0) this.hasSignatures = true;
       if (callSignatures.length !== 0 || constructSignatures.length !== 0) this.hasApplicableSignature = true;
       if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
+        // A symbol of its own, with the declarations of the instantiated type's symbol.
+        const symbol = c.newSymbol(SymbolFlags.None, InternalSymbolName.InstantiationExpression);
+        if (t.symbol !== undefined) copyDeclarations(symbol, t.symbol);
         const result = newObjectType(
           c,
           ObjectFlags.Anonymous | ObjectFlags.InstantiationExpressionType,
-          c.newSymbol(SymbolFlags.None, InternalSymbolName.InstantiationExpression),
+          symbol,
         ) as InstantiationExpressionType;
         setStructuredTypeMembers(c, result, resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
         result.node = this.node;

package/src/compiler/checker-classes.ts

@@ -46,7 +46,7 @@ import {
   isPrivateIdentifierClassElementDeclaration,
   isStatic,
 } from './binder-utilities.js';
-import { isFunctionLike, nodeIsMissing, nodeIsPresent } from './ast-utilities.js';
+import { isFunctionLike, isInJSFile, nodeIsMissing, nodeIsPresent } from './ast-utilities.js';
 import { ScriptTarget, getEmitScriptTarget, getUseDefineForClassFields } from './options.js';
 import { hasDynamicName, hasLateBindableName } from './checker-utilities.js';
 import { type DiagnosticMessage, Diagnostics } from './diagnostics.js';
@@ -78,7 +78,13 @@ import { getSymbolOfDeclaration } from './checker-symbols.js';
 import { getOptionalType, getTypeOfSymbol } from './checker-symbol-types.js';
 import { convertAutoToAny, getFlowTypeOfReference } from './checker-narrowing.js';
 import { TypeFacts, hasTypeFacts } from './checker-flow.js';
-import { getIndexInfosOfType, getSignaturesOfType, getTypeOfPropertyOfType } from './checker-members.js';
+import {
+  getIndexInfosOfType,
+  getPropertiesOfType,
+  getSignaturesOfType,
+  getTypeOfPropertyOfType,
+} from './checker-members.js';
+import { isConstructorDeclaredThisProperty } from './checker-javascript.js';
 import {
   checkJSDocLinksOfNode,
   checkNodeDeferred,
@@ -91,7 +97,7 @@ import {
   checkExportsOnMergedDeclarations,
 } from './checker-declarations.js';
 import { checkFunctionLikeBody } from './checker-functions.js';
-import { checkJSDocFullSignature } from './checker-jsdoc.js';
+import { checkJSDocFullSignature, checkJSDocFullSignatureType } from './checker-jsdoc.js';
 import { checkComputedPropertyName } from './checker-expressions.js';
 import { checkFunctionOrConstructorSymbol, checkFunctionOrMethodSymbols } from './checker-overloads.js';
 import {
@@ -100,6 +106,7 @@ import {
   checkInterfaceHeritage,
 } from './checker-heritage.js';
 import { checkDecorators, getFirstTransformableStaticClassElement } from './checker-decorators.js';
+import { getTypeOfNode } from './checker-services.js';
 
 export function checkClassDeclaration(c: Checker, node: Node): void {
   checkClassLikeDeclaration(c, node);
@@ -148,6 +155,23 @@ export function checkClassLikeDeferred(c: Checker, node: Node): void {
 
 function checkClassMembers(c: Checker, node: Node): void {
   for (const member of getMembers(node)!.nodes) checkClassMember(c, member);
+  checkConstructorDeclaredProperties(c, node);
+}
+
+/**
+ * Resolves the types of a JavaScript class's properties declared by `this.x` assignments in its
+ * constructor, so the diagnostics of their initializers don't depend on which use is checked first.
+ */
+function checkConstructorDeclaredProperties(c: Checker, node: Node): void {
+  if (!isInJSFile(node)) return;
+  const symbol = getSymbolOfDeclaration(c, node);
+  if (symbol === undefined) return;
+  for (const property of getPropertiesOfType(c, getDeclaredTypeOfSymbol(c, symbol)))
+    if (
+      isConstructorDeclaredThisProperty(c, property) &&
+      c.symbolLinks(property).thisAssignmentLocation!.parent === node
+    )
+      getTypeOfSymbol(c, property);
 }
 
 function checkClassLikeDeclaration(c: Checker, node: Node): void {
@@ -241,6 +265,7 @@ function checkClassMember(c: Checker, member: Node): void {
       if (symbol !== undefined && member.kind !== SyntaxKind.Constructor) getTypeOfSymbol(c, symbol);
       checkFunctionLikeBody(c, member);
       if (member.kind === SyntaxKind.MethodDeclaration) {
+        checkJSDocFullSignatureType(c, member);
         checkJSDocFullSignature(c, member);
         checkFunctionOrMethodSymbols(c, member);
         if (hasSyntacticModifier(member, ModifierFlags.Abstract) && getBody(member) !== undefined)
@@ -612,35 +637,64 @@ function containsUndefinedType(t: Type): boolean {
   return (first.flags & TypeFlags.Undefined) !== 0;
 }
 
-/** Whether `new` at `node` may call a constructor, reporting private and protected ones out of reach. */
-export function isConstructorAccessible(c: Checker, node: Node, signature: Signature | undefined): boolean {
-  if (signature === undefined || signature.declaration === undefined) return true;
-  const declaration = signature.declaration;
-  const modifiers = getModifierFlags(declaration) & ModifierFlags.NonPublicAccessibilityModifier;
-  // Public constructors and constructor functions are always accessible.
-  if (modifiers === 0 || declaration.kind !== SyntaxKind.Constructor) return true;
-  const classSymbol = getSymbol(declaration.parent!)!;
-  const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(classSymbol);
-  const declaringClass = getDeclaredTypeOfSymbol(c, classSymbol);
-  // Private and protected constructors are only callable within their class, or subclasses if protected.
-  for (let container = getContainingClass(node); container !== undefined; container = getContainingClass(container))
-    if (container === declaringClassDeclaration) return true;
-  const containingClass = getContainingClass(node);
-  if (containingClass !== undefined && (modifiers & ModifierFlags.Protected) !== 0) {
-    const containingType = getDeclaredTypeOfSymbol(c, getSymbol(containingClass)!);
-    if (typeHasProtectedAccessibleBase(c, classSymbol, containingType)) return true;
+/** A constructor that `node` may not call: the modifiers that forbid it, and the class that declares it. */
+export class ConstructorAccessibilityError {
+  constructor(
+    readonly kind: ModifierFlags,
+    readonly declaringClass: Type,
+  ) {}
+}
+
+/**
+ * The first of `signatures` whose constructor `node` may not call because of the modifiers in `modifiersMask`:
+ * private and protected constructors are only callable within their class, or subclasses if protected.
+ */
+export function getConstructorAccessibilityError(
+  c: Checker,
+  node: Node,
+  signatures: readonly Signature[],
+  modifiersMask: ModifierFlags,
+): ConstructorAccessibilityError | undefined {
+  for (const signature of signatures) {
+    const declaration = signature.declaration;
+    if (declaration === undefined) continue;
+    const modifiers = getModifierFlags(declaration) & modifiersMask;
+    // Public constructors and constructor functions are always accessible.
+    if (modifiers === 0 || declaration.kind !== SyntaxKind.Constructor) continue;
+    const classSymbol = getSymbol(declaration.parent!)!;
+    const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(classSymbol);
+    let withinClass = false;
+    for (let container = getContainingClass(node); container !== undefined; container = getContainingClass(container))
+      if (container === declaringClassDeclaration) {
+        withinClass = true;
+        break;
+      }
+    if (withinClass) continue;
+    const containingClass = getContainingClass(node);
+    if (containingClass !== undefined && (modifiers & ModifierFlags.Protected) !== 0) {
+      const containingType = getTypeOfNode(c, containingClass);
+      if (typeHasProtectedAccessibleBase(c, classSymbol, containingType)) continue;
+    }
+    return new ConstructorAccessibilityError(modifiers, getDeclaredTypeOfSymbol(c, classSymbol));
   }
-  if ((modifiers & ModifierFlags.Private) !== 0)
+  return undefined;
+}
+
+/** Whether `new` at `node` may call the constructors of `signatures`, reporting private and protected ones out of reach. */
+export function isConstructorAccessible(c: Checker, node: Node, signatures: readonly Signature[]): boolean {
+  const error = getConstructorAccessibilityError(c, node, signatures, ModifierFlags.NonPublicAccessibilityModifier);
+  if (error === undefined) return true;
+  if ((error.kind & ModifierFlags.Private) !== 0)
     c.error(
       node,
       Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration,
-      typeToString(c, declaringClass),
+      typeToString(c, error.declaringClass),
     );
-  if ((modifiers & ModifierFlags.Protected) !== 0)
+  if ((error.kind & ModifierFlags.Protected) !== 0)
     c.error(
       node,
       Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration,
-      typeToString(c, declaringClass),
+      typeToString(c, error.declaringClass),
     );
   return false;
 }

package/src/compiler/checker-contextual.ts

@@ -470,7 +470,12 @@ function getContextualTypeForInitializer(c: Checker, declaration: Node, contextF
   ) {
     const parentType = getContextualTypeEx(c, declaration.parent!, contextFlags);
     const symbol = getSymbolOfDeclaration(c, declaration);
-    if (parentType !== undefined && symbol !== undefined)
+    // The class's own type might still be in progress, so contextually typing by it would report a spurious circularity.
+    if (
+      parentType !== undefined &&
+      symbol !== undefined &&
+      parentType.symbol !== getSymbolOfDeclaration(c, declaration.parent!)
+    )
       return getTypeOfPropertyOfContextualType(c, parentType, symbol.name);
   }
   return undefined;

package/src/compiler/checker-declarations.ts

@@ -2,6 +2,7 @@
 import { checkCollisionsForDeclarationName } from './checker-generated-code.js';
 import { ExternalEmitHelpers, checkExternalEmitHelpers } from './checker-emit-helpers.js';
 import { convertAutoToAny } from './checker-narrowing.js';
+import { grammarErrorOnNode } from './checker-operators.js';
 import { markPropertyAsReferenced } from './checker-unused.js';
 import {
   type BindingElement,
@@ -13,6 +14,7 @@ import {
   type NodeList,
   NodeVisitor,
   type TypeAliasDeclaration,
+  type TypeLiteralNode,
   type TypeParameterDeclaration,
   type VariableDeclarationList,
   type VariableStatement,
@@ -138,7 +140,7 @@ import {
 } from './ast-utilities.js';
 import { getTypeForBindingElementParent } from './checker-destructuring.js';
 import { checkFunctionOrMethodSymbols } from './checker-overloads.js';
-import { checkJSDocFullSignature } from './checker-jsdoc.js';
+import { checkJSDocFullSignature, checkJSDocFullSignatureType } from './checker-jsdoc.js';
 import { checkAliasSymbol } from './checker-modules.js';
 import { checkDecorators } from './checker-decorators.js';
 import {
@@ -400,7 +402,7 @@ function checkParameter(c: Checker, node: Node): void {
   }
 }
 
-function isVariableLike(node: Node): boolean {
+export function isVariableLike(node: Node): boolean {
   switch (node.kind) {
     case SyntaxKind.BindingElement:
     case SyntaxKind.EnumMember:
@@ -444,6 +446,12 @@ function reportNonIdenticalModifiers(c: Checker, name: Node): void {
 function checkBindingElement(c: Checker, element: BindingElement): void {
   // Missing array binding elements have no name.
   if (element.name === undefined) return;
+  if (element.propertyName !== undefined && element.propertyName.kind === SyntaxKind.PrivateIdentifier)
+    grammarErrorOnNode(
+      c,
+      element.propertyName,
+      Diagnostics.Private_identifiers_cannot_be_used_in_destructuring_patterns,
+    );
   if (
     element.propertyName !== undefined &&
     element.name.kind === SyntaxKind.Identifier &&
@@ -598,6 +606,7 @@ export function checkFunctionDeclaration(c: Checker, node: Node): void {
   const symbol = getSymbolOfDeclaration(c, node);
   if (symbol !== undefined) getTypeOfSymbol(c, symbol);
   checkFunctionLikeBody(c, node);
+  checkJSDocFullSignatureType(c, node);
   checkJSDocFullSignature(c, node);
   checkFunctionOrMethodSymbols(c, node);
   checkCollisionsForDeclarationName(c, node, getName(node));
@@ -775,6 +784,8 @@ export function checkEnumMember(c: Checker, node: Node): void {
   const name = getName(node);
   if (name !== undefined && name.kind === SyntaxKind.PrivateIdentifier)
     c.error(node, Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier);
+  // A computed name is a grammar error, but its expression is checked.
+  if (name !== undefined && name.kind === SyntaxKind.ComputedPropertyName) checkExpression(c, getExpression(name)!);
   const initializer = getInitializer(node);
   if (initializer !== undefined) checkExpression(c, initializer);
 }
@@ -794,7 +805,8 @@ export function checkEnumDeclaration(c: Checker, node: Node): void {
   if (links.enumChecked) return;
   links.enumChecked = true;
   if (declarationCount(symbol) > 1) {
-    const enumIsConst = isEnumConst(node);
+    // Reported against the first enum declaration, whichever declaration is checked first.
+    const enumIsConst = isEnumConst(getDeclarationOfKind(symbol, SyntaxKind.EnumDeclaration)!);
     for (const d of getDeclarations(symbol))
       if (d.kind === SyntaxKind.EnumDeclaration && isEnumConst(d) !== enumIsConst)
         c.error(getNameOfDeclaration(d), Diagnostics.Enum_declarations_must_all_be_const_or_non_const);
@@ -814,6 +826,14 @@ export function checkEnumDeclaration(c: Checker, node: Node): void {
   }
 }
 
+/** An ambient module's import attributes type must be assignable to the global `ImportAttributes`. */
+function checkImportAttributesType(c: Checker, attributes: TypeLiteralNode): void {
+  checkSourceElement(c, attributes);
+  const importAttributesType = getCachedGlobalType(c, 'ImportAttributes', 0, true);
+  if (importAttributesType !== c.emptyObjectType)
+    checkTypeAssignableTo(c, getTypeFromTypeNode(c, attributes), importAttributesType, attributes, undefined);
+}
+
 /** Whether erasableSyntaxOnly applies at `node`: it is set, and `node` is in a TypeScript file. */
 export function shouldCheckErasableSyntax(c: Checker, node: Node): boolean {
   return c.compilerOptions.erasableSyntaxOnly === true && !isInJSFile(node);
@@ -830,6 +850,8 @@ export function checkModuleDeclaration(c: Checker, node: Node): void {
       module.name,
       Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context,
     );
+  const attributes = module.attributes;
+  if (attributes !== undefined) checkImportAttributesType(c, attributes);
   const contextMessage = isAmbientModule(node)
     ? Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file
     : Diagnostics.A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module;
@@ -888,6 +910,8 @@ export function checkModuleDeclaration(c: Checker, node: Node): void {
   }
   if (!isAmbientModule(node)) return;
   if (isModuleAugmentationExternal(node)) {
+    if (attributes !== undefined)
+      c.error(attributes, Diagnostics.Import_attributes_are_not_allowed_on_a_module_augmentation);
     // Check an augmentation's body only when it merged with its target.
     const checkBody = isGlobalAugmentation || (symbol !== undefined && (symbol.flags & SymbolFlags.Transient) !== 0);
     if (checkBody && body !== undefined && body.kind === SyntaxKind.ModuleBlock)
@@ -1066,7 +1090,10 @@ export function checkExportsOnMergedDeclarations(c: Checker, node: Node): void {
     symbol = getSymbolOfDeclaration(c, node);
     if (symbol === undefined || symbol.exportSymbol === undefined) return;
   }
-  if (getDeclarationOfKind(symbol, node.kind) !== node) return;
+  if (declarationCount(symbol) < 2) return;
+  const links = c.symbolLinks(symbol);
+  if (links.mergedExportsChecked) return;
+  links.mergedExportsChecked = true;
   let exported = DeclarationSpaces.None;
   let nonExported = DeclarationSpaces.None;
   let defaultExported = DeclarationSpaces.None;

package/src/compiler/checker-declared-types.ts

@@ -19,7 +19,8 @@ import {
   MappedTypeNode,
   getHeritageClauses,
 } from './ast.js';
-import { getSourceFileOfNode, isEnumConst, isObjectLiteralMethod } from './binder-utilities.js';
+import { getSourceFileOfNode, hasDynamicName, isEnumConst, isObjectLiteralMethod } from './binder-utilities.js';
+import { getHeritageClauseElementName } from './ast-utilities.js';
 import { Diagnostics } from './diagnostics.js';
 import { SyntaxKind } from './syntax-kind.js';
 import { type Checker, createDiagnosticForNode } from './checker.js';
@@ -56,6 +57,7 @@ import {
   typeListKey,
   typesOf,
   typeListHash,
+  compareTypes,
 } from './checker-type-factory.js';
 import {
   TypeSystemPropertyName,
@@ -157,9 +159,9 @@ function isThislessInterface(c: Checker, symbol: Symbol): boolean {
     if (declaration.kind !== SyntaxKind.InterfaceDeclaration) continue;
     if ((declaration.flags & NodeFlags.ContainsThis) !== 0) return false;
     for (const node of getExtendsHeritageClauseElements(declaration)) {
-      const expression = getExpression(node)!;
-      if (isEntityNameExpression(expression)) {
-        const baseSymbol = resolveEntityName(c, expression, SymbolFlags.Type, true, false, undefined);
+      const name = getHeritageClauseElementName(node);
+      if (name.kind === SyntaxKind.QualifiedName || isEntityNameExpression(name)) {
+        const baseSymbol = resolveEntityName(c, name, SymbolFlags.Type, true, false, undefined);
         if (
           baseSymbol === undefined ||
           (baseSymbol.flags & SymbolFlags.Interface) === 0 ||
@@ -302,6 +304,7 @@ export function getInferTypeParameters(c: Checker, node: Node): Type[] {
   if (locals !== undefined)
     for (const symbol of locals.values())
       if ((symbol.flags & SymbolFlags.TypeParameter) !== 0) result.push(getDeclaredTypeOfSymbol(c, symbol));
+  result.sort((t1, t2) => compareTypes(c, t1, t2));
   return result;
 }
 
@@ -377,7 +380,7 @@ export function getDeclaredTypeOfEnum(c: Checker, symbol: Symbol): Type {
   for (const declaration of getDeclarations(symbol)) {
     if (declaration.kind !== SyntaxKind.EnumDeclaration) continue;
     for (const member of (declaration as EnumDeclaration).members.nodes) {
-      if (!hasBindableName(member)) continue;
+      if (hasDynamicName(member)) continue;
       const memberSymbol = getSymbolOfDeclaration(c, member)!;
       computeEnumMemberValues(c, declaration);
       const memberLinks = c.nodeLinks(member);

package/src/compiler/checker-decorators.ts

@@ -404,7 +404,7 @@ export function getDecoratorArgumentCount(c: Checker, node: Node, signature: Sig
     case SyntaxKind.GetAccessor:
     case SyntaxKind.SetAccessor:
       // Decorators with only two parameters get only two arguments.
-      return signature.parameters.length <= 2 ? 2 : 3;
+      return getParameterCount(c, signature) <= 2 ? 2 : 3;
   }
   return 3;
 }

package/src/compiler/checker-deprecation.ts

@@ -6,15 +6,16 @@ import {
   type IndexedAccessTypeNode,
   JSDoc,
   JSDocDeprecatedTag,
-  type JsxAttribute,
   type JsxNamespacedName,
   type Node,
+  type SourceFile,
   NodeFlags,
   type QualifiedName,
   type TaggedTemplateExpression,
   type TypeReferenceNode,
   getExpression,
   getName,
+  getProperties,
   getTagName,
   getText,
 } from './ast.js';
@@ -31,6 +32,7 @@ import { hasMatchingArgument } from './checker-narrowing.js';
 import { entityNameToString } from './checker-expressions.js';
 import { isErrorType } from './checker-type-factory.js';
 import { getPropertyOfType } from './checker-members.js';
+import { getApparentTypeOfContextualType } from './checker-contextual.js';
 import { signatureToString } from './type-printer.js';
 import { declarationAt, declarationCount, getDeclarations, type Symbol, SymbolFlags } from './symbol.js';
 
@@ -347,11 +349,30 @@ export function checkDeprecatedImportSpecifier(c: Checker, node: Node, symbol: S
     addDeprecatedSuggestion(c, node, getDeclarations(targetSymbol), targetSymbol.name);
 }
 
-/** Reports a JSX attribute setting a deprecated property of the element's contextual props type. */
-export function checkDeprecatedJsxAttribute(c: Checker, contextualType: Type, attribute: JsxAttribute): void {
-  const name = attribute.name;
-  if (name.kind !== SyntaxKind.Identifier) return;
-  const prop = getPropertyOfType(c, contextualType, getText(name));
-  if (prop !== undefined && declarationCount(prop) !== 0 && isDeprecatedSymbol(c, prop))
-    addDeprecatedSuggestion(c, name, getDeclarations(prop), getText(name));
+/** Reports the deprecated properties the checked object literals of `file` set (`checkContextualDeprecations`). */
+export function checkObjectLiteralDeprecations(c: Checker, file: SourceFile): void {
+  const pending = c.objectLiteralsForDeprecations.get(file);
+  if (pending === undefined) return;
+  c.objectLiteralsForDeprecations.delete(file);
+  for (const node of pending) checkContextualDeprecations(c, node);
+}
+
+/**
+ * Reports the members of an object literal or the attributes of a JSX element that set a deprecated
+ * property of its contextual type. Deferred, so the contextual type of the final check is used.
+ */
+export function checkContextualDeprecations(c: Checker, node: Node): void {
+  const contextualType = getApparentTypeOfContextualType(c, node);
+  if (contextualType === undefined) return;
+  for (const property of getProperties(node)!.nodes) {
+    const name = getName(property);
+    if (name === undefined || name.kind === SyntaxKind.ComputedPropertyName) continue;
+    const text =
+      name.kind === SyntaxKind.JsxNamespacedName
+        ? (name as JsxNamespacedName).namespace.text + ':' + (name as JsxNamespacedName).name.text
+        : getText(name);
+    const prop = getPropertyOfType(c, contextualType, text);
+    if (prop !== undefined && declarationCount(prop) !== 0 && isDeprecatedSymbol(c, prop))
+      addDeprecatedSuggestion(c, name, getDeclarations(prop), text);
+  }
 }

package/src/compiler/checker-destructuring.ts

@@ -110,7 +110,12 @@ import {
 } from './checker-expressions.js';
 import { IterationUse, checkIteratedTypeOrElementType, createIterableType } from './checker-iteration.js';
 import { ScriptTarget } from './options.js';
-import { checkBinaryExpression, checkReferenceExpression, removeDefinitelyFalsyTypes } from './checker-operators.js';
+import {
+  checkBinaryExpression,
+  checkReferenceExpression,
+  grammarErrorOnNode,
+  removeDefinitelyFalsyTypes,
+} from './checker-operators.js';
 import { TypeFacts, getNonNullableType, getTypeWithFacts, hasTypeFacts } from './checker-flow.js';
 import { sliceTupleType } from './checker-signatures.js';
 import { getPropertyNameFromType, isTypeUsableAsPropertyName, maybeTypeOfKind } from './checker-utilities.js';
@@ -462,7 +467,7 @@ function padObjectLiteralType(c: Checker, t: Type, pattern: Node): Type {
   const missingElements: BindingElement[] = [];
   for (const node of getElements(pattern)!.nodes) {
     const e = node as BindingElement;
-    if (e.initializer === undefined) continue;
+    if (e.dotDotDotToken !== undefined) continue;
     const name = getPropertyNameFromBindingElement(c, e);
     if (name !== undefined && getPropertyOfType(c, t, name) === undefined) missingElements.push(e);
   }
@@ -471,7 +476,7 @@ function padObjectLiteralType(c: Checker, t: Type, pattern: Node): Type {
   for (const prop of getPropertiesOfObjectType(c, t)) members.set(prop.name, prop);
   for (const e of missingElements) {
     const symbol = c.newSymbol(SymbolFlags.Property | SymbolFlags.Optional, getPropertyNameFromBindingElement(c, e)!);
-    c.symbolTypes.set(getSymbolId(symbol), getTypeFromBindingElement(c, e, false, false));
+    c.symbolTypes.set(getSymbolId(symbol), getTypeFromBindingElement(c, e, false, true));
     members.set(symbol.name, symbol);
   }
   const result = createAnonymousType(c, t.symbol, members, [], [], getIndexInfosOfType(c, t));
@@ -588,6 +593,8 @@ function checkObjectLiteralDestructuringPropertyAssignment(
   const property = properties[propertyIndex]!;
   if (property.kind === SyntaxKind.PropertyAssignment || property.kind === SyntaxKind.ShorthandPropertyAssignment) {
     const name = getName(property)!;
+    if (name.kind === SyntaxKind.PrivateIdentifier)
+      grammarErrorOnNode(c, name, Diagnostics.Private_identifiers_cannot_be_used_in_destructuring_patterns);
     markDestructuredPropertyAsReferenced(c, objectLiteralType, name, property, rightIsThis);
     const exprType = getLiteralTypeFromPropertyName(c, name) ?? c.errorType;
     if (isTypeUsableAsPropertyName(exprType)) {

package/src/compiler/checker-emit-helpers.ts

@@ -174,6 +174,7 @@ function resolveHelpersModule(c: Checker, file: SourceFile, errorNode: Node): Sy
         Diagnostics.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found,
         errorNode,
         false,
+        undefined,
       ) ?? c.unknownSymbol;
   return links.helpersModule;
 }