Return type is any of getter in object passed as generic

Bug Report

When the following is true:

You are passing an object created inline to a function
The type of that function argument is generic
The object has a getter that accesses this
The object also has a function

Then the return type of the getter will be any.

If you either remove the function from the object or create the object before passing it into the function the getter will return the correct type.

🔎 Search Terms

any, object, generic

🕗 Version & Regression Information

Bug present in all versions available on the playground, including nightly

⏯ Playground Link

Playground link with relevant code

💻 Code

declare function generic<T>(v: T): T;

// Passing object directly to genery gives type `any` on `get hi()`
const store = generic({
  hello: "hi",

  // return type of getter is any
  get hi() {
    return this.hello;
  },

  // If you remove this function, return type of getter will be string
  doSomething() { }
});

const res = store.hi // any

// Passing object directly to genery gives type `any` on `get hi()`
const obj = {
  hello: "hi",

  // return type of getter is string
  get hi() {
    return this.hello;
  },

  doSomething() { }
};
const store2 = generic(obj)

const res2 = store2.hi // string

🙁 Actual behavior

Return type of getters are any

🙂 Expected behavior

Return type of getters have the type of the returned data

Looks related -- from src/compiler/checker.ts, resolveCallExpression(...)

// When a call to a generic function is an argument to an outer call to a generic function for which
// inference is in process, we have a choice to make. If the inner call relies on inferences made from
// its contextual type to its return type, deferring the inner call processing allows the best possible
// contextual type to accumulate. But if the outer call relies on inferences made from the return type of
// the inner call, the inner call should be processed early. There's no sure way to know which choice is
// right (only a full unification algorithm can determine that), so we resort to the following heuristic:
// If no type arguments are specified in the inner call and at least one call signature is generic and
// returns a function type, we choose to defer processing. This narrowly permits function composition
// operators to flow inferences through return types, but otherwise processes calls right away. We
// use the resolvingSignature singleton to indicate that we deferred processing. This result will be
// propagated out and eventually turned into nonInferrableType (a type that is assignable to anything and
// from which we never make inferences).
if (checkMode & CheckMode.SkipGenericFunctions 
    && !node.typeArguments 
    && callSignatures.some(isGenericFunctionReturningFunction)) {
    skippedGenericFunction(node, checkMode);
    return resolvingSignature;
}

#58483

This is fixed by PR #62243. With --target es6 --strict, 4.7.2 and 6.0.0-dev.20251210 infer any for the inline getter, while 6.0.0-dev.20251211, TypeScript 6.0.3, and the current native compiler infer string for both the inline and stored-object getters.

Navigation Menu

Return type is `any` of getter in object passed as generic #49511

Bug Report

🔎 Search Terms

🕗 Version & Regression Information

⏯ Playground Link

💻 Code

🙁 Actual behavior

🙂 Expected behavior

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Return type is any of getter in object passed as generic #49511

Description

Bug Report

🔎 Search Terms

🕗 Version & Regression Information

⏯ Playground Link

💻 Code

🙁 Actual behavior

🙂 Expected behavior

Activity

craigphicks commented on Jun 14, 2022

lqzhgood commented on May 9, 2024

RyanCavanaugh commented on Sep 9, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

Return type is `any` of getter in object passed as generic #49511