TypeScript 4.0 Iteration Plan

[DanielRosenwasser]

This document outlines our focused tasks for TypeScript 4.0, as well as some of the discussion that explains how/why we prioritized certain work items. Nothing is set in stone, but we will strive to complete them in a reasonable timeframe.

Date	Event
May 12th	TypeScript 3.9 Release (past)
June 22nd	Create 4.0 Beta (4.0.0) Build for Testing
June 25th	TypeScript 4.0 Beta Release
July 31st	Create 4.0 RC (4.0.1) Build for Testing
August 6th	TypeScript 4.0 RC Release
August 14th	Create 4.0 Final (4.0.2) Build for Testing
August 20th	TypeScript 4.0 Final Release 🚀

Language Features

• Short-Circuiting Assignment Operators
• Labeled Tuple Elements
• Class Property Inference from Constructors
• Forward Declarations
• Investigate the awaited Type
• JSX Factory Updates
• unknown on catch Clause Bindings
• Variadic Tuples

Editor Productivity

• Refactorings
  • Convert to Optional Chaining and Coalescing
• Discoverability in Refactoring (ideas)
• Lightweight Navigation
• Improved Auto-Import
• Editor support for /** @deprecated */ tags
• Editor support for /** @see */ tags
• Semantic Highlighting

Performance

• More Type-Checking Optimizations
• Investigate Bottlenecks in Larger Apps

Infrastructure

• Migrate TypeScript to Modules
• Expand Commands Tested in TSServer Crawler
• GitHub Crawler Infrastructure to Find Breaking Changes

Investigate High-Demand Bug Fixes

• Don't Widen Computed Property Keys
• Cleaning Files Under --watch
• Higher Order Component Issues
• Remove --declaration Emit Error
• Inference for Proxies
• change events on <input type="file">have no files field
• Poor Error for isolatedModules

[checkmatez]

Would you consider to include #29818 in 4.0 maybe behind experimental flag?

[Jessidhia]

That gets complicated by the change in factory function definition in itself.

It could be interesting to introduce a separate factory virtual type definition, though; say, JSX.Factory, or React.JSX.Factory, which TypeScript could then use for inference. I'm not quite sure just translating JSX grammar to function calls is sufficient or efficient but, since it's a virtual type, it doesn't have to correspond to any concrete JavaScript entity. The risk, of course, is getting into the same situation as we have now, with a bunch of virtual types that ended up limiting the type safety, not only of children, but of several features introduced after React 15.

[ExE-Boss]

Would you consider to also include #24738 in 4.0 as well?

[leemhenson]

I'm a bit sad to see no mention of #33038 [👍 140 and an actual PR by your own @weswigham] or #202 [👍 390] while tickets like #15230 [👍 27] are considered "high-demand". I realise you can't really compare or prioritise on the basis of "likes" but it would be great if there was some roadmap update on these, especially as 4.0 seems like nice opportunity to introduce a feature like this. 🙏

[Skillz4Killz]

~3.5-year-old issue awaiting feedback with almost 200 comments #13778 with inaccurate typings provided for stuff like array destructuring. Pwetty pwease can we implement fix 🙏

[DanielRosenwasser]

I appreciate people occasionally boosting issues that they believe need attention on the roadmaps and iteration plans, but I think I need to be clear here -that "investigate high demand bug fixes" section was determined by looking through issues that were clearly causing a lot of papercuts but which seemed reasonable in scope. We're definitely still mindful of the issues mentioned, but some of them are not as scoped nor do they have a clear ideal outcome.

Examples:

• Nominal brands would be nice, but would that compose with future language direction around nominality? I even have this concern with placeholder types as the person who proposed it.
• undefined on index signatures is an example of something that's interesting, but we don't want to add behavior that makes it harder for 90% of people who already operate under the current assumptions. Finding an approach that composes and allows users to incrementally adopt those checks isn't something that's obvious to us. Even if it's technically possible with a bunch of conditional types and special compiler checks, those solutions tend to be very clearly hacky and break down fast.

[aminpaks]

Nominal brands would be nice, but would that compose with future language direction around nominality?

@DanielRosenwasser what is the future language direction in your vision?

[DanielRosenwasser]

I guess I'll give some context on where my mind is with nominality. There are a lot of different ideas people have in mind when they ask about nominal types, including

• "Traditional" declaration-based nominality (e.g. what you see in most OO languages)
• Opaque types (types whose contents are entirely unknown outside)
• Distinct aliases (single-member structs in C/C++/C#, newtype in Haskell, inline classes in Kotlin)
• Units of measure (a way to encode dimensional analysis into the language)

There are shades between some of these (e.g. placeholder type declarations - kind of variant of opaque types that fall back to an implementation type), and then there are different directions that blend each of these together.

@RyanCavanaugh had a great analogy about this where 3 kids are asking their parents for a pet. One wants a dog, one wants a cat, one wants a fish. They ask their parents "when are we getting a pet!?" Clearly they all agree they want a pet, but each wants a different pet!

Do I like branded types? I do! Branded types achieves something like distinct aliases, and fits the bill for what most users are looking for. But I don't think that's the right way to think about it. There's more design space to be fleshed out with plenty of known tradeoffs, and nothing giving me a sense that we need to rush a solution ASAP.

[ExE-Boss]

I’d like if we could get microsoft/TypeScript-DOM-lib-generator#858 into TypeScript 4.0.

[benjamingr]

@DanielRosenwasser first of all thank you for the writeup 🙇

Can you elaborate a bit on what use cases nominal types actually address for TypeScript?

First: feel free to send me to a giant wall of text or a repo and I'll read it :]

I don't mean opaque types like placeholder types - I mean what you call "Traditional" nominal types.

I always felt nominal types were antithetical to JavaScript and that's why previous attempts didn't really work so well. There are ways to make it work pretty nicely (protocols in swift and typeclasses in haskell come to mind as "Nominal but extendable from the outside") and I'm sure you're familiar with most of the "well established" ways (I assume "units of measure" is an F# wink).

I have found a lot of people asking for nominal (as in "traditional") types but not a lot of writeups about why.

[DanielRosenwasser]

Over time, we've seen fewer and fewer people request "traditional" nominal types, maybe because collectively the community has built up a mental mode for structural types. There are some places where types truly do act nominally (when instanceof is involved or when there are privates). Some of that is captured with better control flow analysis and compatibility checks, but it's not perfect.

Some of the "traditional" use-cases are the same as those of a zero-overhead nominal wrapper type (e.g. newtype), and a lot of the time the intent there is to ensure special handling for things like file paths, untrusted strings, etc.

[chyzwar]

I kind of feel that Typescript is already expressive enough. What I would personally would like to see is better tooling integration.

• support for ESM New --emitExtension and --noImplicitExtensionName compiler options #35148 Provide a way to add the '.js' file extension to the end of module specifiers #16577
• compiler plugins Allow "Compiler Plugins" #16607 Pre-Compiler Plugin Proposal #38736
• yarn pnp Add new moduleResolution option: yarn-pnp #28289 Native support for PnP #35206

Because of above it is common to see clunky and hacky solutions. Most react projects have babel included for react-hot-loader (compiler plugins), some CSS systems also require babel for compile time transforms. Using pnp, esm or even CSS modules require more tooling and workarounds for tsc limitations.

It is also frustrating that for some of these issues community came with concrete solutions in form of PRs or proposals but these were rejected or stalled for years. As a practitioner, it is getting harder to use TS in the context of wider ecosystem.

Anyway I am just random person from internet.