@typescript-deploys/pr-build 5.1.0-pr-53406-15 → 5.1.0-pr-49863-41

package/lib/tsc.js

@@ -7313,6 +7313,7 @@ var Diagnostics = {
   Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(6718, 3 /* Message */, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."),
   Default_catch_clause_variables_as_unknown_instead_of_any: diag(6803, 3 /* Message */, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."),
   Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting: diag(6804, 3 /* Message */, "Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_i_6804", "Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting."),
+  Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks: diag(6805, 3 /* Message */, "Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks_6805", "Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks."),
   one_of_Colon: diag(6900, 3 /* Message */, "one_of_Colon_6900", "one of:"),
   one_or_more_Colon: diag(6901, 3 /* Message */, "one_or_more_Colon_6901", "one or more:"),
   type_Colon: diag(6902, 3 /* Message */, "type_Colon_6902", "type:"),
@@ -33850,6 +33851,16 @@ var commandOptionsWithoutBuild = [
     description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
     defaultValueDescription: false
   },
+  {
+    name: "strictInstanceOfTypeParameters",
+    type: "boolean",
+    affectsSemanticDiagnostics: true,
+    affectsBuildInfo: true,
+    strictFlag: true,
+    category: Diagnostics.Type_Checking,
+    description: Diagnostics.Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks,
+    defaultValueDescription: false
+  },
   {
     name: "alwaysStrict",
     type: "boolean",
@@ -42538,6 +42549,7 @@ function createTypeChecker(host) {
   var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
   var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
   var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
+  var strictInstanceOfTypeParameters = true;
   var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
   var defaultIndexFlags = keyofStringsOnly ? 1 /* StringsOnly */ : 0 /* None */;
   var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
@@ -50511,9 +50523,30 @@ function createTypeChecker(host) {
       }
     }).parent;
   }
+  function getInstanceTypeOfClassSymbol(classSymbol) {
+    const classType = getDeclaredTypeOfSymbol(classSymbol);
+    const objectFlags = getObjectFlags(classType);
+    if (!(objectFlags & 3 /* ClassOrInterface */) || !classType.typeParameters) {
+      return classType;
+    }
+    const variances = getVariances(classType);
+    const typeArguments = map(classType.typeParameters, (typeParameter, i) => {
+      if (!strictInstanceOfTypeParameters) {
+        return anyType;
+      }
+      const variance = variances[i];
+      switch (variance & 7 /* VarianceMask */) {
+        case 2 /* Contravariant */:
+        case 3 /* Bivariant */:
+          return neverType;
+      }
+      return getBaseConstraintOfType(typeParameter) || unknownType;
+    });
+    return createTypeReference(classType, typeArguments);
+  }
   function getTypeOfPrototypeProperty(prototype) {
-    const classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype));
-    return classType.typeParameters ? createTypeReference(classType, map(classType.typeParameters, (_) => anyType)) : classType;
+    const classSymbol = getParentOfSymbol(prototype);
+    return getInstanceTypeOfClassSymbol(classSymbol);
   }
   function getTypeOfPropertyOfType(type, name) {
     const prop = getPropertyOfType(type, name);
@@ -55804,7 +55837,7 @@ function createTypeChecker(host) {
     }
   }
   function removeStringLiteralsMatchedByTemplateLiterals(types) {
-    const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t) && !some(t.types, (t2) => !!(t2.flags & 2097152 /* Intersection */)));
+    const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t));
     if (templates.length) {
       let i = types.length;
       while (i > 0) {
@@ -64993,8 +65026,8 @@ function createTypeChecker(host) {
       if (symbol === void 0) {
         return type;
       }
-      const classSymbol = symbol.parent;
-      const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) : getDeclaredTypeOfSymbol(classSymbol);
+      const classSymbol = getParentOfSymbol(symbol);
+      const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) : getInstanceTypeOfClassSymbol(classSymbol);
       return getNarrowedType(
         type,
         targetType,
@@ -94612,10 +94645,13 @@ function transformJsx(context) {
         return Debug.failBadSyntaxKind(node);
     }
   }
+  function hasProto(obj) {
+    return obj.properties.some((p) => isPropertyAssignment(p) && (isIdentifier(p.name) && idText(p.name) === "__proto__" || isStringLiteral(p.name) && p.name.text === "__proto__"));
+  }
   function hasKeyAfterPropsSpread(node) {
     let spread = false;
     for (const elem of node.attributes.properties) {
-      if (isJsxSpreadAttribute(elem)) {
+      if (isJsxSpreadAttribute(elem) && (!isObjectLiteralExpression(elem.expression) || elem.expression.properties.some(isSpreadAssignment))) {
         spread = true;
       } else if (spread && isJsxAttribute(elem) && elem.name.escapedText === "key") {
         return true;
@@ -94781,7 +94817,10 @@ function transformJsx(context) {
     }
     return element;
   }
-  function transformJsxSpreadAttributeToSpreadAssignment(node) {
+  function transformJsxSpreadAttributeToProps(node) {
+    if (isObjectLiteralExpression(node.expression) && !hasProto(node.expression)) {
+      return node.expression.properties;
+    }
     return factory2.createSpreadAssignment(Debug.checkDefined(visitNode(node.expression, visitor, isExpression)));
   }
   function transformJsxAttributesToObjectProps(attrs, children) {
@@ -94789,30 +94828,48 @@ function transformJsx(context) {
     return target && target >= 5 /* ES2018 */ ? factory2.createObjectLiteralExpression(transformJsxAttributesToProps(attrs, children)) : transformJsxAttributesToExpression(attrs, children);
   }
   function transformJsxAttributesToProps(attrs, children) {
-    const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToSpreadAssignment(attr) : transformJsxAttributeToObjectLiteralElement(attr))));
+    const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => flatten(map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToProps(attr) : transformJsxAttributeToObjectLiteralElement(attr)))));
     if (children) {
       props.push(children);
     }
     return props;
   }
   function transformJsxAttributesToExpression(attrs, children) {
-    const expressions = flatten(
-      spanMap(
-        attrs,
-        isJsxSpreadAttribute,
-        (attrs2, isSpread) => isSpread ? map(attrs2, transformJsxSpreadAttributeToExpression) : factory2.createObjectLiteralExpression(map(attrs2, transformJsxAttributeToObjectLiteralElement))
-      )
-    );
-    if (isJsxSpreadAttribute(attrs[0])) {
-      expressions.unshift(factory2.createObjectLiteralExpression());
+    const expressions = [];
+    let properties = [];
+    for (const attr of attrs) {
+      if (isJsxSpreadAttribute(attr)) {
+        if (isObjectLiteralExpression(attr.expression) && !hasProto(attr.expression)) {
+          for (const prop of attr.expression.properties) {
+            if (isSpreadAssignment(prop)) {
+              finishObjectLiteralIfNeeded();
+              expressions.push(prop.expression);
+              continue;
+            }
+            properties.push(prop);
+          }
+          continue;
+        }
+        finishObjectLiteralIfNeeded();
+        expressions.push(attr.expression);
+        continue;
+      }
+      properties.push(transformJsxAttributeToObjectLiteralElement(attr));
     }
     if (children) {
-      expressions.push(factory2.createObjectLiteralExpression([children]));
+      properties.push(children);
+    }
+    finishObjectLiteralIfNeeded();
+    if (expressions.length && !isObjectLiteralExpression(expressions[0])) {
+      expressions.unshift(factory2.createObjectLiteralExpression());
     }
     return singleOrUndefined(expressions) || emitHelpers().createAssignHelper(expressions);
-  }
-  function transformJsxSpreadAttributeToExpression(node) {
-    return Debug.checkDefined(visitNode(node.expression, visitor, isExpression));
+    function finishObjectLiteralIfNeeded() {
+      if (properties.length) {
+        expressions.push(factory2.createObjectLiteralExpression(properties));
+        properties = [];
+      }
+    }
   }
   function transformJsxAttributeToObjectLiteralElement(node) {
     const name = getAttributeName(node);

package/lib/tsserver.js

@@ -10800,6 +10800,7 @@ var Diagnostics = {
   Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(6718, 3 /* Message */, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."),
   Default_catch_clause_variables_as_unknown_instead_of_any: diag(6803, 3 /* Message */, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."),
   Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting: diag(6804, 3 /* Message */, "Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_i_6804", "Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting."),
+  Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks: diag(6805, 3 /* Message */, "Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks_6805", "Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks."),
   one_of_Colon: diag(6900, 3 /* Message */, "one_of_Colon_6900", "one of:"),
   one_or_more_Colon: diag(6901, 3 /* Message */, "one_or_more_Colon_6901", "one or more:"),
   type_Colon: diag(6902, 3 /* Message */, "type_Colon_6902", "type:"),
@@ -38211,6 +38212,16 @@ var commandOptionsWithoutBuild = [
     description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
     defaultValueDescription: false
   },
+  {
+    name: "strictInstanceOfTypeParameters",
+    type: "boolean",
+    affectsSemanticDiagnostics: true,
+    affectsBuildInfo: true,
+    strictFlag: true,
+    category: Diagnostics.Type_Checking,
+    description: Diagnostics.Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks,
+    defaultValueDescription: false
+  },
   {
     name: "alwaysStrict",
     type: "boolean",
@@ -47165,6 +47176,7 @@ function createTypeChecker(host) {
   var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
   var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
   var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
+  var strictInstanceOfTypeParameters = true;
   var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
   var defaultIndexFlags = keyofStringsOnly ? 1 /* StringsOnly */ : 0 /* None */;
   var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
@@ -55138,9 +55150,30 @@ function createTypeChecker(host) {
       }
     }).parent;
   }
+  function getInstanceTypeOfClassSymbol(classSymbol) {
+    const classType = getDeclaredTypeOfSymbol(classSymbol);
+    const objectFlags = getObjectFlags(classType);
+    if (!(objectFlags & 3 /* ClassOrInterface */) || !classType.typeParameters) {
+      return classType;
+    }
+    const variances = getVariances(classType);
+    const typeArguments = map(classType.typeParameters, (typeParameter, i) => {
+      if (!strictInstanceOfTypeParameters) {
+        return anyType;
+      }
+      const variance = variances[i];
+      switch (variance & 7 /* VarianceMask */) {
+        case 2 /* Contravariant */:
+        case 3 /* Bivariant */:
+          return neverType;
+      }
+      return getBaseConstraintOfType(typeParameter) || unknownType;
+    });
+    return createTypeReference(classType, typeArguments);
+  }
   function getTypeOfPrototypeProperty(prototype) {
-    const classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype));
-    return classType.typeParameters ? createTypeReference(classType, map(classType.typeParameters, (_) => anyType)) : classType;
+    const classSymbol = getParentOfSymbol(prototype);
+    return getInstanceTypeOfClassSymbol(classSymbol);
   }
   function getTypeOfPropertyOfType(type, name) {
     const prop = getPropertyOfType(type, name);
@@ -60431,7 +60464,7 @@ function createTypeChecker(host) {
     }
   }
   function removeStringLiteralsMatchedByTemplateLiterals(types) {
-    const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t) && !some(t.types, (t2) => !!(t2.flags & 2097152 /* Intersection */)));
+    const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t));
     if (templates.length) {
       let i = types.length;
       while (i > 0) {
@@ -69620,8 +69653,8 @@ function createTypeChecker(host) {
       if (symbol === void 0) {
         return type;
       }
-      const classSymbol = symbol.parent;
-      const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) : getDeclaredTypeOfSymbol(classSymbol);
+      const classSymbol = getParentOfSymbol(symbol);
+      const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) : getInstanceTypeOfClassSymbol(classSymbol);
       return getNarrowedType(
         type,
         targetType,
@@ -99410,10 +99443,13 @@ function transformJsx(context) {
         return Debug.failBadSyntaxKind(node);
     }
   }
+  function hasProto(obj) {
+    return obj.properties.some((p) => isPropertyAssignment(p) && (isIdentifier(p.name) && idText(p.name) === "__proto__" || isStringLiteral(p.name) && p.name.text === "__proto__"));
+  }
   function hasKeyAfterPropsSpread(node) {
     let spread = false;
     for (const elem of node.attributes.properties) {
-      if (isJsxSpreadAttribute(elem)) {
+      if (isJsxSpreadAttribute(elem) && (!isObjectLiteralExpression(elem.expression) || elem.expression.properties.some(isSpreadAssignment))) {
         spread = true;
       } else if (spread && isJsxAttribute(elem) && elem.name.escapedText === "key") {
         return true;
@@ -99579,7 +99615,10 @@ function transformJsx(context) {
     }
     return element;
   }
-  function transformJsxSpreadAttributeToSpreadAssignment(node) {
+  function transformJsxSpreadAttributeToProps(node) {
+    if (isObjectLiteralExpression(node.expression) && !hasProto(node.expression)) {
+      return node.expression.properties;
+    }
     return factory2.createSpreadAssignment(Debug.checkDefined(visitNode(node.expression, visitor, isExpression)));
   }
   function transformJsxAttributesToObjectProps(attrs, children) {
@@ -99587,30 +99626,48 @@ function transformJsx(context) {
     return target && target >= 5 /* ES2018 */ ? factory2.createObjectLiteralExpression(transformJsxAttributesToProps(attrs, children)) : transformJsxAttributesToExpression(attrs, children);
   }
   function transformJsxAttributesToProps(attrs, children) {
-    const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToSpreadAssignment(attr) : transformJsxAttributeToObjectLiteralElement(attr))));
+    const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => flatten(map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToProps(attr) : transformJsxAttributeToObjectLiteralElement(attr)))));
     if (children) {
       props.push(children);
     }
     return props;
   }
   function transformJsxAttributesToExpression(attrs, children) {
-    const expressions = flatten(
-      spanMap(
-        attrs,
-        isJsxSpreadAttribute,
-        (attrs2, isSpread) => isSpread ? map(attrs2, transformJsxSpreadAttributeToExpression) : factory2.createObjectLiteralExpression(map(attrs2, transformJsxAttributeToObjectLiteralElement))
-      )
-    );
-    if (isJsxSpreadAttribute(attrs[0])) {
-      expressions.unshift(factory2.createObjectLiteralExpression());
+    const expressions = [];
+    let properties = [];
+    for (const attr of attrs) {
+      if (isJsxSpreadAttribute(attr)) {
+        if (isObjectLiteralExpression(attr.expression) && !hasProto(attr.expression)) {
+          for (const prop of attr.expression.properties) {
+            if (isSpreadAssignment(prop)) {
+              finishObjectLiteralIfNeeded();
+              expressions.push(prop.expression);
+              continue;
+            }
+            properties.push(prop);
+          }
+          continue;
+        }
+        finishObjectLiteralIfNeeded();
+        expressions.push(attr.expression);
+        continue;
+      }
+      properties.push(transformJsxAttributeToObjectLiteralElement(attr));
     }
     if (children) {
-      expressions.push(factory2.createObjectLiteralExpression([children]));
+      properties.push(children);
+    }
+    finishObjectLiteralIfNeeded();
+    if (expressions.length && !isObjectLiteralExpression(expressions[0])) {
+      expressions.unshift(factory2.createObjectLiteralExpression());
     }
     return singleOrUndefined(expressions) || emitHelpers().createAssignHelper(expressions);
-  }
-  function transformJsxSpreadAttributeToExpression(node) {
-    return Debug.checkDefined(visitNode(node.expression, visitor, isExpression));
+    function finishObjectLiteralIfNeeded() {
+      if (properties.length) {
+        expressions.push(factory2.createObjectLiteralExpression(properties));
+        properties = [];
+      }
+    }
   }
   function transformJsxAttributeToObjectLiteralElement(node) {
     const name = getAttributeName(node);

package/lib/tsserverlibrary.d.ts

@@ -7141,6 +7141,7 @@ declare namespace ts {
         strictBindCallApply?: boolean;
         strictNullChecks?: boolean;
         strictPropertyInitialization?: boolean;
+        strictInstanceOfTypeParameters?: boolean;
         stripInternal?: boolean;
         suppressExcessPropertyErrors?: boolean;
         suppressImplicitAnyIndexErrors?: boolean;

package/lib/tsserverlibrary.js

@@ -8623,6 +8623,7 @@ ${lanes.join("\n")}
         Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(6718, 3 /* Message */, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."),
         Default_catch_clause_variables_as_unknown_instead_of_any: diag(6803, 3 /* Message */, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."),
         Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting: diag(6804, 3 /* Message */, "Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_i_6804", "Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting."),
+        Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks: diag(6805, 3 /* Message */, "Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks_6805", "Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks."),
         one_of_Colon: diag(6900, 3 /* Message */, "one_of_Colon_6900", "one of:"),
         one_or_more_Colon: diag(6901, 3 /* Message */, "one_or_more_Colon_6901", "one or more:"),
         type_Colon: diag(6902, 3 /* Message */, "type_Colon_6902", "type:"),
@@ -37734,6 +37735,16 @@ ${lanes.join("\n")}
           description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
           defaultValueDescription: false
         },
+        {
+          name: "strictInstanceOfTypeParameters",
+          type: "boolean",
+          affectsSemanticDiagnostics: true,
+          affectsBuildInfo: true,
+          strictFlag: true,
+          category: Diagnostics.Type_Checking,
+          description: Diagnostics.Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks,
+          defaultValueDescription: false
+        },
         {
           name: "alwaysStrict",
           type: "boolean",
@@ -44973,6 +44984,7 @@ ${lanes.join("\n")}
     var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
     var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
     var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
+    var strictInstanceOfTypeParameters = true;
     var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
     var defaultIndexFlags = keyofStringsOnly ? 1 /* StringsOnly */ : 0 /* None */;
     var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
@@ -52946,9 +52958,30 @@ ${lanes.join("\n")}
         }
       }).parent;
     }
+    function getInstanceTypeOfClassSymbol(classSymbol) {
+      const classType = getDeclaredTypeOfSymbol(classSymbol);
+      const objectFlags = getObjectFlags(classType);
+      if (!(objectFlags & 3 /* ClassOrInterface */) || !classType.typeParameters) {
+        return classType;
+      }
+      const variances = getVariances(classType);
+      const typeArguments = map(classType.typeParameters, (typeParameter, i) => {
+        if (!strictInstanceOfTypeParameters) {
+          return anyType;
+        }
+        const variance = variances[i];
+        switch (variance & 7 /* VarianceMask */) {
+          case 2 /* Contravariant */:
+          case 3 /* Bivariant */:
+            return neverType;
+        }
+        return getBaseConstraintOfType(typeParameter) || unknownType;
+      });
+      return createTypeReference(classType, typeArguments);
+    }
     function getTypeOfPrototypeProperty(prototype) {
-      const classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype));
-      return classType.typeParameters ? createTypeReference(classType, map(classType.typeParameters, (_) => anyType)) : classType;
+      const classSymbol = getParentOfSymbol(prototype);
+      return getInstanceTypeOfClassSymbol(classSymbol);
     }
     function getTypeOfPropertyOfType(type, name) {
       const prop = getPropertyOfType(type, name);
@@ -58239,7 +58272,7 @@ ${lanes.join("\n")}
       }
     }
     function removeStringLiteralsMatchedByTemplateLiterals(types) {
-      const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t) && !some(t.types, (t2) => !!(t2.flags & 2097152 /* Intersection */)));
+      const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t));
       if (templates.length) {
         let i = types.length;
         while (i > 0) {
@@ -67428,8 +67461,8 @@ ${lanes.join("\n")}
         if (symbol === void 0) {
           return type;
         }
-        const classSymbol = symbol.parent;
-        const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) : getDeclaredTypeOfSymbol(classSymbol);
+        const classSymbol = getParentOfSymbol(symbol);
+        const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) : getInstanceTypeOfClassSymbol(classSymbol);
         return getNarrowedType(
           type,
           targetType,
@@ -97453,10 +97486,13 @@ ${lanes.join("\n")}
           return Debug.failBadSyntaxKind(node);
       }
     }
