tsc-ts 0.0.10 → 0.1.1

package/src/compiler/binder.ts

@@ -30,6 +30,7 @@ import {
   MetaProperty,
   ModifierFlags,
   ModuleDeclaration,
+  getNodeId,
   type Node,
   NonNullExpression,
   NodeFlags,
@@ -590,7 +591,16 @@ class Binder extends NodeVisitor {
     if (name !== undefined) {
       if (isAmbientModule(node)) {
         if (isGlobalScopeAugmentation(node)) return InternalSymbolName.Global;
-        return '"' + nodeText(name) + '"';
+        const moduleName = nodeText(name);
+        // A pattern module with import attributes has its own symbol, named after the attributes node's id: it merges
+        // only with pattern modules of the same pattern and identical attributes, which the checker decides. The id
+        // is written at a fixed width so that names sort in declaration order.
+        const attributes = (node as ModuleDeclaration).attributes;
+        if (attributes !== undefined && hasSingleStar(moduleName))
+          return (
+            internalSymbolNamePrefix + '"' + moduleName + '"pattern@' + String(getNodeId(attributes)).padStart(10, '0')
+          );
+        return '"' + moduleName + '"';
       }
       if (name.kind === SyntaxKind.PrivateIdentifier) {
         // Private names are only allowed in classes; elsewhere there is already a parse error.
@@ -1116,7 +1126,6 @@ class Binder extends NodeVisitor {
     if (this.seenThisKeyword) node.flags |= NodeFlags.ContainsThis;
     if (node.kind === SyntaxKind.SourceFile) {
       node.flags |= this.emitFlags;
-      (node as SourceFile).endFlowNode = this.currentFlow;
     }
     const returnTarget = this.currentReturnTarget;
     if (returnTarget !== undefined) {
@@ -1516,11 +1525,19 @@ class Binder extends NodeVisitor {
   }
 
   bindForStatement(node: ForStatement): void {
+    this.bindOptional(node.initializer);
+    if (this.currentFlow === this.unreachableFlow) {
+      // An initializer that ends the flow (a throwing IIFE) would leave the loop label only the
+      // incrementor's back edge: a cycle with no entry. Bind the rest as unreachable.
+      this.bindOptional(node.condition);
+      this.bind(node.statement);
+      this.bindOptional(node.incrementor);
+      return;
+    }
     const preLoopLabel = this.setContinueTarget(node, this.createLoopLabel());
     const preBodyLabel = this.createBranchLabel();
     const preIncrementorLabel = this.createBranchLabel();
     const postLoopLabel = this.createBranchLabel();
-    this.bindOptional(node.initializer);
     this.addAntecedent(preLoopLabel, this.currentFlow);
     this.currentFlow = preLoopLabel;
     this.bindCondition(node.condition, preBodyLabel, postLoopLabel);
@@ -1534,9 +1551,15 @@ class Binder extends NodeVisitor {
   }
 
   bindForInOrForOfStatement(node: ForInOrOfStatement): void {
+    this.bind(node.expression);
+    if (this.currentFlow === this.unreachableFlow) {
+      // As for a `for` initializer: an expression that ends the flow leaves the loop unreachable.
+      this.bind(node.initializer);
+      this.bind(node.statement);
+      return;
+    }
     const preLoopLabel = this.setContinueTarget(node, this.createLoopLabel());
     const postLoopLabel = this.createBranchLabel();
-    this.bind(node.expression);
     this.addAntecedent(preLoopLabel, this.currentFlow);
     this.currentFlow = preLoopLabel;
     if (node.kind === SyntaxKind.ForOfStatement) this.bindOptional(node.awaitModifier);
@@ -1980,6 +2003,12 @@ class Binder extends NodeVisitor {
             this.file.patternAmbientModules,
             new PatternAmbientModule(text, starIndex, symbol),
           );
+        else if (node.attributes !== undefined)
+          this.errorOnNode(
+            name,
+            Diagnostics.An_ambient_module_declaration_with_import_attributes_must_use_a_pattern_name_with_an_Asterisk_character,
+            noArgs,
+          );
       }
       return;
     }
@@ -2711,3 +2740,9 @@ export function findUseStrictPrologue(file: SourceFile, statements: readonly Nod
   }
   return undefined;
 }
+
+/** Whether a module name is a pattern with exactly one `*`. */
+function hasSingleStar(text: string): boolean {
+  const star = text.indexOf('*');
+  return star >= 0 && text.indexOf('*', star + 1) < 0;
+}

package/src/compiler/cgroup.ts

@@ -0,0 +1,157 @@
+// The limits the process's cgroup puts on the machine a run sees: the whole CPUs its CPU quota allows
+// and the smallest memory limit of its cgroup and that cgroup's ancestors. `os.availableParallelism()`
+// already lowers its count to a quota of one CPU or more; the native runtime's count ignores a quota
+// below one, which truncates to no CPUs there and falls back to the affinity mask, so the quota is read
+// here too. The memory limit only sometimes reaches `process.constrainedMemory()` (libuv reads the
+// process's own cgroup, and scriptc's runtime only the root of the cgroup mount, which is the process's
+// own cgroup only inside a cgroup namespace).
+import { readFileSync } from 'node:fs';
+import { availableParallelism } from 'node:os';
+
+/**
+ * The CPUs this process may run on: `os.availableParallelism()`, lowered to the whole CPUs its cgroup
+ * quota allows (`cgroupCpuQuota`). Where the runtime already applies the quota this returns the same
+ * count; a quota below one CPU, which the native runtime's count ignores, lowers it to one. The text and
+ * root parameters are for the tests.
+ */
+export function availableCpus(membershipText: string = readMembership(), root: string = '/sys/fs/cgroup'): number {
+  const cpus = Math.max(1, availableParallelism());
+  const quota = cgroupCpuQuota(membershipText, root);
+  return quota > 0 && quota < cpus ? quota : cpus;
+}
+
+/**
+ * The whole CPUs this process's cgroup and its ancestors allow, or 0 where there is none or it is
+ * unknown: `cpu.max` under cgroup v2, `cpu.cfs_quota_us` and `cpu.cfs_period_us` under v1. A quota
+ * below one CPU counts as one, the least a run can use. The text and root parameters are for the tests.
+ */
+export function cgroupCpuQuota(membershipText: string = readMembership(), root: string = '/sys/fs/cgroup'): number {
+  let quota = 0;
+  const lower = (value: number): void => {
+    if (value > 0 && (quota === 0 || value < quota)) quota = value;
+  };
+  forEachCgroupDirectory(membershipText, root, '', (directory) => {
+    lower(cpuMaxValue(directory + '/cpu.max'));
+  });
+  forEachCgroupDirectory(membershipText, root, 'cpu', (directory) => {
+    // The kernel's default period, for a mount that lost the file but kept its quota.
+    const period = numberIn(directory + '/cpu.cfs_period_us') || 100_000;
+    lower(wholeCpus(numberIn(directory + '/cpu.cfs_quota_us'), period));
+  });
+  return quota;
+}
+
+/**
+ * The smallest memory limit of this process's cgroup and its ancestors (Linux), or 0 where there is
+ * none or it is unknown: `memory.max` and `memory.high` under cgroup v2, `memory.limit_in_bytes` under
+ * v1. The text and root parameters are for the tests.
+ */
+export function cgroupMemoryLimit(membershipText: string = readMembership(), root: string = '/sys/fs/cgroup'): number {
+  let limit = 0;
+  const lower = (value: number): void => {
+    if (value > 0 && (limit === 0 || value < limit)) limit = value;
+  };
+  forEachCgroupDirectory(membershipText, root, '', (directory) => {
+    lower(memoryLimitValue(directory + '/memory.max'));
+    lower(memoryLimitValue(directory + '/memory.high'));
+  });
+  forEachCgroupDirectory(membershipText, root, 'memory', (directory) => {
+    lower(memoryLimitValue(directory + '/memory.limit_in_bytes'));
+  });
+  return limit;
+}
+
+/**
+ * Calls `visit` with the directory of this process's cgroup for `controller` and of each of its
+ * ancestors, deepest first: the unified hierarchy for `''` (cgroup v2, whose line lists no
+ * controllers), or the controller's own mount for a v1 line that lists it.
+ */
+function forEachCgroupDirectory(
+  membershipText: string,
+  root: string,
+  controller: string,
+  visit: (directory: string) => void,
+): void {
+  for (const line of membershipText.split('\n')) {
+    // "0::/path" (v2), "N:cpu:/path" or "N:cpu,cpuacct:/path" (v1).
+    const first = line.indexOf(':');
+    const second = line.indexOf(':', first + 1);
+    if (first < 0 || second < 0) continue;
+    const controllers = line.substring(first + 1, second);
+    const path = line.substring(second + 1);
+    if (controller === '') {
+      if (controllers !== '') continue;
+      forEachAncestor(path, (directory) => visit(root + directory));
+    } else if (controllers.split(',').indexOf(controller) >= 0) {
+      forEachAncestor(path, (directory) => visit(root + '/' + controller + directory));
+    }
+  }
+}
+
+/**
+ * Calls `visit` with `path` and each of its ancestors, deepest first ("/a/b/c", "/a/b", "/a", ""): a
+ * cgroup's limits apply to every process below it, in cgroup v1 as in v2.
+ */
+function forEachAncestor(path: string, visit: (directory: string) => void): void {
+  for (let directory = path; ; directory = directory.substring(0, directory.lastIndexOf('/'))) {
+    visit(directory === '/' ? '' : directory);
+    if (directory === '' || directory.lastIndexOf('/') < 0) break;
+  }
+}
+
+/** `/proc/self/cgroup`, or an empty text where it cannot be read (no cgroup limits). */
+function readMembership(): string {
+  try {
+    return readFileSync('/proc/self/cgroup', 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * The whole CPUs a cgroup v2 quota file allows, or 0 for `max`, an unreadable file or no number:
+ * `cpu.max` holds "MAX PERIOD" in microseconds.
+ */
+function cpuMaxValue(file: string): number {
+  let text: string;
+  try {
+    text = readFileSync(file, 'utf8').trim();
+  } catch {
+    return 0;
+  }
+  if (text === '' || text === 'max') return 0;
+  const parts = text.split(/\s+/).map(Number);
+  return wholeCpus(parts[0]!, parts[1] ?? 100_000);
+}
+
+/** A cgroup memory limit file's value in bytes, or 0 for `max`, an unreadable file or no number. */
+function memoryLimitValue(file: string): number {
+  let text: string;
+  try {
+    text = readFileSync(file, 'utf8').trim();
+  } catch {
+    return 0;
+  }
+  if (text === '' || text === 'max') return 0;
+  const value = Number(text);
+  // cgroup v1 reports no limit as a page-aligned value near 2^63.
+  return Number.isFinite(value) && value > 0 && value < 2 ** 62 ? value : 0;
+}
+
+/** A file's number, or 0 where it cannot be read or holds none (a v1 quota of -1 is no quota). */
+function numberIn(file: string): number {
+  let text: string;
+  try {
+    text = readFileSync(file, 'utf8').trim();
+  } catch {
+    return 0;
+  }
+  const value = Number(text);
+  return Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+/** The whole CPUs `quota` microseconds per `period` microseconds allow, at least one where there is one. */
+function wholeCpus(quota: number, period: number): number {
+  if (!Number.isFinite(quota) || !Number.isFinite(period) || quota <= 0 || period <= 0) return 0;
+  return Math.max(1, Math.floor(quota / period));
+}

package/src/compiler/character-codes.ts

@@ -295,8 +295,8 @@ export function isIdentifierPart(codePoint: number, languageVariant = LanguageVa
     isWordCharacter(codePoint) ||
     codePoint === CharacterCodes.$ ||
     (codePoint > CharacterCodes.maxAsciiCharacter && isUnicodeIdentifierPart(codePoint)) ||
-    (languageVariant === LanguageVariant.JSX &&
-      (codePoint === CharacterCodes.minus || codePoint === CharacterCodes.colon))
+    // `:` is part of a JSX namespaced name, but not of a JSX identifier.
+    (languageVariant === LanguageVariant.JSX && codePoint === CharacterCodes.minus)
   );
 }
 

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,8 @@ import {
   checkInterfaceHeritage,
 } from './checker-heritage.js';
 import { checkDecorators, getFirstTransformableStaticClassElement } from './checker-decorators.js';
+import { getTypeOfNode } from './checker-services.js';
+import { IdentifierName } from './identifier-name.js';
 
 export function checkClassDeclaration(c: Checker, node: Node): void {
   checkClassLikeDeclaration(c, node);
@@ -148,6 +156,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 +266,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)
@@ -563,7 +589,7 @@ function newThisPropertyReference(symbol: Symbol, container: Node, flowNode: Flo
   const name = symbol.name;
   let accessName: Node;
   if (name.startsWith('\ufffe#')) accessName = new PrivateIdentifier(name.substring(name.indexOf('@') + 1));
-  else accessName = new Identifier(name);
+  else accessName = new Identifier(new IdentifierName(name));
   const thisExpression = new KeywordExpression(SyntaxKind.ThisKeyword);
   const reference = new PropertyAccessExpression(thisExpression, undefined, accessName, NodeFlags.None);
   thisExpression.parent = reference;
@@ -612,35 +638,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;
 }