tsc-ts 0.0.9 → 0.1.0

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

@@ -19,7 +19,7 @@ export declare function resolveStructuredTypeMembers(c: Checker, t: Type): Struc
  * `t` writes them there; `t` keeps its identity and is never written.
  */
 export declare function membersHolder(c: Checker, t: Type): StructuredType;
-/** The `objectFlags` of `t` that resolving its members sets (MembersResolved, UnresolvedMembers). */
+/** The `objectFlags` of `t` that resolving its members sets (MembersResolved). */
 export declare function memberResolutionFlags(c: Checker, t: Type): ObjectFlags;
 declare const enum MemberState {
     Skipped = 0,
@@ -32,6 +32,8 @@ export declare class PendingInstantiatedMembers extends PendingMembers {
     readonly sourceTable: SymbolTable | undefined;
     /** Anonymous type instantiations: the properties of the target, in order. */
     readonly sourceList: Symbol[] | undefined;
+    /** The source's members at their positions: `sourceList`, or the declared members in table order. */
+    readonly sourceMembers: Symbol[];
     readonly mapper: TypeMapper;
     /** MemberState of each member of the source, in order, 16 to a word. */
     readonly states: number[];
@@ -59,7 +61,7 @@ export declare class PendingInstantiatedMembers extends PendingMembers {
     /** Whether the instantiated table has an own member, and one that isn't optional. */
     readonly hasOwnMembers: boolean;
     readonly hasRequiredOwnMembers: boolean;
-    constructor(c: Checker, sourceTable: SymbolTable | undefined, sourceList: Symbol[] | undefined, mapper: TypeMapper, states: number[], positions: Map<string, number>, hasOwnMembers: boolean, hasRequiredOwnMembers: boolean);
+    constructor(c: Checker, sourceTable: SymbolTable | undefined, sourceList: Symbol[] | undefined, sourceMembers: Symbol[], mapper: TypeMapper, states: number[], positions: Map<string, number>, hasOwnMembers: boolean, hasRequiredOwnMembers: boolean);
     /** Records the next base: `base` where its pending table is complete, else its `properties`. */
     addBase(base: StructuredType | undefined, properties: Symbol[] | undefined): void;
     /** The base at `index` where its pending table is complete (`addBase`), else undefined. */
@@ -83,6 +85,11 @@ export declare class PendingInstantiatedMembers extends PendingMembers {
      */
     private keepTableOnDemand;
     materializeTable(t: StructuredType): void;
+    /**
+     * The property order of the source's instantiations for `container` (computed for the first container
+     * asked for), or undefined.
+     */
+    private namedMemberOrder;
 }
 /**
  * The members of a type whose members table holds only its properties, in the order of the

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

@@ -1,14 +1,14 @@
 import { getCombinedModifierFlags, getDeclarationOfKind } from './binder-utilities.js';
 import { getSymbol, getName } from './ast.js';
-import { cachedTypeKey, CompositeSignature, IndexInfo, MemberNames, unionOrIntersectionMembers, emptyIndexInfos, emptySignatures, emptySymbols, emptyTypes, newThisArgumentTypeMapper, newTypeMapper, prependTypeMapping, PendingMembers, } from './checker-types.js';
+import { cachedTypeKey, CompositeSignature, IndexInfo, DeclaredMemberPlan, MemberNames, NamedMemberOrder, unionOrIntersectionMembers, emptyIndexInfos, emptySignatures, emptySymbols, emptyTypes, newThisArgumentTypeMapper, newTypeMapper, prependTypeMapping, PendingMembers, getMappedType, } from './checker-types.js';
 import { createArrayTypeEx, createTupleTypeEx, createTypeReference, everyType, getElementTypes, getIntersectionType, getStringLiteralType, getTemplateLiteralType, getTypeArguments, getUnionOrIntersectionType, getUnionType, getUnionTypeEx, isArrayOrTupleType, isErrorType, isGenericTupleType, isLiteralType, isPatternLiteralType, isReadonlyArrayType, isTupleType, mapType, setStructuredTypeMembers, someType, tupleTargetOf, typesOf, } from './checker-type-factory.js';
 import { getRestTypeOfTupleType, mappedTypeTarget } from './checker-type-operators.js';
 import { isAmbientModule } from './ast-utilities.js';
-import { getExportsOfSymbol, getLateBoundSymbol, getMembersOfSymbol, getMergedSymbol, getNamedMembers, getSymbolOfDeclaration, isReservedMemberName, popTypeResolution, pushTypeResolution, symbolIsValue, } from './checker-symbols.js';
+import { getExportsOfSymbol, getLateBoundSymbol, getMembersOfSymbol, getMergedSymbol, getNamedMemberPositions, getNamedMembers, getSymbolOfDeclaration, isReservedMemberName, popTypeResolution, pushTypeResolution, symbolIsValue, } from './checker-symbols.js';
 import { getBaseConstructorTypeOfClass, getBaseTypes, getConstraintDeclaration, getConstraintFromTypeParameter, getDeclaredTypeOfClassOrInterface, getDeclaredTypeOfSymbol, getLocalTypeParametersOfClassOrInterfaceOrTypeAlias, isMixinConstructorType, } from './checker-declared-types.js';
 import { getTypeOfSymbol, getWriteTypeOfSymbol, isReadonlySymbol } from './checker-symbol-types.js';
 import { getTypeFromTypeNode } from './checker-type-nodes.js';
-import { instantiateIndexInfos, instantiateSignatures, instantiateSymbol, instantiateType, keepsSymbolUnderInstantiation, newInstantiatedSymbol, instantiateTypes, } from './instantiation.js';
+import { instantiateIndexInfos, instantiateSignatures, instantiateSymbol, instantiateType, isThisless, keepsSymbolTypeUnderInstantiation, keepsSymbolUnderInstantiation, newInstantiatedSymbol, instantiateTypes, } from './instantiation.js';
 import { compareProperties, compareSignaturesIdentical, compareTypesIdentical, getRecursionIdentity, isTypeAssignableTo, } from './relations.js';
 import { isUnmatchedTemplateLiteralKey } from './checker-inference.js';
 import { typeToString } from './type-printer.js';
@@ -42,7 +42,7 @@ export function membersHolder(c, t) {
         return unionOrIntersectionMembers(side);
     return side;
 }
-/** The `objectFlags` of `t` that resolving its members sets (MembersResolved, UnresolvedMembers). */
+/** The `objectFlags` of `t` that resolving its members sets (MembersResolved). */
 export function memberResolutionFlags(c, t) {
     if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) === 0)
         return lazyObjectFlags(c, t);
@@ -128,8 +128,7 @@ function resolveObjectTypeMembers(c, t, source, typeParameters, typeArguments, t
     }
     if (baseTypes.length !== 0) {
         members = !instantiated || members === undefined ? new Map(members ?? []) : members;
-        setStructuredTypeMembers(c, t, members, callSignatures, constructSignatures, indexInfos);
-        t.objectFlags |= 536870912 /* ObjectFlags.UnresolvedMembers */;
+        // The members are set once the bases are added: a recursive request for them resolves them again.
         for (const baseType of baseTypes) {
             const instantiatedBaseType = lastArgument !== undefined
                 ? getTypeWithThisArgument(c, instantiateType(c, baseType, mapper), lastArgument, false)
@@ -150,7 +149,6 @@ function resolveObjectTypeMembers(c, t, source, typeParameters, typeArguments, t
             if (added.length !== 0)
                 indexInfos = indexInfos.concat(added);
         }
-        t.objectFlags &= ~536870912 /* ObjectFlags.UnresolvedMembers */;
     }
     setStructuredTypeMembers(c, t, members, callSignatures, constructSignatures, indexInfos);
 }
@@ -162,6 +160,8 @@ export class PendingInstantiatedMembers extends PendingMembers {
     sourceTable;
     /** Anonymous type instantiations: the properties of the target, in order. */
     sourceList;
+    /** The source's members at their positions: `sourceList`, or the declared members in table order. */
+    sourceMembers;
     mapper;
     /** MemberState of each member of the source, in order, 16 to a word. */
     states;
@@ -189,8 +189,9 @@ export class PendingInstantiatedMembers extends PendingMembers {
     /** Whether the instantiated table has an own member, and one that isn't optional. */
     hasOwnMembers;
     hasRequiredOwnMembers;
-    constructor(c, sourceTable, sourceList, mapper, states, positions, hasOwnMembers, hasRequiredOwnMembers) {
+    constructor(c, sourceTable, sourceList, sourceMembers, mapper, states, positions, hasOwnMembers, hasRequiredOwnMembers) {
         super();
+        this.sourceMembers = sourceMembers;
         this.hasOwnMembers = hasOwnMembers;
         this.hasRequiredOwnMembers = hasRequiredOwnMembers;
         this.c = c;
@@ -315,6 +316,22 @@ export class PendingInstantiatedMembers extends PendingMembers {
     materialize(t) {
         const c = this.c;
         t.pendingMembers = undefined;
+        if (!this.hasBases) {
+            // The properties are the source's named members, in the order cached for the source
+            // (`NamedMemberOrder`), and they are all of the table, which is built only when asked for.
+            const order = this.namedMemberOrder(t.symbol);
+            if (order !== undefined) {
+                const sourceMembers = this.sourceMembers;
+                const properties = [];
+                for (const position of order.positions)
+                    properties.push(this.memberAt(position, sourceMembers[position]));
+                this.instantiated = undefined;
+                t.membersValue = undefined;
+                t.propertiesValue = properties;
+                t.pendingMembers = new PropertyMembers(properties, order.names);
+                return;
+            }
+        }
         const members = this.ownTable();
         this.instantiated = undefined;
         if (!this.hasBases) {
@@ -364,6 +381,51 @@ export class PendingInstantiatedMembers extends PendingMembers {
         if (pending !== undefined)
             pending.materializeTable(t);
     }
+    /**
+     * The property order of the source's instantiations for `container` (computed for the first container
+     * asked for), or undefined.
+     */
+    namedMemberOrder(container) {
+        const c = this.c;
+        const owner = this.owner;
+        let order = owner !== undefined ? owner.namedMemberOrder : c.namedMemberOrdersOfLists.get(this.sourceList);
+        if (order === undefined) {
+            order = namedMemberOrderOf(c, this.sourceMembers, container, owner !== undefined);
+            if (owner !== undefined)
+                owner.namedMemberOrder = order;
+            else
+                c.namedMemberOrdersOfLists.set(this.sourceList, order);
+        }
+        return order !== null && order.container === container ? order : undefined;
+    }
+}
+/**
+ * The `NamedMemberOrder` of instantiations of `members` for `container`; null where `getNamedMemberPositions`
+ * has none. With `skipsUnnamed` (declared members), an instantiation's table holds the named members, the
+ * others being skipped, in the order of `members`; without it, every member must be named.
+ */
+function namedMemberOrderOf(c, members, container, skipsUnnamed) {
+    const positions = getNamedMemberPositions(c, members, container);
+    // Members of a list are never skipped (`pendingInstantiatedList`): its table holds them all.
+    if (positions === undefined || (!skipsUnnamed && positions.length !== members.length))
+        return null;
+    const names = [];
+    const byName = new Map();
+    // The index in `positions` of each member's position, or -1 for a member that isn't a property.
+    const indexes = [];
+    for (let i = 0; i < members.length; i++)
+        indexes.push(-1);
+    for (let i = 0; i < positions.length; i++) {
+        const name = members[positions[i]].name;
+        names.push(name);
+        byName.set(name, i);
+        indexes[positions[i]] = i;
+    }
+    const tableOrder = [];
+    for (const index of indexes)
+        if (index >= 0)
+            tableOrder.push(index);
+    return new NamedMemberOrder(container, positions, new MemberNames(names, byName, tableOrder));
 }
 /**
  * The members of a type whose members table holds only its properties, in the order of the
@@ -459,39 +521,80 @@ function pendingInstantiatedTable(c, source, mapper) {
     const table = declared.declaredMembers;
     if (table === undefined || table.size === 0)
         return undefined;
+    const plan = declaredMemberPlan(c, declared, table);
+    if (plan.eager)
+        return undefined;
+    const members = plan.members;
+    const named = plan.named;
+    const keptByType = plan.keptByType;
     const states = [];
     let word = 0;
-    let i = 0;
-    let hasOwnMembers = false;
-    let hasRequiredOwnMembers = false;
-    for (const [id, symbol] of table) {
-        if (id !== symbol.name)
-            return undefined;
+    const count = members.length;
+    for (let i = 0; i < count; i++) {
         let state = 0 /* MemberState.Skipped */;
-        if (isNamedMember(c, symbol, id)) {
-            // A named member without a value flag (an alias) could be replaced by an inherited one; keep
-            // such tables eager, so that an own member always stands.
-            if ((symbol.flags & 111551 /* SymbolFlags.Value */) === 0)
-                return undefined;
-            state = keepsSymbolUnderInstantiation(c, symbol, mapper) ? 3 /* MemberState.Kept */ : 1 /* MemberState.Instantiated */;
-            // Instantiated symbols have the flags of their source.
-            hasOwnMembers = true;
-            if ((symbol.flags & 16777216 /* SymbolFlags.Optional */) === 0)
-                hasRequiredOwnMembers = true;
+        if (named[i] !== 0) {
+            const bit = 1 << (i & 31);
+            if ((keptByType[i >> 5] & bit) !== 0)
+                state = 3 /* MemberState.Kept */;
+            else if (mapper.mapsThisOnly() && isThisless(members[i])) {
+                getSymbolId(members[i]);
+                state = 3 /* MemberState.Kept */;
+            }
+            else if (keepsSymbolTypeUnderInstantiation(c, members[i])) {
+                keptByType[i >> 5] = keptByType[i >> 5] | bit;
+                state = 3 /* MemberState.Kept */;
+            }
+            else
+                state = 1 /* MemberState.Instantiated */;
         }
         word |= state << ((i & 15) * 2);
         if ((i & 15) === 15) {
             states.push(word);
             word = 0;
         }
-        i++;
     }
-    if ((i & 15) !== 0)
+    if ((count & 15) !== 0)
         states.push(word);
-    const pending = new PendingInstantiatedMembers(c, table, undefined, mapper, sharedStates(declared, states), declaredMemberPositions(declared, table), hasOwnMembers, hasRequiredOwnMembers);
+    const pending = new PendingInstantiatedMembers(c, table, undefined, members, mapper, sharedStates(declared, states), declaredMemberPositions(declared, table), plan.hasOwnMembers, plan.hasRequiredOwnMembers);
     pending.owner = declared;
     return pending;
 }
+/** What the pending instantiations of `table`, the declared members of `declared`, share. */
+function declaredMemberPlan(c, declared, table) {
+    const known = declared.declaredMemberPlan;
+    if (known !== undefined && known.table === table)
+        return known;
+    const members = [];
+    const named = [];
+    let hasOwnMembers = false;
+    let hasRequiredOwnMembers = false;
+    let eager = false;
+    for (const [id, symbol] of table) {
+        if (id !== symbol.name) {
+            eager = true;
+            break;
+        }
+        members.push(symbol);
+        if (!isNamedMember(c, symbol, id)) {
+            named.push(0);
+            continue;
+        }
+        // A named member without a value flag (an alias) could be replaced by an inherited one; keep
+        // such tables eager, so that an own member always stands.
+        if ((symbol.flags & 111551 /* SymbolFlags.Value */) === 0) {
+            eager = true;
+            break;
+        }
+        named.push(1);
+        // Instantiated symbols have the flags of their source.
+        hasOwnMembers = true;
+        if ((symbol.flags & 16777216 /* SymbolFlags.Optional */) === 0)
+            hasRequiredOwnMembers = true;
+    }
+    const plan = new DeclaredMemberPlan(table, eager, members, named, hasOwnMembers, hasRequiredOwnMembers);
+    declared.declaredMemberPlan = plan;
+    return plan;
+}
 /**
  * `states`, or the equal list the last instantiation of `source` used: most instantiations of a
  * source keep and instantiate the same members, and the lists are never changed.
@@ -525,7 +628,7 @@ function pendingInstantiatedList(c, list, mapper) {
     }
     if ((list.length & 15) !== 0)
         states.push(word);
-    return new PendingInstantiatedMembers(c, undefined, list, mapper, states, listPositions(c, list), true, hasRequiredOwnMembers);
+    return new PendingInstantiatedMembers(c, undefined, list, list, mapper, states, listPositions(c, list), true, hasRequiredOwnMembers);
 }
 /**
  * Positions of the declared members of a class or interface by name, shared by all its
@@ -629,12 +732,13 @@ export function resolvedPropertiesAreOptional(t) {
 }
 /** resolveObjectTypeMembers for an instantiation whose member symbols are instantiated on demand. */
 function resolvePendingObjectTypeMembers(c, t, pending, baseTypes, mapper, thisArgument, callSignatures, constructSignatures, indexInfos) {
-    setPendingStructuredTypeMembers(c, t, pending, callSignatures, constructSignatures, indexInfos);
-    if (baseTypes.length === 0)
+    if (baseTypes.length === 0) {
+        setPendingStructuredTypeMembers(c, t, pending, callSignatures, constructSignatures, indexInfos);
         return;
+    }
+    // The members are set once the bases are added: a recursive request for them resolves them again.
     pending.hasBases = true;
     pending.resolving = true;
-    t.objectFlags |= 536870912 /* ObjectFlags.UnresolvedMembers */;
     for (const baseType of baseTypes) {
         const instantiatedBaseType = thisArgument !== undefined
             ? getTypeWithThisArgument(c, instantiateType(c, baseType, mapper), thisArgument, false)
@@ -654,10 +758,7 @@ function resolvePendingObjectTypeMembers(c, t, pending, baseTypes, mapper, thisA
                 lazyBase = resolved;
         }
         const baseProperties = lazyBase === undefined ? getPropertiesOfType(c, instantiatedBaseType) : undefined;
-        if (t.pendingMembers === pending)
-            pending.addBase(lazyBase, baseProperties);
-        else
-            addInheritedMembers(t.membersValue, baseProperties ?? lazyBase.properties);
+        pending.addBase(lazyBase, baseProperties);
         const baseCallSignatures = getSignaturesOfType(c, instantiatedBaseType, 0 /* SignatureKind.Call */);
         if (baseCallSignatures.length !== 0)
             callSignatures = callSignatures.concat(baseCallSignatures);
@@ -672,12 +773,8 @@ function resolvePendingObjectTypeMembers(c, t, pending, baseTypes, mapper, thisA
         if (added.length !== 0)
             indexInfos = indexInfos.concat(added);
     }
-    t.objectFlags &= ~536870912 /* ObjectFlags.UnresolvedMembers */;
     pending.resolving = false;
-    if (t.pendingMembers === pending)
-        setPendingStructuredTypeMembers(c, t, pending, callSignatures, constructSignatures, indexInfos);
-    else
-        setStructuredTypeMembers(c, t, t.membersValue, callSignatures, constructSignatures, indexInfos);
+    setPendingStructuredTypeMembers(c, t, pending, callSignatures, constructSignatures, indexInfos);
 }
 function setPendingStructuredTypeMembers(c, type, pending, callSignatures, constructSignatures, indexInfos) {
     const t = membersHolder(c, type);
@@ -855,7 +952,7 @@ function isOnlyAmbientModuleDeclarations(declarations) {
     if (declarations.length === 0)
         return false;
     for (const d of declarations)
-        if (d.kind !== 268 /* SyntaxKind.ModuleDeclaration */ || !isAmbientModule(d))
+        if (d.kind !== 269 /* SyntaxKind.ModuleDeclaration */ || !isAmbientModule(d))
             return false;
     return true;
 }
@@ -891,7 +988,7 @@ function getArrayMemberCallSignatures(c, t) {
     }
     const arrayArg = mapType(c, t, (u) => {
         const generic = isReadonlyArraySymbol(c, u.symbol.parent) ? c.globalReadonlyArrayType : c.globalArrayType;
-        return u.mapper.map(generic.typeParameters()[0]);
+        return getMappedType(generic.typeParameters()[0], u.mapper);
     });
     const arrayType = createArrayTypeEx(c, arrayArg, someType(t, (u) => isReadonlyArraySymbol(c, u.symbol.parent)));
     const memberType = getTypeOfPropertyOfType(c, arrayType, memberName);
@@ -1046,7 +1143,7 @@ export function combineUnionOrIntersectionMemberSignatures(c, left, right, isUni
     let flags = (left.flags | right.flags) & (335 /* SignatureFlags.PropagatingFlags */ & ~1 /* SignatureFlags.HasRestParameter */);
     const params = combineUnionOrIntersectionParameters(c, left, right, paramMapper, isUnion);
     const lastParam = params.length !== 0 ? params[params.length - 1] : undefined;
-    if (lastParam !== undefined && (lastParam.checkFlags & 32768 /* CheckFlags.RestParameter */) !== 0)
+    if (lastParam !== undefined && (lastParam.checkFlags & 262144 /* CheckFlags.RestParameter */) !== 0)
         flags |= 1 /* SignatureFlags.HasRestParameter */;
     const thisParam = combineUnionOrIntersectionThisParam(c, left.thisParameter, right.thisParameter, paramMapper, isUnion);
     const minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount);
@@ -1088,12 +1185,12 @@ function combineUnionOrIntersectionParameters(c, left, right, mapper, isUnion) {
         let paramName = leftName === rightName ? leftName : leftName === '' ? rightName : rightName === '' ? leftName : '';
         if (paramName === '')
             paramName = 'arg' + i;
-        const paramSymbol = c.newSymbolWithCheckFlags(1 /* SymbolFlags.FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* SymbolFlags.Optional */ : 0), paramName, isRestParam ? 32768 /* CheckFlags.RestParameter */ : isOptional ? 16384 /* CheckFlags.OptionalParameter */ : 0 /* CheckFlags.None */);
+        const paramSymbol = c.newSymbolWithCheckFlags(1 /* SymbolFlags.FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* SymbolFlags.Optional */ : 0), paramName, isRestParam ? 262144 /* CheckFlags.RestParameter */ : isOptional ? 131072 /* CheckFlags.OptionalParameter */ : 0 /* CheckFlags.None */);
         c.symbolTypes.set(getSymbolId(paramSymbol), isRestParam ? createArrayTypeEx(c, combinedParamType, false) : combinedParamType);
         params.push(paramSymbol);
     }
     if (needsExtraRestElement) {
-        const restParamSymbol = c.newSymbolWithCheckFlags(1 /* SymbolFlags.FunctionScopedVariable */, 'args', 32768 /* CheckFlags.RestParameter */);
+        const restParamSymbol = c.newSymbolWithCheckFlags(1 /* SymbolFlags.FunctionScopedVariable */, 'args', 262144 /* CheckFlags.RestParameter */);
         let restType = createArrayTypeEx(c, getTypeAtPosition(c, shorter, longestCount), false);
         if (shorter === right)
             restType = instantiateType(c, restType, mapper);
@@ -1268,7 +1365,8 @@ export function getPropertyOfTypeEx(c, t, name, skipObjectFunctionPropertyAugmen
     if (!isOwnReducedApparentType(t))
         t = getReducedApparentTypeWorker(c, t);
     if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
-        const resolved = resolveStructuredTypeMembers(c, t);
+        // The first test of resolveStructuredTypeMembers, here where most lookups find the members resolved.
+        const resolved = (t.objectFlags & 2097152 /* ObjectFlags.MembersResolved */) !== 0 ? t : resolveStructuredTypeMembers(c, t);
         const symbol = getResolvedMember(resolved, name);
         if (symbol !== undefined && includeTypeOnlyMembers)
             return symbol;
@@ -1530,12 +1628,24 @@ export function getUnionOrIntersectionProperty(c, t, name, skipObjectFunctionPro
     return prop;
 }
 export function getDeclarationModifierFlagsFromSymbol(c, s, isWrite) {
+    const checkFlags = s.checkFlags;
+    if ((checkFlags & 6 /* CheckFlags.Synthetic */) !== 0) {
+        // The least restricted access of the constituents, for reading or for writing.
+        let access = 0 /* ModifierFlags.None */;
+        if ((checkFlags & (isWrite ? 2048 /* CheckFlags.ContainsWritePublic */ : 256 /* CheckFlags.ContainsPublic */)) !== 0)
+            access = 1 /* ModifierFlags.Public */;
+        else if ((checkFlags & (isWrite ? 4096 /* CheckFlags.ContainsWriteProtected */ : 512 /* CheckFlags.ContainsProtected */)) !== 0)
+            access = 4 /* ModifierFlags.Protected */;
+        else if ((checkFlags & (isWrite ? 8192 /* CheckFlags.ContainsWritePrivate */ : 1024 /* CheckFlags.ContainsPrivate */)) !== 0)
+            access = 2 /* ModifierFlags.Private */;
+        return (checkFlags & 16384 /* CheckFlags.ContainsStatic */) !== 0 ? access | 256 /* ModifierFlags.Static */ : access;
+    }
     if (s.valueDeclaration !== undefined) {
         let declaration;
         if (isWrite)
-            declaration = getDeclarationOfKind(s, 179 /* SyntaxKind.SetAccessor */);
+            declaration = getDeclarationOfKind(s, 180 /* SyntaxKind.SetAccessor */);
         if (declaration === undefined && (s.flags & 32768 /* SymbolFlags.GetAccessor */) !== 0)
-            declaration = getDeclarationOfKind(s, 178 /* SyntaxKind.GetAccessor */);
+            declaration = getDeclarationOfKind(s, 179 /* SyntaxKind.GetAccessor */);
         if (declaration === undefined)
             declaration = s.valueDeclaration;
         const flags = getCombinedModifierFlags(declaration);
@@ -1543,15 +1653,6 @@ export function getDeclarationModifierFlagsFromSymbol(c, s, isWrite) {
             ? flags
             : flags & ~7 /* ModifierFlags.AccessibilityModifier */;
     }
-    if ((s.checkFlags & 6 /* CheckFlags.Synthetic */) !== 0) {
-        const access = (s.checkFlags & 1024 /* CheckFlags.ContainsPrivate */) !== 0
-            ? 2 /* ModifierFlags.Private */
-            : (s.checkFlags & 256 /* CheckFlags.ContainsPublic */) !== 0
-                ? 1 /* ModifierFlags.Public */
-                : 4 /* ModifierFlags.Protected */;
-        const staticModifier = (s.checkFlags & 2048 /* CheckFlags.ContainsStatic */) !== 0 ? 256 /* ModifierFlags.Static */ : 0;
-        return access | staticModifier;
-    }
     if ((s.flags & 4194304 /* SymbolFlags.Prototype */) !== 0)
         return 1 /* ModifierFlags.Public */ | 256 /* ModifierFlags.Static */;
     return 0;
@@ -1574,6 +1675,7 @@ export function createUnionOrIntersectionProperty(c, containingType, name, skipO
         const prop = getPropertyOfTypeEx(c, t, name, skipObjectFunctionPropertyAugment, false);
         if (prop !== undefined) {
             const modifiers = getDeclarationModifierFlagsFromSymbol(c, prop, false);
+            const writeModifiers = getDeclarationModifierFlagsFromSymbol(c, prop, true);
             if ((prop.flags & 106500 /* SymbolFlags.ClassMember */) !== 0) {
                 if (isUnion)
                     optionalFlag |= prop.flags & 16777216 /* SymbolFlags.Optional */;
@@ -1607,14 +1709,20 @@ export function createUnionOrIntersectionProperty(c, containingType, name, skipO
                 checkFlags |= 8 /* CheckFlags.Readonly */;
             else if (!isUnion && !isReadonlySymbol(c, prop))
                 checkFlags &= ~8 /* CheckFlags.Readonly */;
-            if ((modifiers & 6 /* ModifierFlags.NonPublicAccessibilityModifier */) === 0)
-                checkFlags |= 256 /* CheckFlags.ContainsPublic */;
-            if ((modifiers & 4 /* ModifierFlags.Protected */) !== 0)
+            if ((modifiers & (4 /* ModifierFlags.Protected */ | 1 /* ModifierFlags.Public */)) === 4 /* ModifierFlags.Protected */)
                 checkFlags |= 512 /* CheckFlags.ContainsProtected */;
-            if ((modifiers & 2 /* ModifierFlags.Private */) !== 0)
+            else if ((modifiers & (2 /* ModifierFlags.Private */ | 1 /* ModifierFlags.Public */)) === 2 /* ModifierFlags.Private */)
                 checkFlags |= 1024 /* CheckFlags.ContainsPrivate */;
+            else
+                checkFlags |= 256 /* CheckFlags.ContainsPublic */;
+            if ((writeModifiers & (4 /* ModifierFlags.Protected */ | 1 /* ModifierFlags.Public */)) === 4 /* ModifierFlags.Protected */)
+                checkFlags |= 4096 /* CheckFlags.ContainsWriteProtected */;
+            else if ((writeModifiers & (2 /* ModifierFlags.Private */ | 1 /* ModifierFlags.Public */)) === 2 /* ModifierFlags.Private */)
+                checkFlags |= 8192 /* CheckFlags.ContainsWritePrivate */;
+            else
+                checkFlags |= 2048 /* CheckFlags.ContainsWritePublic */;
             if ((modifiers & 256 /* ModifierFlags.Static */) !== 0)
-                checkFlags |= 2048 /* CheckFlags.ContainsStatic */;
+                checkFlags |= 16384 /* CheckFlags.ContainsStatic */;
             if (!isPrototypeProperty(prop))
                 syntheticFlag = 2 /* CheckFlags.SyntheticProperty */;
         }
@@ -1633,13 +1741,27 @@ export function createUnionOrIntersectionProperty(c, containingType, name, skipO
                 checkFlags |= 16 /* CheckFlags.ReadPartial */;
         }
     }
-    if (singleProp === undefined ||
-        (isUnion &&
-            (propSet !== undefined || (checkFlags & 48 /* CheckFlags.Partial */) !== 0) &&
-            (checkFlags & (1024 /* CheckFlags.ContainsPrivate */ | 512 /* CheckFlags.ContainsProtected */)) !== 0 &&
-            !(propSet !== undefined && hasCommonDeclaration(propSet))))
-        // Missing, or private/protected in one constituent but missing or different in another.
+    if (singleProp === undefined)
         return undefined;
+    if (isUnion &&
+        (propSet !== undefined || (checkFlags & 48 /* CheckFlags.Partial */) !== 0) &&
+        (checkFlags &
+            (1024 /* CheckFlags.ContainsPrivate */ |
+                512 /* CheckFlags.ContainsProtected */ |
+                8192 /* CheckFlags.ContainsWritePrivate */ |
+                4096 /* CheckFlags.ContainsWriteProtected */)) !==
+            0 &&
+        !(propSet !== undefined && hasCommonDeclaration(propSet))) {
+        // The property is private or protected in one constituent but missing or different in another.
+        // Private or protected reading leaves no property; private or protected writing restricts write
+        // access to that of the most restricted constituent.
+        if ((checkFlags & (1024 /* CheckFlags.ContainsPrivate */ | 512 /* CheckFlags.ContainsProtected */)) !== 0)
+            return undefined;
+        if ((checkFlags & 8192 /* CheckFlags.ContainsWritePrivate */) !== 0)
+            checkFlags &= ~(2048 /* CheckFlags.ContainsWritePublic */ | 4096 /* CheckFlags.ContainsWriteProtected */);
+        else if ((checkFlags & 4096 /* CheckFlags.ContainsWriteProtected */) !== 0)
+            checkFlags &= ~2048 /* CheckFlags.ContainsWritePublic */;
+    }
     if (propSet === undefined && (checkFlags & 16 /* CheckFlags.ReadPartial */) === 0 && indexTypes.length === 0) {
         if (!mergedInstantiations)
             return singleProp;
@@ -1674,7 +1796,8 @@ export function createUnionOrIntersectionProperty(c, containingType, name, skipO
         else if (prop.valueDeclaration !== undefined && prop.valueDeclaration !== firstValueDeclaration)
             hasNonUniformValueDeclaration = true;
         for (const d of getDeclarations(prop))
-            declarations.push(d);
+            if (!declarations.includes(d))
+                declarations.push(d);
         const t = getTypeOfSymbol(c, prop);
         if (firstType === undefined) {
             firstType = t;
@@ -1691,7 +1814,7 @@ export function createUnionOrIntersectionProperty(c, containingType, name, skipO
         if (isLiteralType(t) || isPatternLiteralType(c, t))
             checkFlags |= 128 /* CheckFlags.HasLiteralType */;
         if ((t.flags & 262144 /* TypeFlags.Never */) !== 0 && t !== c.uniqueLiteralType)
-            checkFlags |= 131072 /* CheckFlags.HasNeverType */;
+            checkFlags |= 1048576 /* CheckFlags.HasNeverType */;
         propTypes.push(t);
     }
     for (const t of indexTypes)
@@ -1707,7 +1830,7 @@ export function createUnionOrIntersectionProperty(c, containingType, name, skipO
     c.symbolNameTypes.set(id, nameType);
     if (propTypes.length > 2) {
         // Defer normalization of possibly large constituent lists.
-        result.checkFlags |= 65536 /* CheckFlags.DeferredType */;
+        result.checkFlags |= 524288 /* CheckFlags.DeferredType */;
         const links = c.symbolLinks(result);
         links.deferralParent = containingType;
         links.deferralConstituents = propTypes;
@@ -1991,7 +2114,7 @@ export function getReducedType(c, t) {
         const side = sideOf(c, t);
         if ((side.objectFlags & 33554432 /* ObjectFlags.IsNeverIntersectionComputed */) === 0) {
             side.objectFlags |= 33554432 /* ObjectFlags.IsNeverIntersectionComputed */;
-            if (hasNeverReducedProperty(c, t))
+            if (!isMappingOfSameObjectType(c, typesOf(t)) && hasNeverReducedProperty(c, t))
                 side.objectFlags |= 67108864 /* ObjectFlags.IsNeverIntersection */;
         }
         if ((side.objectFlags & 67108864 /* ObjectFlags.IsNeverIntersection */) !== 0)
@@ -1999,6 +2122,20 @@ export function getReducedType(c, t) {
     }
     return t;
 }
+/** Whether `types` are mapped types that all map the same object type. */
+function isMappingOfSameObjectType(c, types) {
+    if (types.length === 0 || (types[0].objectFlags & 32 /* ObjectFlags.Mapped */) === 0)
+        return false;
+    const first = getModifiersTypeFromMappedType(c, types[0]);
+    if ((first.flags & 1048576 /* TypeFlags.Object */) === 0)
+        return false;
+    for (let i = 1; i < types.length; i++) {
+        const t = types[i];
+        if ((t.objectFlags & 32 /* ObjectFlags.Mapped */) === 0 || getModifiersTypeFromMappedType(c, t) !== first)
+            return false;
+    }
+    return true;
+}
 /**
  * Whether a property of the intersection `t` reduces it to never, without resolving all of its
  * properties. Such a property is one that createUnionOrIntersectionProperty combines from different
@@ -2112,7 +2249,7 @@ function isNeverReducedProperty(c, prop) {
 export function isDiscriminantWithNeverType(c, prop) {
     // A synthetic required property with non-uniform literal types, none never, reducing to never.
     return ((prop.flags & 16777216 /* SymbolFlags.Optional */) === 0 &&
-        (prop.checkFlags & (192 /* CheckFlags.NonUniformAndLiteral */ | 131072 /* CheckFlags.HasNeverType */)) ===
+        (prop.checkFlags & (192 /* CheckFlags.NonUniformAndLiteral */ | 1048576 /* CheckFlags.HasNeverType */)) ===
             192 /* CheckFlags.NonUniformAndLiteral */ &&
         (getTypeOfSymbol(c, prop).flags & 262144 /* TypeFlags.Never */) !== 0);
 }
@@ -2176,7 +2313,7 @@ export function getResolvedBaseConstraint(c, t, stack) {
         return c.circularConstraintType;
     let constraint;
     // At least 10 levels; up to 50 without deeply nested types on the stack.
-    const identity = getRecursionIdentity(t);
+    const identity = getRecursionIdentity(c, t);
     const current = stack ?? [];
     if (current.length < 10 || (current.length < 50 && !current.includes(identity)))
         constraint = computeBaseConstraint(c, getSimplifiedType(c, t, false), current.concat([identity]));
@@ -2184,7 +2321,7 @@ export function getResolvedBaseConstraint(c, t, stack) {
         if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
             const errorNode = getConstraintDeclaration(t);
             if (errorNode !== undefined)
-                c.error(errorNode, 491 /* Diagnostics.Type_parameter_0_has_a_circular_constraint */, typeToString(c, t));
+                c.error(errorNode, 498 /* Diagnostics.Type_parameter_0_has_a_circular_constraint */, typeToString(c, t));
         }
         constraint = c.circularConstraintType;
     }

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

@@ -1,19 +1,20 @@
-import { type Node, type SourceFile } from './ast.js';
+import { type ImportAttributes, type Node, type SourceFile } from './ast.js';
 import { type DiagnosticMessage } from './diagnostics.js';
 import { ModuleKind } from './options.js';
 import { type Checker, type CheckerHost } from './checker.js';
 import { type Type } from './checker-types.js';
 import { type Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 /** The module symbol `moduleReference` names, reporting it when it isn't found unless `ignoreErrors`. */
-export declare function resolveExternalModuleName(c: Checker, location: Node, moduleReference: Node | undefined, ignoreErrors: boolean): Symbol | undefined;
-export declare function resolveExternalModuleNameWorker(c: Checker, location: Node, moduleReference: Node | undefined, moduleNotFoundError: DiagnosticMessage | undefined, ignoreErrors: boolean, isForAugmentation: boolean): Symbol | undefined;
+export declare function resolveExternalModuleName(c: Checker, location: Node, moduleReference: Node | undefined, ignoreErrors: boolean, importAttributesType: Type | undefined): Symbol | undefined;
+export declare function resolveExternalModuleNameWorker(c: Checker, location: Node, moduleReference: Node | undefined, moduleNotFoundError: DiagnosticMessage | undefined, ignoreErrors: boolean, isForAugmentation: boolean, importAttributesType: Type | undefined): Symbol | undefined;
 /** A `resolveExternalModule` result that reported nothing, and the arguments it was computed for. */
 export declare class ModuleResolution {
     readonly moduleReference: string;
     readonly moduleNotFoundError: DiagnosticMessage | undefined;
     readonly isForAugmentation: boolean;
+    readonly importAttributesType: Type | undefined;
     readonly symbol: Symbol | undefined;
-    constructor(moduleReference: string, moduleNotFoundError: DiagnosticMessage | undefined, isForAugmentation: boolean, symbol: Symbol | undefined);
+    constructor(moduleReference: string, moduleNotFoundError: DiagnosticMessage | undefined, isForAugmentation: boolean, importAttributesType: Type | undefined, symbol: Symbol | undefined);
 }
 /**
  * The module symbol `moduleReference` resolves to from `location`, reporting resolution errors at
@@ -21,7 +22,9 @@ export declare class ModuleResolution {
  * with the same result and the same diagnostics: a result that reported nothing is kept for the
  * specifier and returned to later calls from the same declaration (`sharesSpecifierContext`).
  */
-export declare function resolveExternalModule(c: Checker, location: Node, moduleReference: string, moduleNotFoundError: DiagnosticMessage | undefined, errorNode: Node | undefined, isForAugmentation: boolean): Symbol | undefined;
+export declare function resolveExternalModule(c: Checker, location: Node, moduleReference: string, moduleNotFoundError: DiagnosticMessage | undefined, errorNode: Node | undefined, isForAugmentation: boolean, importAttributesType: Type | undefined): Symbol | undefined;
+/** The import attributes type an ambient module declares, or the empty object type. */
+export declare function getTypeOfModuleImportAttributes(c: Checker, symbol: Symbol): Type;
 /** A message with its arguments, the elaboration of a diagnostic before it has a location. */
 export declare class DiagnosticDetails {
     readonly message: DiagnosticMessage;
@@ -43,6 +46,8 @@ export declare function tryFindAmbientModule(c: Checker, moduleName: string, wit
 export declare function resolveExternalModuleSymbol(c: Checker, moduleSymbol: Symbol | undefined, dontResolveAlias: boolean): Symbol | undefined;
 /** The module as a namespace: removes call and construct signatures, or wraps it with a synthetic default. */
 export declare function resolveESModuleSymbol(c: Checker, moduleSymbol: Symbol | undefined, node: Node, moduleSpecifier: Node): Symbol | undefined;
+/** The module syntax of the import or export containing `usage`, or `None` for non-literals. */
+export declare function getEmitSyntaxForModuleSpecifierExpression(c: Checker, usage: Node): ModuleKind;
 /** The symbol an alias declaration refers to, without resolving further aliases. */
 export declare function getTargetOfAliasDeclaration(c: Checker, node: Node | undefined): Symbol | undefined;
 /**
@@ -87,10 +92,14 @@ export declare function getHostSignatureFromJSDoc(node: Node): Node | undefined;
 export declare function checkMetaProperty(c: Checker, node: Node): Type;
 export declare function checkNewTargetMetaProperty(c: Checker, node: Node): Type;
 export declare function checkImportDeclaration(c: Checker, node: Node): void;
+/** Import attributes must be assignable to the global `ImportAttributes`. */
+export declare function checkImportAttributes(c: Checker, declaration: Node): void;
+/** The import attributes type of the declaration `node` is the module specifier of. */
+export declare function getImportAttributesTypeForModuleSpecifier(c: Checker, moduleSpecifier: Node): Type | undefined;
+export declare function checkImportAttributesExpression(c: Checker, node: ImportAttributes): Type;
 export declare function checkImportEqualsDeclaration(c: Checker, node: Node): void;
 export declare function checkExportDeclaration(c: Checker, node: Node): void;
 export declare function getDeclarationContainer(node: Node): Node;
-/** `export = e` and `export default e`; the grammar checker reports misplaced ones. */
 export declare function checkExportAssignment(c: Checker, node: Node): void;
 /** Reports aliases that conflict with local declarations, and type-only rules of isolated modules. */
 export declare function checkAliasSymbol(c: Checker, node: Node): void;