+    function hasProto(obj) {
+      return obj.properties.some((p) => isPropertyAssignment(p) && (isIdentifier(p.name) && idText(p.name) === "__proto__" || isStringLiteral(p.name) && p.name.text === "__proto__"));
+    }
     function hasKeyAfterPropsSpread(node) {
       let spread = false;
       for (const elem of node.attributes.properties) {
-        if (isJsxSpreadAttribute(elem)) {
+        if (isJsxSpreadAttribute(elem) && (!isObjectLiteralExpression(elem.expression) || elem.expression.properties.some(isSpreadAssignment))) {
           spread = true;
         } else if (spread && isJsxAttribute(elem) && elem.name.escapedText === "key") {
           return true;
@@ -97622,7 +97658,10 @@ ${lanes.join("\n")}
       }
       return element;
     }
-    function transformJsxSpreadAttributeToSpreadAssignment(node) {
+    function transformJsxSpreadAttributeToProps(node) {
+      if (isObjectLiteralExpression(node.expression) && !hasProto(node.expression)) {
+        return node.expression.properties;
+      }
       return factory2.createSpreadAssignment(Debug.checkDefined(visitNode(node.expression, visitor, isExpression)));
     }
     function transformJsxAttributesToObjectProps(attrs, children) {
@@ -97630,30 +97669,48 @@ ${lanes.join("\n")}
       return target && target >= 5 /* ES2018 */ ? factory2.createObjectLiteralExpression(transformJsxAttributesToProps(attrs, children)) : transformJsxAttributesToExpression(attrs, children);
     }
     function transformJsxAttributesToProps(attrs, children) {
-      const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToSpreadAssignment(attr) : transformJsxAttributeToObjectLiteralElement(attr))));
+      const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => flatten(map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToProps(attr) : transformJsxAttributeToObjectLiteralElement(attr)))));
       if (children) {
         props.push(children);
       }
       return props;
     }
     function transformJsxAttributesToExpression(attrs, children) {
-      const expressions = flatten(
-        spanMap(
-          attrs,
-          isJsxSpreadAttribute,
-          (attrs2, isSpread) => isSpread ? map(attrs2, transformJsxSpreadAttributeToExpression) : factory2.createObjectLiteralExpression(map(attrs2, transformJsxAttributeToObjectLiteralElement))
-        )
-      );
-      if (isJsxSpreadAttribute(attrs[0])) {
-        expressions.unshift(factory2.createObjectLiteralExpression());
+      const expressions = [];
+      let properties = [];
+      for (const attr of attrs) {
+        if (isJsxSpreadAttribute(attr)) {
+          if (isObjectLiteralExpression(attr.expression) && !hasProto(attr.expression)) {
+            for (const prop of attr.expression.properties) {
+              if (isSpreadAssignment(prop)) {
+                finishObjectLiteralIfNeeded();
+                expressions.push(prop.expression);
+                continue;
+              }
+              properties.push(prop);
+            }
+            continue;
+          }
+          finishObjectLiteralIfNeeded();
+          expressions.push(attr.expression);
+          continue;
+        }
+        properties.push(transformJsxAttributeToObjectLiteralElement(attr));
       }
       if (children) {
-        expressions.push(factory2.createObjectLiteralExpression([children]));
+        properties.push(children);
+      }
+      finishObjectLiteralIfNeeded();
+      if (expressions.length && !isObjectLiteralExpression(expressions[0])) {
+        expressions.unshift(factory2.createObjectLiteralExpression());
       }
       return singleOrUndefined(expressions) || emitHelpers().createAssignHelper(expressions);
-    }
-    function transformJsxSpreadAttributeToExpression(node) {
-      return Debug.checkDefined(visitNode(node.expression, visitor, isExpression));
+      function finishObjectLiteralIfNeeded() {
+        if (properties.length) {
+          expressions.push(factory2.createObjectLiteralExpression(properties));
+          properties = [];
+        }
+      }
     }
     function transformJsxAttributeToObjectLiteralElement(node) {
       const name = getAttributeName(node);

package/lib/typescript.d.ts

@@ -3198,6 +3198,7 @@ declare namespace ts {
         strictBindCallApply?: boolean;
         strictNullChecks?: boolean;
         strictPropertyInitialization?: boolean;
+        strictInstanceOfTypeParameters?: boolean;
         stripInternal?: boolean;
         suppressExcessPropertyErrors?: boolean;
         suppressImplicitAnyIndexErrors?: boolean;

package/lib/typescript.js

@@ -8623,6 +8623,7 @@ ${lanes.join("\n")}
         Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(6718, 3 /* Message */, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."),
         Default_catch_clause_variables_as_unknown_instead_of_any: diag(6803, 3 /* Message */, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."),
         Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting: diag(6804, 3 /* Message */, "Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_i_6804", "Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting."),
+        Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks: diag(6805, 3 /* Message */, "Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks_6805", "Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks."),
         one_of_Colon: diag(6900, 3 /* Message */, "one_of_Colon_6900", "one of:"),
         one_or_more_Colon: diag(6901, 3 /* Message */, "one_or_more_Colon_6901", "one or more:"),
         type_Colon: diag(6902, 3 /* Message */, "type_Colon_6902", "type:"),
@@ -37734,6 +37735,16 @@ ${lanes.join("\n")}
           description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
           defaultValueDescription: false
         },
+        {
+          name: "strictInstanceOfTypeParameters",
+          type: "boolean",
+          affectsSemanticDiagnostics: true,
+          affectsBuildInfo: true,
+          strictFlag: true,
+          category: Diagnostics.Type_Checking,
+          description: Diagnostics.Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks,
+          defaultValueDescription: false
+        },
         {
           name: "alwaysStrict",
           type: "boolean",
@@ -44973,6 +44984,7 @@ ${lanes.join("\n")}
     var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
     var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
     var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
+    var strictInstanceOfTypeParameters = true;
     var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
     var defaultIndexFlags = keyofStringsOnly ? 1 /* StringsOnly */ : 0 /* None */;
     var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
@@ -52946,9 +52958,30 @@ ${lanes.join("\n")}
         }
       }).parent;
     }
+    function getInstanceTypeOfClassSymbol(classSymbol) {
+      const classType = getDeclaredTypeOfSymbol(classSymbol);
+      const objectFlags = getObjectFlags(classType);
+      if (!(objectFlags & 3 /* ClassOrInterface */) || !classType.typeParameters) {
+        return classType;
+      }
+      const variances = getVariances(classType);
+      const typeArguments = map(classType.typeParameters, (typeParameter, i) => {
+        if (!strictInstanceOfTypeParameters) {
+          return anyType;
+        }
+        const variance = variances[i];
+        switch (variance & 7 /* VarianceMask */) {
+          case 2 /* Contravariant */:
+          case 3 /* Bivariant */:
+            return neverType;
+        }
+        return getBaseConstraintOfType(typeParameter) || unknownType;
+      });
+      return createTypeReference(classType, typeArguments);
+    }
     function getTypeOfPrototypeProperty(prototype) {
-      const classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype));
-      return classType.typeParameters ? createTypeReference(classType, map(classType.typeParameters, (_) => anyType)) : classType;
+      const classSymbol = getParentOfSymbol(prototype);
+      return getInstanceTypeOfClassSymbol(classSymbol);
     }
     function getTypeOfPropertyOfType(type, name) {
       const prop = getPropertyOfType(type, name);
@@ -58239,7 +58272,7 @@ ${lanes.join("\n")}
       }
     }
     function removeStringLiteralsMatchedByTemplateLiterals(types) {
-      const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t) && !some(t.types, (t2) => !!(t2.flags & 2097152 /* Intersection */)));
+      const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t));
       if (templates.length) {
         let i = types.length;
         while (i > 0) {
@@ -67428,8 +67461,8 @@ ${lanes.join("\n")}
         if (symbol === void 0) {
           return type;
         }
-        const classSymbol = symbol.parent;
-        const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) : getDeclaredTypeOfSymbol(classSymbol);
+        const classSymbol = getParentOfSymbol(symbol);
+        const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) : getInstanceTypeOfClassSymbol(classSymbol);
         return getNarrowedType(
           type,
           targetType,
@@ -97453,10 +97486,13 @@ ${lanes.join("\n")}
           return Debug.failBadSyntaxKind(node);
       }
     }
