Suggestion: Let null assertion (!) operator block "used before assigned" errors

[ghost]

TypeScript Version: nightly (2.1.0-dev.20161008)

Code

(Compile with --strictNullChecks)

let n: number
doit(() => {
    n = 0
})
n! + 1

function doit(action) { action() }

Expected behavior:

No error

Actual behavior:

a.ts(5,1): error TS2454: Variable 'n' is used before being assigned.

The problem is fixed by using let n: number | undefined, but it's not obvious that that's the solution, and it would be intuitive for the ! operator to work in this situation.

Aside: I don't see the ! operator documented in the handbook.

[kitsonk]

Yes, some solution to immediately invoked callbacks would be great. @novemberborn and others have had issues trying to convert a Promise into a deferral and we have had to actually assign noop functions to values to work around the CFA. For example:

const noop = () => { };

function createDeferral() {
    let complete = noop;
    let cancel = noop;
    const promise = new Promise<void>((resolve, reject) => {
        complete = resolve;
        cancel = reject;
    });

    return { complete, cancel, promise };
}

const deferral = createDeferral();

Which sort of seems silly. I assume we would rewrite it as this with this proposal:

function createDeferral() {
    let complete: () => void;
    let cancel: () => void;
    const promise = new Promise<void>((resolve, reject) => {
        complete = resolve;
        cancel = reject;
    });

    return { complete!, cancel!, promise };
}

const deferral = createDeferral();

I also second the "undocumented" nature of !. Several of the team found it by accident by searching issues.

[kitsonk]

As I mentioned in #11498 I am more supportive of an annotation that indicates that the function is immediately invoked than this solution.

[RyanCavanaugh]

Approved since "not assigned yet" is really the same thing as "still has undefined in its domain"