Merge remote-tracking branch 'upstream/master'

* upstream/master:
  Include unknown in spread prop override check (microsoft#38577)
  Fix (cosmetic) typos in checker.ts comments

Author: cangSDARM

src/compiler/checker.ts

@@ -7597,7 +7597,7 @@ namespace ts {
 
             if (isPropertyDeclaration(declaration) && (noImplicitAny || isInJSFile(declaration))) {
                 // We have a property declaration with no type annotation or initializer, in noImplicitAny mode or a .js file.
-                // Use control flow analysis of this.xxx assignments the constructor to determine the type of the property.
+                // Use control flow analysis of this.xxx assignments in the constructor to determine the type of the property.
                 const constructor = findConstructorDeclaration(declaration.parent);
                 const type = constructor ? getFlowTypeInConstructor(declaration.symbol, constructor) :
                     getEffectiveModifierFlags(declaration) & ModifierFlags.Ambient ? getTypeOfPropertyInBaseClass(declaration.symbol) :
@@ -7622,7 +7622,7 @@ namespace ts {
         }
 
         function isConstructorDeclaredProperty(symbol: Symbol) {
-            // A propery is considered a constructor declared property when all declaration sites are this.xxx assignments,
+            // A property is considered a constructor declared property when all declaration sites are this.xxx assignments,
             // when no declaration sites have JSDoc type annotations, and when at least one declaration site is in the body of
             // a class constructor.
             if (symbol.valueDeclaration && isBinaryExpression(symbol.valueDeclaration)) {
@@ -10565,7 +10565,7 @@ namespace ts {
             // Since getApparentType may return a non-reduced union or intersection type, we need to perform
             // type reduction both before and after obtaining the apparent type. For example, given a type parameter
             // 'T extends A | B', the type 'T & X' becomes 'A & X | B & X' after obtaining the apparent type, and
-            // that type may need futher reduction to remove empty intersections.
+            // that type may need further reduction to remove empty intersections.
             return getReducedType(getApparentType(getReducedType(type)));
         }
 
@@ -23595,7 +23595,7 @@ namespace ts {
             for (const right of getPropertiesOfType(type)) {
                 const left = props.get(right.escapedName);
                 const rightType = getTypeOfSymbol(right);
-                if (left && !maybeTypeOfKind(rightType, TypeFlags.Nullable) && !(maybeTypeOfKind(rightType, TypeFlags.Any) && right.flags & SymbolFlags.Optional)) {
+                if (left && !maybeTypeOfKind(rightType, TypeFlags.Nullable) && !(maybeTypeOfKind(rightType, TypeFlags.AnyOrUnknown) && right.flags & SymbolFlags.Optional)) {
                     const diagnostic = error(left.valueDeclaration, Diagnostics._0_is_specified_more_than_once_so_this_usage_will_be_overwritten, unescapeLeadingUnderscores(left.escapedName));
                     addRelatedInfo(diagnostic, createDiagnosticForNode(spread, Diagnostics.This_spread_always_overwrites_this_property));
                 }

tests/baselines/reference/jsxPartialSpread.js

@@ -0,0 +1,26 @@
+//// [jsxPartialSpread.tsx]
+/// <reference path="/.lib/react16.d.ts" />
+const Select = (p: {value?: unknown}) => <p></p>;
+import React from 'react';
+
+export function Repro({ SelectProps = {} }: { SelectProps?: Partial<Parameters<typeof Select>[0]> }) {
+    return (
+        <Select value={'test'} {...SelectProps} />
+    );
+}
+
+//// [jsxPartialSpread.jsx]
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.Repro = void 0;
+/// <reference path="react16.d.ts" />
+var Select = function (p) { return <p></p>; };
+var react_1 = __importDefault(require("react"));
+function Repro(_a) {
+    var _b = _a.SelectProps, SelectProps = _b === void 0 ? {} : _b;
+    return (<Select value={'test'} {...SelectProps}/>);
+}
+exports.Repro = Repro;

tests/baselines/reference/jsxPartialSpread.symbols

@@ -0,0 +1,28 @@
+=== tests/cases/compiler/jsxPartialSpread.tsx ===
+/// <reference path="react16.d.ts" />
+const Select = (p: {value?: unknown}) => <p></p>;
+>Select : Symbol(Select, Decl(jsxPartialSpread.tsx, 1, 5))
+>p : Symbol(p, Decl(jsxPartialSpread.tsx, 1, 16))
+>value : Symbol(value, Decl(jsxPartialSpread.tsx, 1, 20))
+>p : Symbol(JSX.IntrinsicElements.p, Decl(react16.d.ts, 2467, 102))
+>p : Symbol(JSX.IntrinsicElements.p, Decl(react16.d.ts, 2467, 102))
+
+import React from 'react';
+>React : Symbol(React, Decl(jsxPartialSpread.tsx, 2, 6))
+
+export function Repro({ SelectProps = {} }: { SelectProps?: Partial<Parameters<typeof Select>[0]> }) {
+>Repro : Symbol(Repro, Decl(jsxPartialSpread.tsx, 2, 26))
+>SelectProps : Symbol(SelectProps, Decl(jsxPartialSpread.tsx, 4, 23))
+>SelectProps : Symbol(SelectProps, Decl(jsxPartialSpread.tsx, 4, 45))
+>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
+>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --))
+>Select : Symbol(Select, Decl(jsxPartialSpread.tsx, 1, 5))
+
+    return (
+        <Select value={'test'} {...SelectProps} />
+>Select : Symbol(Select, Decl(jsxPartialSpread.tsx, 1, 5))
+>value : Symbol(value, Decl(jsxPartialSpread.tsx, 6, 15))
+>SelectProps : Symbol(SelectProps, Decl(jsxPartialSpread.tsx, 4, 23))
+
+    );
+}

tests/baselines/reference/jsxPartialSpread.types

@@ -0,0 +1,33 @@
+=== tests/cases/compiler/jsxPartialSpread.tsx ===
+/// <reference path="react16.d.ts" />
+const Select = (p: {value?: unknown}) => <p></p>;
+>Select : (p: {    value?: unknown;}) => JSX.Element
+>(p: {value?: unknown}) => <p></p> : (p: {    value?: unknown;}) => JSX.Element
+>p : { value?: unknown; }
+>value : unknown
+><p></p> : JSX.Element
+>p : { value?: unknown; }
+>p : { value?: unknown; }
+
+import React from 'react';
+>React : typeof React
+
+export function Repro({ SelectProps = {} }: { SelectProps?: Partial<Parameters<typeof Select>[0]> }) {
+>Repro : ({ SelectProps }: {    SelectProps?: Partial<Parameters<typeof Select>[0]>;}) => JSX.Element
+>SelectProps : Partial<{ value?: unknown; }>
+>{} : {}
+>SelectProps : Partial<{ value?: unknown; }> | undefined
+>Select : (p: { value?: unknown; }) => JSX.Element
+
+    return (
+>(        <Select value={'test'} {...SelectProps} />    ) : JSX.Element
+
+        <Select value={'test'} {...SelectProps} />
+><Select value={'test'} {...SelectProps} /> : JSX.Element
+>Select : (p: { value?: unknown; }) => JSX.Element
+>value : string
+>'test' : "test"
+>SelectProps : Partial<{ value?: unknown; }>
+
+    );
+}

tests/cases/compiler/jsxPartialSpread.tsx

@@ -0,0 +1,12 @@
+// @jsx: preserve
+// @esModuleInterop: true
+// @strict: true
+/// <reference path="/.lib/react16.d.ts" />
+const Select = (p: {value?: unknown}) => <p></p>;
+import React from 'react';
+
+export function Repro({ SelectProps = {} }: { SelectProps?: Partial<Parameters<typeof Select>[0]> }) {
+    return (
+        <Select value={'test'} {...SelectProps} />
+    );
+}