Actually have a chance to reuse optional property signatures in the node builder (microsoft#57995)

Author: weswigham

src/compiler/checker.ts

@@ -8551,7 +8551,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             if (typeFromTypeNode === type) {
                 return true;
             }
-            if (annotatedDeclaration && (isParameter(annotatedDeclaration) || isPropertyDeclaration(annotatedDeclaration)) && annotatedDeclaration.questionToken) {
+            if (annotatedDeclaration && (isParameter(annotatedDeclaration) || isPropertySignature(annotatedDeclaration) || isPropertyDeclaration(annotatedDeclaration)) && annotatedDeclaration.questionToken) {
                 return getTypeWithFacts(type, TypeFacts.NEUndefined) === typeFromTypeNode;
             }
             return false;

tests/baselines/reference/avoidNarrowingUsingConstVariableFromBindingElementWithLiteralInitializer.types

@@ -8,8 +8,8 @@ declare const foo: ["a", string, number] | ["b", string, boolean];
 export function test(arg: { index?: number }) {
 >test : (arg: { index?: number; }) => void
 >     : ^^^^^^                   ^^^^^^^^^
->arg : { index?: number | undefined; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>arg : { index?: number; }
+>    : ^^^^^^^^^^      ^^^
 >index : number | undefined
 >      : ^^^^^^^^^^^^^^^^^^
 

tests/baselines/reference/checkJsxIntersectionElementPropsType.types

@@ -23,8 +23,8 @@ declare class Component<P> {
 class C<T> extends Component<{ x?: boolean; } & T> {}
 >C : C<T>
 >  : ^^^^
->Component : Component<{ x?: boolean | undefined; } & T>
->          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Component : Component<{ x?: boolean; } & T>
+>          : ^^^^^^^^^^^^^^^^       ^^^^^^^^
 >x : boolean | undefined
 >  : ^^^^^^^^^^^^^^^^^^^
 

tests/baselines/reference/circularlyConstrainedMappedTypeContainingConditionalNoInfiniteInstantiationDepth.types

@@ -16,8 +16,8 @@ declare class Component<P> {
 >        : ^^^
 
     readonly props: Readonly<P> & Readonly<{ children?: {} }>;
->props : Readonly<P> & Readonly<{ children?: {} | undefined; }>
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>props : Readonly<P> & Readonly<{ children?: {}; }>
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^
 >children : {} | undefined
 >         : ^^^^^^^^^^^^^^
 }
@@ -42,8 +42,8 @@ interface ComponentClass<P = {}> {
 }
 interface FunctionComponent<P = {}> {
     (props: P & { children?: {} }, context?: any): {} | null;
->props : P & { children?: {} | undefined; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>props : P & { children?: {}; }
+>      : ^^^^^^^^^^^^^^^^^  ^^^
 >children : {} | undefined
 >         : ^^^^^^^^^^^^^^
 >context : any

tests/baselines/reference/contextualSignatureConditionalTypeInstantiationUsingDefault.types

@@ -33,8 +33,8 @@ declare function createMachine<
   TTypesMeta extends TypegenEnabled | TypegenDisabled = TypegenDisabled
 >(
   config: {
->config : { types?: TTypesMeta | undefined; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>config : { types?: TTypesMeta; }
+>       : ^^^^^^^^^^          ^^^
 
     types?: TTypesMeta;
 >types : TTypesMeta | undefined

tests/baselines/reference/contextuallyTypedOptionalProperty(exactoptionalpropertytypes=false).types

@@ -14,8 +14,8 @@ declare function match<T>(cb: (value: T) => boolean): T;
 declare function foo(pos: { x?: number; y?: number }): boolean;
 >foo : (pos: { x?: number; y?: number; }) => boolean
 >    : ^^^^^^                           ^^^^^       
->pos : { x?: number | undefined; y?: number | undefined; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>pos : { x?: number; y?: number; }
+>    : ^^^^^^      ^^^^^^      ^^^
 >x : number | undefined
 >  : ^^^^^^^^^^^^^^^^^^
 >y : number | undefined

tests/baselines/reference/contextuallyTypedParametersWithInitializers1.types

@@ -28,8 +28,8 @@ declare function id3<T extends (x: { foo: any }) => any>(input: T): T;
 declare function id4<T extends (x: { foo?: number }) => any>(input: T): T;
 >id4 : <T extends (x: { foo?: number; }) => any>(input: T) => T
 >    : ^ ^^^^^^^^^^^^^                 ^^^^^   ^^^^^^^^^ ^^^^^ 
->x : { foo?: number | undefined; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>x : { foo?: number; }
+>  : ^^^^^^^^      ^^^
 >foo : number | undefined
 >    : ^^^^^^^^^^^^^^^^^^
 >input : T

tests/baselines/reference/controlFlowAliasing.types

@@ -1284,8 +1284,8 @@ class C11 {
 function f40(obj: { kind: 'foo', foo?: string } | { kind: 'bar', bar?: number }) {
 >f40 : (obj: { kind: 'foo'; foo?: string; } | { kind: 'bar'; bar?: number; }) => void
 >    : ^^^^^^                                                               ^^^^^^^^^
->obj : { kind: 'foo'; foo?: string | undefined; } | { kind: 'bar'; bar?: number | undefined; }
->    : ^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>obj : { kind: 'foo'; foo?: string; } | { kind: 'bar'; bar?: number; }
+>    : ^^^^^^^^     ^^^^^^^^      ^^^^^^^^^^^^^^     ^^^^^^^^      ^^^
 >kind : "foo"
 >     : ^^^^^
 >foo : string | undefined

tests/baselines/reference/controlFlowDeleteOperator.types

@@ -6,8 +6,8 @@ function f() {
 >  : ^^^^^^^^^^
 
     let x: { a?: number | string, b: number | string } = { b: 1 };
->x : { a?: string | number | undefined; b: number | string; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^               ^^^
+>x : { a?: number | string; b: number | string; }
+>  : ^^^^^^               ^^^^^               ^^^
 >a : string | number | undefined
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >b : string | number

tests/baselines/reference/controlFlowInitializedDestructuringVariables.types

@@ -2,8 +2,8 @@
 
 === controlFlowInitializedDestructuringVariables.ts ===
 declare const obj: { a?: string, b?: number };
->obj : { a?: string | undefined; b?: number | undefined; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>obj : { a?: string; b?: number; }
+>    : ^^^^^^      ^^^^^^      ^^^
 >a : string | undefined
 >  : ^^^^^^^^^^^^^^^^^^
 >b : number | undefined