For every position the tests passed through, apply either writes the type it saw or leaves the position alone, and says why. Each section below is one rule it decides by, with small files that end there: run, applied, and the code that made the call. How good the types it writes are, in real projects, is on In real code.
The examples are not written by hand: each is run through the same applier as the playground when the page is built, and a test checks that it still ends in its rule.
// A line added after the run moves everything below it.functionstamp(clock) {
clock();
}
stamp(() => newDate());
After ts-capture apply
// A line added after the run moves everything below it.functionstamp(clock) {
clock();
}
stamp(() => newDate());
A line was added above the code after the run. Every recorded position now points one line too early, at no parameter, so apply writes nothing there and says so.
// A line added after the run moves everything below it.classStore {
items = JSON.parse("[1, 2]");
}
newStore();
After ts-capture apply
// A line added after the run moves everything below it.classStore {
items = JSON.parse("[1, 2]");
}
newStore();
A line was added above the code after the run. Every recorded position now points one line too early, at no field, so apply writes nothing there and says so.
// A line added after the run moves everything below it.functiongreet(user) {
return"Hello " + user.name;
}
greet({ name: "Ada" });
After ts-capture apply
// A line added after the run moves everything below it.functiongreet(user) {
return"Hello " + user.name;
}
greet({ name: "Ada" });
A line was added above the code after the run. Every recorded position now points one line too early, at no parameter, so apply writes nothing there and says so.
// A line added after the run moves everything below it.functionload() {
returnJSON.parse('{"a": 1}');
}
load();
After ts-capture apply
// A line added after the run moves everything below it.functionload() {
returnJSON.parse('{"a": 1}');
}
load();
A line was added above the code after the run. Every recorded position now points one line too early, at no function, so apply writes nothing there and says so.
// A line added after the run moves everything below it.constdata = JSON.parse('{"id": 1}');
After ts-capture apply
// A line added after the run moves everything below it.constdata = JSON.parse('{"id": 1}');
A line was added above the code after the run. Every recorded position now points one line too early, at no variable, so apply writes nothing there and says so.
A variable that holds a function, sits in a generic function, or is initialized by a call that names its type arguments gets its type from there. A type written on the variable would repeat it, or contradict it.
The run saw one call, with a number. Inside the function the value is a T, which stands for every type a caller can pass, so writing number would be wrong for the others.
The initializer can give either side of ??, ||, ?: or ?., and the run saw one. Writing what it saw would forbid the other, so the type is left to TypeScript.
The initializer can give either side of ??, and the run only ever saw one. Writing what it saw would forbid the other, so the type is left to TypeScript.
The initializer can give either side of ??, and the run only ever saw one. Writing what it saw would forbid the other, so the type is left to TypeScript, which knows both.
The lookup missed, so the run saw undefined alone. TypeScript knows the lookup can also hit. Writing undefined would forbid that, so the type is left to TypeScript.
A callback passed to an array method is typed by the array's element type. Writing the element's shape again adds a long type and nothing else. A primitive is still written.
With no tsconfig there is no type checker. Whether TypeScript would infer the same type is then read from the initializer's syntax. With a project the checker answers first, as gate.redundant.
No example on this page: the page runs every example the way the playground does, and this rule needs a run it cannot make.
No call passed this parameter, so all the run saw was undefined. That says nothing about what the parameter is for, and written as options: undefined it would make every call that does pass options an error.
functioncountTags(post): number {
returnpost.tags.length;
}
countTags({ tags: [] });
The one call passed { tags: [] }, and an empty array says nothing about what goes in it. Written as unknown[], the field would make every reader of it handle unknown, so the shape is dropped, and nothing is left to write.
functionstore(record) {
returnObject.keys(record).length;
}
for (leti = 0; i < 400; i++) store({ [`field${i}`]: i });
After ts-capture apply
functionstore(record) {
returnObject.keys(record).length;
}
for (leti = 0; i < 400; i++) store({ [`field${i}`]: i });
The calls passed 400 different shapes. Their union is longer than maxAnnotationChars (4096 characters by default), and an annotation that long is harder to read than no annotation.
Observed
{ field0: number } | { field1: number } | { field2: number } | { field3: number } | { field4: number } | { field5: number } | { field6: number } | { field7: number } | { field8: number } | { field9: number } | { field10: number } | { field11: number } | { field12: number } | { field13: number } | { field14: number } | { field15: number } | { field16: number } | { field17: number } | { field18: number } | { field19: number } | { field20: number } | { field21: number } | { field22: number } | { field23: number } | { field24: number } | { field25: number } | { field26: number } | { field27: number } | { field28: number } | { field29: number } | { field30: number } | { field31: number } | { field32: number } | { field33: number } | { field34: number } | { field35: number } | { field36: number } | { field37: number } | { field38: number } | { field39: number } | { field40: number } | { field41: number } | { field42: number } | { field43: number } | { field44: number } | { field45: number } | { field46: number } | { field47: number } | { field48: number } | { field49: number } | { field50: number } | { field51: number } | { field52: number } | { field53: number } | { field54: number } | { field55: number } | { field56: number } | { field57: number } | { field58: number } | { field59: number } | { field60: number } | { field61: number } | { field62: number } | { field63: number } | { field64: number } | { field65: number } | { field66: number } | { field67: number } | { field68: number } | { field69: number } | { field70: number } | { field71: number } | { field72: number } | { field73: number } | { field74: number } | { field75: number } | { field76: number } | { field77: number } | { field78: number } | { field79: number } | { field80: number } | { field81: number } | { field82: number } | { field83: number } | { field84: number } | { field85: number } | { field86: number } | { field87: number } | { field88: number } | { field89: number } | { field90: number } | { field91: number } | { field92: number } | { field93: number } | { field94: number } | { field95: number } | { field96: number } | { field97: number } | { field98: number } | { field99: number } | { field100: number } | { field101: number } | { field102: number } | { field103: number } | { field104: number } | { field105: number } | { field106: number } | { field107: number } | { field108: number } | { field109: number } | { field110: number } | { field111: number } | { field112: number } | { field113: number } | { field114: number } | { field115: number } | { field116: number } | { field117: number } | { field118: number } | { field119: number } | { field120: number } | { field121: number } | { field122: number } | { field123: number } | { field124: number } | { field125: number } | { field126: number } | { field127: number } | { field128: number } | { field129: number } | { field130: number } | { field131: number } | { field132: number } | { field133: number } | { field134: number } | { field135: number } | { field136: number } | { field137: number } | { field138: number } | { field139: number } | { field140: number } | { field141: number } | { field142: number } | { field143: number } | { field144: number } | { field145: number } | { field146: number } | { field147: number } | { field148: number } | { field149: number } | { field150: number } | { field151: number } | { field152: number } | { field153: number } | { field154: number } | { field155: number } | { field156: number } | { field157: number } | { field158: number } | { field159: number } | { field160: number } | { field161: number } | { field162: number } | { field163: number } | { field164: number } | { field165: number } | { field166: number } | { field167: number } | { field168: number } | { field169: number } | { field170: number } | { field171: number } | { field172: number } | { field173: number } | { field174: number } | { field175: number } | { field176: number } | { field177: number } | { field178: number } | { field179: number } | { field180: number } | { field181: number } | { field182: number } | { field183: number } | { field184: number } | { field185: number } | { field186: number } | { field187: number } | { field188: number } | { field189: number } | { field190: number } | { field191: number } | { field192: number } | { field193: number } | { field194: number } | { field195: number } | { field196: number } | { field197: number } | { field198: number } | { field199: number } | { field200: number } | { field201: number } | { field202: number } | { field203: number } | { field204: number } | { field205: number } | { field206: number } | { field207: number } | { field208: number } | { field209: number } | { field210: number } | { field211: number } | { field212: number } | { field213: number } | { field214: number } | { field215: number } | { field216: number } | { field217: number } | { field218: number } | { field219: number } | { field220: number } | { field221: number } | { field222: number } | { field223: number } | { field224: number } | { field225: number } | { field226: number } | { field227: number } | { field228: number } | { field229: number } | { field230: number } | { field231: number } | { field232: number } | { field233: number } | { field234: number } | { field235: number } | { field236: number } | { field237: number } | { field238: number } | { field239: number } | { field240: number } | { field241: number } | { field242: number } | { field243: number } | { field244: number } | { field245: number } | { field246: number } | { field247: number } | { field248: number } | { field249: number } | { field250: number } | { field251: number } | { field252: number } | { field253: number } | { field254: number } | { field255: number } | { field256: number } | { field257: number } | { field258: number } | { field259: number } | { field260: number } | { field261: number } | { field262: number } | { field263: number } | { field264: number } | { field265: number } | { field266: number } | { field267: number } | { field268: number } | { field269: number } | { field270: number } | { field271: number } | { field272: number } | { field273: number } | { field274: number } | { field275: number } | { field276: number } | { field277: number } | { field278: number } | { field279: number } | { field280: number } | { field281: number } | { field282: number } | { field283: number } | { field284: number } | { field285: number } | { field286: number } | { field287: number } | { field288: number } | { field289: number } | { field290: number } | { field291: number } | { field292: number } | { field293: number } | { field294: number } | { field295: number } | { field296: number } | { field297: number } | { field298: number } | { field299: number } | { field300: number } | { field301: number } | { field302: number } | { field303: number } | { field304: number } | { field305: number } | { field306: number } | { field307: number } | { field308: number } | { field309: number } | { field310: number } | { field311: number } | { field312: number } | { field313: number } | { field314: number } | { field315: number } | { field316: number } | { field317: number } | { field318: number } | { field319: number } | { field320: number } | { field321: number } | { field322: number } | { field323: number } | { field324: number } | { field325: number } | { field326: number } | { field327: number } | { field328: number } | { field329: number } | { field330: number } | { field331: number } | { field332: number } | { field333: number } | { field334: number } | { field335: number } | { field336: number } | { field337: number } | { field338: number } | { field339: number } | { field340: number } | { field341: number } | { field342: number } | { field343: number } | { field344: number } | { field345: number } | { field346: number } | { field347: number } | { field348: number } | { field349: number } | { field350: number } | { field351: number } | { field352: number } | { field353: number } | { field354: number } | { field355: number } | { field356: number } | { field357: number } | { field358: number } | { field359: number } | { field360: number } | { field361: number } | { field362: number } | { field363: number } | { field364: number } | { field365: number } | { field366: number } | { field367: number } | { field368: number } | { field369: number } | { field370: number } | { field371: number } | { field372: number } | { field373: number } | { field374: number } | { field375: number } | { field376: number } | { field377: number } | { field378: number } | { field379: number } | { field380: number } | { field381: number } | { field382: number } | { field383: number } | { field384: number } | { field385: number } | { field386: number } | { field387: number } | { field388: number } | { field389: number } | { field390: number } | { field391: number } | { field392: number } | { field393: number } | { field394: number } | { field395: number } | { field396: number } | { field397: number } | { field398: number } | { field399: number }
TypeScript types the return as this, which in a subclass is the subclass. The run saw a Builder. Writing Builder would make every subclass's chained calls return the base class.
resolve is a function the engine made, so the run can only say it was callable. TypeScript already has its signature, and Function would throw that away.
Observed
Function · TypeScript has (value: unknown) => void
TypeScript types user as the interface User from where the callback is passed. The run saw a shape with one more field. Writing that shape would throw the name User away, and with it everything the interface says.
Observed
{ age: number, name: string } · TypeScript has User
TypeScript types this parameter as the enum Mode. The run only sees the string underneath. Writing string would throw the enum away, and with it every comparison against Mode.Fast.
TypeScript infers a union, and the run saw only some of its arms. Writing those would forbid the rest, so the type is left to TypeScript, which already holds every value the run saw.
The tests only ever got null back here, but TypeScript knows the call can also return the array. Writing null would forbid the array, so the type is left to TypeScript, which already holds both.
Observed
null · TypeScript has (string | number | null)[] | null
TypeScript types next from the signature the callback is assigned to: a function, never missing. The run passed undefined once. Apply reports the disagreement instead of widening the parameter.
Observed
() => void | undefined · the type here is () => void
TypeScript already types this callback parameter as string, but the run passed undefined too. Apply does not write a type the checker contradicts; it reports the disagreement instead.
TypeScript reads the return as string from the parameter's type. The run got undefined, because a test passed an object without the field. Apply reports that instead of writing either.
TypeScript types an element of a string[] as string. The loop read one past the end, so the run saw undefined too. Apply reports the disagreement instead of writing either.
In the tests cache.match gave null, where TypeScript infers Response or undefined. ts-capture does not write a type the checker contradicts. It leaves a note saying what it saw.
cond gets its type from conditions, which TypeScript prints by the alias name Condition. The run saw the alias's body, (c: Context) => boolean: the same type, so there is nothing to write.
cond gets its type from conditions, and the run saw the same. TypeScript spells it (c: Context<any, any>) => boolean away from the code and (c: Context) => boolean where cond is, so it is the type TypeScript has.
The run saw { name: string }, but the function adds a field. Written, that type would make the next line an error, so apply type-checks every annotation first and drops this one.
threshold is written; stock is not. The observed shape would have added a type error on the next line, so apply left the parameter as it was and said so in its report.
Not written
stock · would add a type error
Observed
{ "sku-chair": number, "sku-lamp": number }
Why
TS7053 at src/inventory.ts:10: Element implicitly has an 'any' type because expression of type 'string' can't be used to index type '{ "sku-chair": number; "sku-lamp": number; }'. No index signature with a parameter of type 'stri…
Every call returned a number, so that is what the run saw. But label hands the result on as a string, and written, the type would make that line an error.
Judged with the run's other annotations written, TypeScript infers a type that holds everything the run saw, and is wider. A variable is left to TypeScript. A return type is written as TypeScript has it, unless TypeScript inferred it before the run too.
This call returned null[]. Once valuesOrNull has its return type, TypeScript infers the wider array for the variable, and that holds what the run saw. Writing null[] would only narrow it.
Observed
null[] · TypeScript infers a wider type once the other annotations are written
functionfindUser(id: number) {
if (id < 0) returnnull;
return { id };
}
findUser(1);
After ts-capture apply
functionfindUser(id: number) {
if (id < 0) returnnull;
return { id };
}
findUser(1);
The tests never took return null, so the run saw only the object. TypeScript inferred { id: number } | null before the run already, so writing it would only repeat it.
Observed
{ id: number } · TypeScript infers a wider type once the other annotations are written
The run only saw the branch that returns a number, so Promise<number> does not hold. The returned function's parameters are typed in the code, so TypeScript knew its type before the run. Read from outside the function it spells Request<any>, at the return Request, but it is one type, and it is left to TypeScript.
Observed
(request: Request, reply: (text: string) => number) => Promise<number> · TypeScript infers a wider type once the other annotations are written
The tests never took the return null branch, so what the run saw would not compile with it. Once values is written, TypeScript infers a type that holds every value the run saw, and that is what is written.
The order's lines were not all alike: one had a note, one did not. They are written as one kind of line where the note may be missing, the same as for a list passed on its own.
Each call passed a list of lines, and only the second had a note. The parameter is written as a list of one kind of line where the note may be missing, which both calls fit.
One order had plain lines, one had none, and one had a line with a note. The lines are written as one kind of line where the note may be missing, and the missing list stays a null beside them.
The returned function takes a Request, and every type parameter of Request has a default. TypeScript knows nothing of greeting, so the return type is written, and it says Request as the code does, not Request<unknown>.
A function that reads this without being a method has an implicit any this. With the instrumenter asked to look for it, the run sees what this was and apply writes it as the first parameter.