Type variable escaping its scope becomes `any`

[pelotom]

TypeScript version 2.5.3

I've been playing around with encoding existential types in TypeScript, which has become much easier due to improvements in type inference (thanks!) Here's an example:

type StackSig<S, A> = {
  init(): S
  push(s: S, x: A): void
  pop(s: S): A
  size(s: S): number
}
 
type Stack<A> = <R>(go: <S>(ops: StackSig<S, A>) => R) => R

const arrayStack = <A>(): Stack<A> =>
  go => go<A[]>({
    init: () => [],
    push: (s, x) => s.push(x),
    pop: s => {
      if (s.length) return s.pop()!
      else throw Error('empty stack!')
    },
    size: s => s.length,
  })

const doStringStackStuff = (stack: Stack<string>) =>
  stack(({ init, push, pop, size }) => {
    const s = init()
    push(s, 'hello')
    push(s, 'world')
    push(s, 'omg')
    pop(s)
    return size(s)
  })

const result = doStringStackStuff(arrayStack())
expect(result).toBe(2)

This all works great; the type of the stack object s is an opaque variable S. However what happens if the type variable escapes the scope in which it's bound?

const s = arrayStack()(ops => ops.init())
s.bogus() // no type error, because `s: any`

What happens right now is that s is quietly inferred to have type any. It seems like it should be something like {} or void; a type with which we can't actually do anything meaningful.

[mhegazy]

here is a simpler reproduction:

declare const s: <R>(go: <S>(ops: { init(): S; }) => R) => R;
const x = s(a => a.init());  // x is any, should have been {}

[ahejlsberg]

Ideally we'd infer the upper bound of the particular type parameter (which in the case of an unconstrained type parameter is {}), however we don't have a good answer for self-referential constraints (e.g. S extends Foo<S>). For that reason we currently infer any, but I agree that is overly broad. I suppose we could instantiate the constraint with mapper that erases type parameters to any. This would give us meaningful types for non-recursive constraints and decently good types for recursive cases (i.e. the correct top-level structure but with any for the recursive occurrences).

[mhegazy]

Note for breaking change documentation:

declare function createInstance<A1, T>(ctor: Constructor<A1, T>, first: A1): T;

interface Constructor<A1, T> {
    new(first: A1): T;
}

export class Con<T> {
    constructor(x: number) {
    }
}

createInstance(Con, 3) // Used to be `Con<any>`, now `Con<{}>`

[mmorearty]

For the record, this change causes trouble for some of our code that uses React, and I haven't yet found a good workaround. I don't know if you would consider this a bug — probably not — so I'm a little hesitant to file a separate issue; but since this breaking change means I need a cast where I didn't need one before, I thought I would add a comment here to make sure you were aware of this impact.

Sorry I didn't make a standalone sample app. In order to compile the following samples with React, you can set up a project using these commands:

mkdir test
cd test
npm init -y
npm install --save react
npm install --save-dev @types/react

Then put the following code in index.ts and compile with tsc index.ts.

Let's start with this code, which defines a simple React component , and a create function to create an instance of that component given a collection of properties:

import * as React from "react";

interface Props<T> {
    cache: T[];
}

class Component<T> extends React.Component<Props<T>, {}> {
}

const create = React.createFactory(Component);

With that, we can create instances of Component, and the type T in Props<T> will be inferred, which is nice:

const stringComponent = create({ cache: ["a", "b", "c"] });
const numberComponent = create({ cache: [1, 2, 3] });

But there are cases where type can't be inferred, or can't be inferred with the value we want — e.g. suppose cache is an empty array, so the compiler can't figure out T, even though we know we want T to be string:

const emptyStringComponent = create({ cache: [] });

So we want to be able to specify the type of T:

const emptyStringComponent = create<string>({ cache: [] });

To enable that, we explicitly specify the type of const create, rather than letting the compiler infer it. Since the type is a generic function, after I add the following, I can do the create<string> thing above:

const create: <T>(props: Props<T>) => React.CElement<Props<T>, Component<T>>
    = React.createFactory(Component);

That type definition works with TypeScript 2.6.2. But with 2.7.2, the compiler objects:

index.ts(10,7): error TS2322: Type 'ComponentFactory<Props<{}>, Component<{}>>' is not assignable to type '<T>(props: Props<T>) => ComponentElement<Props<T>, Component<T>>'.
  Type 'ComponentElement<Props<{}>, Component<{}>>' is not assignable to type 'ComponentElement<Props<T>, Component<T>>'.
    Type 'Props<{}>' is not assignable to type 'Props<T>'.
      Type '{}' is not assignable to type 'T'.

The only workaround I've found is to add a cast. (Apologies if I've missed a better workaround.)