[ASDAlexander77]

Quick wins from docs/not_impl (not_impl7, not_impl27).

A generic call with nothing to infer from takes the default, then the constraint

function noParams<T extends {}>() called as noParams(), and even function f<T = string>()
as f(), failed with "generic type arguments cannot be inferred". instantiateSpecializedFunction
now fills the type parameters from their defaults, then their constraints
(zipTypeParametersWithDefaultArguments, as the inference path already does), and reports only a
parameter with neither.

Test: 00generic_default_no_inference.

Promise<T> is T

An async function runs to completion and returns its value, but async function f(): Promise<number>
failed with "generic type Promise can't be found". Promise, PromiseLike and Awaited are now
embedded types that stand for their type argument, with and without builtins. A program's own
Promise<T> is still found first.

Test: 00promise_type.

A callback whose result is ignored may return one

TS lets an arrow given to a function type that returns nothing return a value:
each(a, s => bump(s)) with f: (s: string) => void, or (x) => null.

• An arrow or function expression with no return type of its own, given to a function type whose
  result is a declared void, is generated as returning nothing
  (FunctionPrototypeDOM::discardsReturnValue, kept per function name). Its concise body and its
  return e statements evaluate the value as a statement does and drop it - no retain, so nothing
  leaks under rc. Only an explicit !ts.void result counts: a receiver with no result or a null one
  is one not resolved yet ((i: T) => R while R is inferred, builtin callbacks).
• A variable's declared function type is the receiver of its initializer, as an assignment's left
  side already was.

Explicit type arguments type the arguments

A call to a generic function with every type argument given, none of them still generic, is
specialised before its arguments are generated, so produce<any>(() => undefined) meets
() => any, not () => T. It runs with the call's own (no) operands - the enclosing call's
operands broke DefaultLib's reduce through __is<V, T> - and a failure rolls its diagnostics
back and leaves the call to specialise as before.

Test (both): 00callback_result_ignored.

Not covered

• () => 3 for (x: number) => void (fewer parameters) still fails: it needs an adapter thunk.
• Under -mm=own, a generic returning a callback's any result is rejected - already so on main.

Verification

• ctest Release: 6109/6109 passed.
• DefaultLib tests.ps1 Release (with the companion DefaultLib PR): gc 176/176, rc 175/176
  (1 skipped), none 175/176 (1 skipped), own 165/176 (11 skipped) - all pass. Debug not run locally.

Companion: ASDAlexander77/TypeScriptCompilerDefaultLib#54 (String.substr).

🤖 Generated with Claude Code