String literal types in complex type expressions

TypeScript Version:

1.8.2

Code

interface Foo {
    ok:string;
    okToo: number;
    notOk:  "o" | "k";
}

interface Bar {
    bar: string;
}

interface FooBar extends Foo, Bar{
}

function mix<T>(obj:T): T & Bar {
    (obj as any).bar="bar";
    return obj as T & Bar;
}

var fooBar:FooBar = mix({
    ok:"ok",
    okToo: 42,
    notOk:"k"
});

Expected behavior:

The assignment to fooBar should be allowed.

Actual behavior:

I get the totally confusing error:

Error:(20, 5) TS2322: Type '{ ok: string; notOk: string; } & Bar' is not assignable to type 'FooBar'.
 Type 'Bar' is not assignable to type 'FooBar'.
 Property 'ok' is missing in type 'Bar'.

The confusing part is that it complains about the first property (ok) and not about notOk.

Looking at the error message it seems that the string literal type notOk:"o"|"k" was converted to notOk :string.

Therefore when I turn the string literal type to a string (notOk:string) everything is OK....

Hint: defining the string literal type as a type does not solve the problem:

type NotOK =  "o" | "k";

interface Foo {
    //...
    notOk: NotOK;
}
//...

I could do

var fooBar:FooBar = mix({
    ok:"ok",
    okToo: 42,
    notOk:"k"
}) as FooBar ;

but then I loose all the benefits of type checking...

I think you're expecting too much from type argument inference. Give mix an explicit type argument and it should work:
var fooBar: FooBar = mix<Foo>({ ... })

var foo: Foo = {
    ok:"ok",
    okToo: 42,
    notOk:"k"
};
var fooBar = mix(foo);

Should work fine. TS only infers literal types when there is a type annotation implying them.

Wesley Wigham (@weswigham)

It is as Wesley Wigham (@weswigham) explained. Though we may be should consider give a better error message especially this part of the error is a bit misleading

 Type 'Bar' is not assignable to type 'FooBar'.
 Property 'ok' is missing in type 'Bar'.

Daniel Rosenwasser (@DanielRosenwasser)

The problem is that, in the object literal passed to mix, notOk is inferred to be string absent any other information. As soon as the compiler knows that notOk: "k" is actually of type "k" or "o" | "k" then the assignment works. The minimal annotation is actually:

var foobar: FooBar = mix({
  ok:"ok",
  okToo: 42,
  notOk: "k" as "k" // or as "o" | "k"
});

The error message you get without the annotation looks completely wrong to me, or at least misleading.

Daniel Rosenwasser (@DanielRosenwasser) has a PR #6554 that defaults string literals to string literal types, and then widens to string as needed. After that goes in, the type of "k" will be "k" by default.

Nathan Shively-Sanders (@sandersn)

Nathan Shively-Sanders (@sandersn) that solves the problem :-)

So, if I define type OK = "o" | "k"; I can use it in the cast:

type OK =  "o" | "k";

interface Foo {
    //...
    nowOk: OK;
}
var foobar: FooBar = mix({
    //...
    nowOk: "k" as OK;
});

that should work, or even specifying the type argument explicitlly:

var foobar: FooBar = mix<Foo>({
    //...
    nowOk: "k";
});

Navigation Menu

Repository navigation

String literal types in complex type expressions #7199

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

String literal types in complex type expressions #7199

Description

Activity

scharf commented on Feb 23, 2016

jeffreymorlan commented on Feb 23, 2016

weswigham commented on Feb 23, 2016

yuit commented on Feb 23, 2016

sandersn commented on Feb 23, 2016

scharf commented on Feb 23, 2016

mhegazy commented on Feb 23, 2016

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions