-
Notifications
You must be signed in to change notification settings - Fork 12.9k
Description
Search Terms
emit, typeof, variable
Suggestion
I'm just opening this issue so I have somewhere to refer to.
I don't necessarily think this is a good idea.
I'm just thinking about a problem I have aloud.
It would be nice if I had a way to annotate when I would prefer emit to use typeof variable
instead of emitting the variable
's type.
type SomeType<T> = { x : T };
//Unsure of what syntax to use
type SomeType2<typeof T> = { x : T };
const variable = { prop : "value" };
/*
Expected:
type Foo = {
x: {
prop: string;
};
}
*/
type Foo = SomeType<typeof variable>;
/*
Expected:
type Foo2 = {
x: typeof variable;
}
*/
type Foo2 = SomeType2<typeof variable>;
/*
Expected:
type Bar = {
x: { prop : "value" };
}
*/
type Bar = SomeType<{ prop : "value" }>;
/*
Expected:
type Bar2 = {
x: { prop : "value" };
}
*/
type Bar2 = SomeType2<{ prop : "value" }>;
declare function f_1_1<T> (t : T) : SomeType<T>;
declare function f_1_2<T> (t : T) : SomeType2<T>;
declare function f_2_1<typeof T> (t : T) : SomeType<T>;
declare function f_2_2<typeof T> (t : T) : SomeType2<T>;
//Expected: { x: { prop: string } }
export const r_1_1 = f_1_1(variable);
//Call-site does not have preference for `typeof` emit
//Expected: { x: { prop: string } }
export const r_1_2 = f_1_2(variable);
//Expect to propagate preference to emit `typeof`
//Expected: { x: typeof variable }
export const r_2_1 = f_2_1(variable);
//Expected: { x: typeof variable }
export const r_2_2 = f_2_2(variable);
/*
Variable with nested properties
*/
const baz = { a : { b : { c : "hi" } } };
//Expect to propagate preference to emit `typeof`
//Expected: { x: typeof baz.a }
export const r_2_1 = f_2_1(baz.a);
//Expected: { x: typeof baz.a }
export const r_2_2 = f_2_2(baz.a);
It's just a preference. If such an emit can't be done, then it falls back to the default emit behaviour.
Use Cases
My use case is that one of my subprojects initially spent 15s on check but 45s on emit.
A lot of it is because it's expanding the type of some variables (110+ lines) when it can just use typeof variable
(1 line)
Right now, it's at 18s to check, 47s to emit.
If I can make it emit typeof variable
for the parts where it is possible,
I can probably reduce my emit size and time by a lot.
A SQL table has a bunch of columns, primary keys, candidate keys, etc.
For type-safe JOIN
clauses and expressions in a query builder, these expressions, clauses, queries, etc. need to have information about the table(s) being used be part of their generic type param.
However, because TS always expands the type as much as possible, I end up with 110+ lines when a simple typeof myTable
or typeof myTable.columns
or typeof import("../table").myTable
or typeof import("../table").myTable.columns
would do in most cases.
I'm still trying to trim the amount of information each type needs about a table but there's just no escaping that a lot of information is still needed for SQL queries to be checked properly during compile-time.
Examples
See above suggestion.
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.