Add/modify tests

Author: ahejlsberg

tests/cases/compiler/genericCallInferenceInConditionalTypes1.ts

@@ -0,0 +1,59 @@
+// @strict: true
+// @noEmit: true
+
+// https://github.com/microsoft/TypeScript/issues/59937
+
+type Ref<T> = {
+  current: T;
+};
+
+type FunctionComponent<P> = (props: P) => unknown;
+
+type ComponentProps<T extends FunctionComponent<any>> =
+  T extends FunctionComponent<infer P> ? P : {};
+
+type PropsWithoutRef<P> = P extends any
+  ? "ref" extends keyof P
+    ? Omit<P, "ref">
+    : P
+  : P;
+
+type ComponentPropsWithoutRef<T extends FunctionComponent<any>> =
+  PropsWithoutRef<ComponentProps<T>>;
+
+declare function forwardRef<T, P>(
+  component: (props: P, ref: Ref<T>) => unknown,
+): (props: P & { ref?: Ref<T> }) => unknown;
+
+const ComponentWithForwardRef = forwardRef(
+  <T extends FunctionComponent<any>>(
+    props: ComponentPropsWithoutRef<T>,
+    ref: Ref<HTMLElement>,
+  ) => {
+    return null;
+  },
+);
+
+type Test<T> = T extends { component?: infer Component }
+  ? Component extends FunctionComponent<any>
+    ? ComponentProps<Component>
+    : never
+  : never;
+
+// the first one here has a chance to pollute the cache
+type Result1 = ComponentProps<typeof ComponentWithForwardRef>;
+// that could be incorrectly reused by this one
+type Result2 = Test<{ component: typeof ComponentWithForwardRef }>; // no `T` leak
+
+// same as ComponentWithForwardRef above but using a resolved signature instead of a direct inferred result of `forwardRef`
+declare const ComponentWithForwardRef2: <T extends FunctionComponent<any>>(
+  props: PropsWithoutRef<ComponentProps<T>> & {
+    className?: string;
+    as?: T | undefined;
+  } & {
+    ref?: Ref<HTMLElement> | undefined;
+  },
+) => unknown;
+
+type Result3 = ComponentProps<typeof ComponentWithForwardRef2>;
+type Result4 = Test<{ component: typeof ComponentWithForwardRef2 }>;

tests/cases/compiler/genericCallInferenceUsingThisTypeNoInvalidCacheReuseAfterMappedTypeApplication1.ts

@@ -0,0 +1,46 @@
+// @strict: true
+// @noEmit: true
+
+declare const EffectTypeId: unique symbol;
+
+interface Variance<out A, out E, out R> {
+  readonly [EffectTypeId]: VarianceStruct<A, E, R>;
+}
+
+type Covariant<A> = (_: never) => A;
+
+interface VarianceStruct<out A, out E, out R> {
+  readonly _V: string;
+  readonly _A: Covariant<A>;
+  readonly _E: Covariant<E>;
+  readonly _R: Covariant<R>;
+}
+
+interface Effect<out A, out E = never, out R = never>
+  extends Variance<A, E, R> {}
+
+declare const succeed: <A>(value: A) => Effect<A>;
+
+type F<X, Y> = Y extends { _type: infer Z }
+  ? X extends Effect<infer A, infer E, infer R>
+    ? Effect<A, E, R | Z>
+    : X
+  : X;
+
+type ProxyMap<Service> = {
+  [K in keyof Service]: (Service & { _type: Service })[K];
+};
+
+declare const implement: <T>() => <I extends ReadonlyArray<any>, X>(
+  x: (...i: I) => X,
+) => (...i: I) => F<X, T>;
+
+class XXX {
+  log = implement<this>()(<N extends number>(n: N) => succeed(n));
+}
+
+export declare const inner: XXX;
+export declare const outer: ProxyMap<XXX>;
+
+export const a = inner.log(100); // Effect<100, never, never>
+export const b = outer.log(100); // Effect<100, never, XXX>

tests/cases/compiler/genericCallInferenceWithGenericLocalFunction.ts

@@ -12,3 +12,18 @@ function withP2<P>(p: P) {
 
 const addP2 = withP2({ foo: 1 });
 const added2 = addP2({ bar: 2 });
+
+function withP3<P>(p: P) {
+  const m =
+    <I,>(from: I) =>
+    <I2,>(from2: I2) => ({ ...from, ...from2, ...p });
+  return createTransform(m);
+}
+
+const addP3 = withP3({ a: 1 });
+const addedSome3 = addP3({ b: '' });
+const added3 = addedSome3({ c: true });
+
+const addP3_other = withP3({ foo: 'bar' });
+const addedSome3_other = addP3_other({ qwerty: 123 });
+const added3_other = addedSome3_other({ bazinga: true });

tests/cases/compiler/genericCallWithinOwnBodyCastTypeParameterIdentity.ts

@@ -0,0 +1,27 @@
+// @strict: true
+
+interface Thenable<Value> {
+    then<V>(
+        onFulfilled: (value: Value) => V | Thenable<V>,
+    ): Thenable<V>;
+}
+
+const toThenable = <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) =>
+    (input: Input): Thenable<Result> => {
+        const result = fn(input)
+        return {
+            then<V>(onFulfilled: (value: Result) => V | Thenable<V>) {
+                return toThenable<V, Result>(onFulfilled)(result as Result)
+            }
+        };
+    }
+
+const toThenableInferred = <Result, Input>(fn: (input: Input) => Result | Thenable<Result>) =>
+    (input: Input): Thenable<Result> => {
+        const result = fn(input)
+        return {
+            then(onFulfilled) {
+                return toThenableInferred(onFulfilled)(result as Result)
+            }
+        };
+    }

tests/cases/compiler/inferenceFromGenericClassNoCrash1.ts

@@ -0,0 +1,10 @@
+// @strict: true
+// @noEmit: true
+
+// https://github.com/microsoft/TypeScript/issues/61633#issuecomment-2841778576
+
+function RenderFlagsMixin<T extends new (...args: any[]) => object>(Base?: T) {}
+class Container<T> {
+  t: T;
+}
+RenderFlagsMixin(Container);

tests/cases/compiler/nestedGenericSpreadInference.ts

@@ -0,0 +1,6 @@
+// @strict: true
+
+declare function wrap<X>(x: X): { x: X };
+declare function call<A extends unknown[], T>(x: { x: (...args: A) => T }, ...args: A): T;
+
+const leak = call(wrap(<T>(x: T) => x), 1);