deleting a prop doesn't invalidate the interface

[donaldpipowitch]

TypeScript Version: 2.1? (Playground)

Code

interface Props {
    foo: string;
    bar: string;
}

const p: Props = {
    foo: 'hello',
    bar: 'world'
}

const say = (props: Props) => console.log(`${props.foo.length} ${props.bar.length}`);

say(p);

delete p.bar;
say(p); // works, but should throw

See here.

Expected behavior:

Don't compile, because we delete bar from p.

Actual behavior:

Compiles. Resulting in a runtime error: Uncaught TypeError: Cannot read property 'length' of undefined.

[ahejlsberg]

To track effects of delete you need to compile with --strictNullChecks and declare the property optional. Upon seeing delete p.bar the control flow analyzer will then consider p.bar to have the value undefined.

[donaldpipowitch]

I do use --strictNullCheck, but I don't see why this (and declaring the property) is optional. Why is this working as intended? E.g. this won't compile:

interface Props {
    foo: string;
    bar: string;
}

const p: Props = {  // an error happens here, because `p` is not assignable to type `Props`
    foo: 'hello'
}

const say = (props: Props) => console.log(`${props.foo.length} ${props.bar.length}`);

say(p);

Using delete p.bar changes the p from my initial example essentially to a p without bar as in my second example. And a p without bar doesn't match Props, so it shouldn't be possible to call say with it.

Or am I wrong?

[mhegazy]

this compiles too without --strictNullChecks:

const p: Props = {  
    foo: 'hello'
    bar: undefined
}

and will result in the same runtime behavior.

[donaldpipowitch]

I try to summarise:

Given we have the following interface, function and using --strictNullChecks:

interface Props {
    foo: string;
    bar: string;
}

const say = (props: Props) => console.log(`${props.foo.length} ${props.bar.length}`);

This is invalid:

const p = {
    foo: 'hello',
    bar: undefined
};
say(p);

This is invalid:

const p = {
    foo: 'hello'
};
say(p);

This is invalid:

const p = {
    foo: 'hello',
    bar: 'world'
};
p.bar = undefined;
say(p);

But this is valid and intended?:

const p = {
    foo: 'hello',
    bar: 'world'
};
delete p.bar;
say(p);

That means I'd need to mark every property in every interface as optional, if I'd want nobody to accidentally delete a required property. Isn't that more of a bug instead of an intended solution?

---

Note that this works, too. But it is probably also a bug.

const p1 = {
    foo: 'hello',
    bar: 'world'
};
const p2 = {
    ...p1,
    bar: undefined
};
say(p2);

[donaldpipowitch]

@mhegazy you closed the issue, so this works as intended? Looking at my examples from three months ago this still looks wrong to me.

[mhegazy]

The last case is tracked by #13195.

[mhegazy]

for this case, with --strictNullChecks:

const p = {
    foo: 'hello',
    bar: 'world'
};
delete p.bar;
say(p);

I do not think control flow analysis is the right tool here, but we could disallow deleting a property whose type does not include undefined; treeing it the same way as p.bar = undefined;.

[donaldpipowitch]

Thank you!