Narrow number literal types with comparison

Search Terms

constant number literals narrowing comparison

Suggestion

Narrow number literal type not only with (non)equality, but also with less-than etc.
This request is only about throwing away non-matching literals, and not about full-blown number narrowing.

Use Cases

This could be used to direct narrowing with tuple unions.

Examples

With literals

type X = 0 | 1 | 2 | 3;
function f(): X {
    return 1;
}
function g(x: 0 | 3) { 
    console.log(x);
}
let x: X = f();
g(x); // Error, 1 | 2 is unexpected
if (x > 2) { 
    g(x); // Same error, but should be safe
}
if (x != 1 && x != 2) { 
    g(x); // Ok
}

With tuples

type X = [] | [string, string];
function f(): X { return [];}
function g(x: string) { 
    console.log(x);
}
let x: X = f();
g(x[0]); // Error, undefined is unexpected
if (x.length > 0) { 
    g(x[0]); // Error, but should be ok
}
if (x.length == 2) { 
    g(x[0]); // Ok
}

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Bắt đầu với các ví dụ về literal và tuple trong issue, tái hiện các chẩn đoán hiện tại và hành vi narrowing của chúng. Xác định các kết quả control-flow mong đợi cho các phép kiểm tra so sánh, bao gồm các phép so sánh less-than và độ dài tuple, đồng thời xác minh rằng thay đổi này chỉ loại bỏ các trường hợp literal không thể xảy ra mà không đưa vào narrowing số nói chung.