+    function hasProto(obj) {
+      return obj.properties.some((p) => isPropertyAssignment(p) && (isIdentifier(p.name) && idText(p.name) === "__proto__" || isStringLiteral(p.name) && p.name.text === "__proto__"));
+    }
     function hasKeyAfterPropsSpread(node) {
       let spread = false;
       for (const elem of node.attributes.properties) {
-        if (isJsxSpreadAttribute(elem)) {
+        if (isJsxSpreadAttribute(elem) && (!isObjectLiteralExpression(elem.expression) || elem.expression.properties.some(isSpreadAssignment))) {
           spread = true;
         } else if (spread && isJsxAttribute(elem) && elem.name.escapedText === "key") {
           return true;
@@ -97622,7 +97658,10 @@ ${lanes.join("\n")}
       }
       return element;
     }
-    function transformJsxSpreadAttributeToSpreadAssignment(node) {
+    function transformJsxSpreadAttributeToProps(node) {
+      if (isObjectLiteralExpression(node.expression) && !hasProto(node.expression)) {
+        return node.expression.properties;
+      }
       return factory2.createSpreadAssignment(Debug.checkDefined(visitNode(node.expression, visitor, isExpression)));
     }
     function transformJsxAttributesToObjectProps(attrs, children) {
@@ -97630,30 +97669,48 @@ ${lanes.join("\n")}
       return target && target >= 5 /* ES2018 */ ? factory2.createObjectLiteralExpression(transformJsxAttributesToProps(attrs, children)) : transformJsxAttributesToExpression(attrs, children);
     }
     function transformJsxAttributesToProps(attrs, children) {
-      const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToSpreadAssignment(attr) : transformJsxAttributeToObjectLiteralElement(attr))));
+      const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => flatten(map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToProps(attr) : transformJsxAttributeToObjectLiteralElement(attr)))));
       if (children) {
         props.push(children);
       }
       return props;
     }
     function transformJsxAttributesToExpression(attrs, children) {
-      const expressions = flatten(
-        spanMap(
-          attrs,
-          isJsxSpreadAttribute,
-          (attrs2, isSpread) => isSpread ? map(attrs2, transformJsxSpreadAttributeToExpression) : factory2.createObjectLiteralExpression(map(attrs2, transformJsxAttributeToObjectLiteralElement))
-        )
-      );
-      if (isJsxSpreadAttribute(attrs[0])) {
-        expressions.unshift(factory2.createObjectLiteralExpression());
+      const expressions = [];
+      let properties = [];
+      for (const attr of attrs) {
+        if (isJsxSpreadAttribute(attr)) {
+          if (isObjectLiteralExpression(attr.expression) && !hasProto(attr.expression)) {
+            for (const prop of attr.expression.properties) {
+              if (isSpreadAssignment(prop)) {
+                finishObjectLiteralIfNeeded();
+                expressions.push(prop.expression);
+                continue;
+              }
+              properties.push(prop);
+            }
+            continue;
+          }
+          finishObjectLiteralIfNeeded();
+          expressions.push(attr.expression);
+          continue;
+        }
+        properties.push(transformJsxAttributeToObjectLiteralElement(attr));
       }
       if (children) {
-        expressions.push(factory2.createObjectLiteralExpression([children]));
+        properties.push(children);
+      }
+      finishObjectLiteralIfNeeded();
+      if (expressions.length && !isObjectLiteralExpression(expressions[0])) {
+        expressions.unshift(factory2.createObjectLiteralExpression());
       }
       return singleOrUndefined(expressions) || emitHelpers().createAssignHelper(expressions);
-    }
-    function transformJsxSpreadAttributeToExpression(node) {
-      return Debug.checkDefined(visitNode(node.expression, visitor, isExpression));
+      function finishObjectLiteralIfNeeded() {
+        if (properties.length) {
+          expressions.push(factory2.createObjectLiteralExpression(properties));
+          properties = [];
+        }
+      }
     }
     function transformJsxAttributeToObjectLiteralElement(node) {
       const name = getAttributeName(node);

package/lib/typingsInstaller.js

@@ -6693,6 +6693,7 @@ var Diagnostics = {
   Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(6718, 3 /* Message */, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."),
   Default_catch_clause_variables_as_unknown_instead_of_any: diag(6803, 3 /* Message */, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."),
   Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting: diag(6804, 3 /* Message */, "Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_i_6804", "Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting."),
+  Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks: diag(6805, 3 /* Message */, "Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks_6805", "Default type arguments to parameter constraint or 'unknown' instead of 'any' for instance checks."),
   one_of_Colon: diag(6900, 3 /* Message */, "one_of_Colon_6900", "one of:"),
   one_or_more_Colon: diag(6901, 3 /* Message */, "one_or_more_Colon_6901", "one or more:"),
   type_Colon: diag(6902, 3 /* Message */, "type_Colon_6902", "type:"),
@@ -25906,6 +25907,16 @@ var commandOptionsWithoutBuild = [
     description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
     defaultValueDescription: false
   },
+  {
+    name: "strictInstanceOfTypeParameters",
+    type: "boolean",
+    affectsSemanticDiagnostics: true,
+    affectsBuildInfo: true,
+    strictFlag: true,
+    category: Diagnostics.Type_Checking,
+    description: Diagnostics.Default_type_arguments_to_parameter_constraint_or_unknown_instead_of_any_for_instance_checks,
+    defaultValueDescription: false
+  },
   {
     name: "alwaysStrict",
     type: "boolean",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.1.0-pr-53406-15",
+  "version": "5.1.0-pr-49863-41",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [
@@ -114,5 +114,5 @@
     "node": "14.21.1",
     "npm": "8.19.3"
   },
-  "gitHead": "37d8ce9fa5f3be59c6d3b4bf3aae3098b0e1f190"
+  "gitHead": "30e1c3216ad5c9d403ef25217a94174ef7dd1340"
 }