typescript 5.6.0-dev.20240818 → 5.7.0-dev.20240820

package/lib/tsc.js

@@ -17,8 +17,8 @@ and limitations under the License.
 "use strict";
 
 // src/compiler/corePublic.ts
-var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240818`;
+var versionMajorMinor = "5.7";
+var version = `${versionMajorMinor}.0-dev.20240820`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -71370,46 +71370,108 @@ function createTypeChecker(host) {
   function isCircularMappedProperty(symbol) {
     return !!(getCheckFlags(symbol) & 262144 /* Mapped */ && !symbol.links.type && findResolutionCycleStartIndex(symbol, 0 /* Type */) >= 0);
   }
+  function isExcludedMappedPropertyName(constraint, propertyNameType) {
+    if (constraint.flags & 16777216 /* Conditional */) {
+      const type = constraint;
+      return !!(getReducedType(getTrueTypeFromConditionalType(type)).flags & 131072 /* Never */) && getActualTypeVariable(getFalseTypeFromConditionalType(type)) === getActualTypeVariable(type.checkType) && isTypeAssignableTo(propertyNameType, type.extendsType);
+    }
+    if (constraint.flags & 2097152 /* Intersection */) {
+      return some(constraint.types, (t) => isExcludedMappedPropertyName(t, propertyNameType));
+    }
+    return false;
+  }
   function getTypeOfPropertyOfContextualType(type, name, nameType) {
     return mapType(
       type,
       (t) => {
-        var _a;
-        if (isGenericMappedType(t) && getMappedTypeNameTypeKind(t) !== 2 /* Remapping */) {
-          const constraint = getConstraintTypeFromMappedType(t);
-          const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-          const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
-          if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
-            return substituteIndexedMappedType(t, propertyNameType);
-          }
-        } else if (t.flags & 3670016 /* StructuredType */) {
-          const prop = getPropertyOfType(t, name);
-          if (prop) {
-            return isCircularMappedProperty(prop) ? void 0 : removeMissingType(getTypeOfSymbol(prop), !!(prop.flags & 16777216 /* Optional */));
-          }
-          if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
-            const restType = getElementTypeOfSliceOfTupleType(
-              t,
-              t.target.fixedLength,
-              /*endSkipCount*/
-              0,
-              /*writing*/
-              false,
-              /*noReductions*/
-              true
-            );
-            if (restType) {
-              return restType;
+        if (t.flags & 2097152 /* Intersection */) {
+          let types;
+          let indexInfoCandidates;
+          let ignoreIndexInfos = false;
+          for (const constituentType of t.types) {
+            if (!(constituentType.flags & 524288 /* Object */)) {
+              continue;
+            }
+            if (isGenericMappedType(constituentType) && getMappedTypeNameTypeKind(constituentType) !== 2 /* Remapping */) {
+              const substitutedType = getIndexedMappedTypeSubstitutedTypeOfContextualType(constituentType, name, nameType);
+              types = appendContextualPropertyTypeConstituent(types, substitutedType);
+              continue;
+            }
+            const propertyType = getTypeOfConcretePropertyOfContextualType(constituentType, name);
+            if (!propertyType) {
+              if (!ignoreIndexInfos) {
+                indexInfoCandidates = append(indexInfoCandidates, constituentType);
+              }
+              continue;
             }
+            ignoreIndexInfos = true;
+            indexInfoCandidates = void 0;
+            types = appendContextualPropertyTypeConstituent(types, propertyType);
+          }
+          if (indexInfoCandidates) {
+            for (const candidate of indexInfoCandidates) {
+              const indexInfoType = getTypeFromIndexInfosOfContextualType(candidate, name, nameType);
+              types = appendContextualPropertyTypeConstituent(types, indexInfoType);
+            }
+          }
+          if (!types) {
+            return;
           }
-          return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
+          if (types.length === 1) {
+            return types[0];
+          }
+          return getIntersectionType(types);
         }
-        return void 0;
+        if (!(t.flags & 524288 /* Object */)) {
+          return;
+        }
+        return isGenericMappedType(t) && getMappedTypeNameTypeKind(t) !== 2 /* Remapping */ ? getIndexedMappedTypeSubstitutedTypeOfContextualType(t, name, nameType) : getTypeOfConcretePropertyOfContextualType(t, name) ?? getTypeFromIndexInfosOfContextualType(t, name, nameType);
       },
       /*noReductions*/
       true
     );
   }
+  function appendContextualPropertyTypeConstituent(types, type) {
+    return type ? append(types, type.flags & 1 /* Any */ ? unknownType : type) : types;
+  }
+  function getIndexedMappedTypeSubstitutedTypeOfContextualType(type, name, nameType) {
+    const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
+    const constraint = getConstraintTypeFromMappedType(type);
+    if (type.nameType && isExcludedMappedPropertyName(type.nameType, propertyNameType) || isExcludedMappedPropertyName(constraint, propertyNameType)) {
+      return;
+    }
+    const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
+    if (!isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
+      return;
+    }
+    return substituteIndexedMappedType(type, propertyNameType);
+  }
+  function getTypeOfConcretePropertyOfContextualType(type, name) {
+    const prop = getPropertyOfType(type, name);
+    if (!prop || isCircularMappedProperty(prop)) {
+      return;
+    }
+    return removeMissingType(getTypeOfSymbol(prop), !!(prop.flags & 16777216 /* Optional */));
+  }
+  function getTypeFromIndexInfosOfContextualType(type, name, nameType) {
+    var _a;
+    if (isTupleType(type) && isNumericLiteralName(name) && +name >= 0) {
+      const restType = getElementTypeOfSliceOfTupleType(
+        type,
+        type.target.fixedLength,
+        /*endSkipCount*/
+        0,
+        /*writing*/
+        false,
+        /*noReductions*/
+        true
+      );
+      if (restType) {
+        return restType;
+      }
+    }
+    return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(type), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
+  }
   function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
     Debug.assert(isObjectLiteralMethod(node));
     if (node.flags & 67108864 /* InWithStatement */) {