Why I'm excited for Biome's type inference
A few weeks ago, Biome published their 2024 roadmap. There’s a lot of good stuff in there, but one thing has me particularly curious: type inference for implementing lint rules that rely on TypeScript type information.
There’s a lot to unpack in that single sentence. What is Biome actually trying to achieve here?
First of all, I would like to stress that they’re not trying to create a full implementation of the TypeScript compiler. And not even a full implementation of its type-checking capabilities either. For those, users are expected to continue to use the official TypeScript compiler. So what are they trying to do then?
Biome is a linter (among other things) and as such they’re competing with ESLint. One of the most popular plugins for ESLint is typescript-eslint, which is able to use TypeScript type information to implement lint rules that go beyond what ESLint could offer out of the box. I like to call those “type-informed” lint rules.
Biome has already implemented some of the lint rules from the typescript-eslint
project, such as
That rule is specific to the TypeScript syntax, but it is not a type-informed
An example of a type-informed rule is
the difference? While
useConsistentArrayType operates on the TypeScript
await-thenable relies on actual type information to know which
expressions evaluate to something thenable.
Let’s take this statement from the
Depending on what
createValue contains, the rule will either report a
diagnostic, or not. Is
async function, or another function
Promise? Then it’s fine. But if it’s not, then a diagnostic is
reported. And that’s the kind of decision making that requires type information,
which only type-informed rules can do.
So today, Biome is able to implement TypeScript rules that operate at a syntax level, but type-informed rules are still out of its reach. The typescript-eslint project solved this problem by talking to the real TypeScript compiler to extract type information from it. Biome could do something similar, but there’s a catch: It comes with a significant performance overhead. For some users, that overhead is worth it. But Biome is attracting users from other tools on the premise of being magnitudes faster. Going the same route as typescript-eslint wouldn’t provide a very compelling reason to switch.
So instead, Biome intends to implement a minimal subset of type inference (the part that tracks what type a given expression evaluates to) so that it is able to implement type-informed lint rules of its own. Its approach would be limited by nature, but that’s all right: Users are still expected to use the TypeScript compiler for type safety. The linter is “merely” an additional safety net, and it doesn’t need to be perfect. If it can catch some user’s mistakes, while being much faster than alternative solutions, it would be a very useful addition to its current offering.
So far, I’ve only explained what Biome’s goals for 2024 are. There’s no guarantee they will be delivered in time, of course, but generally I think they make a lot of sense. But what makes me more excited than the near-term is the potential longer term impact: Could this lead to the implementation of a full TypeScript compiler in Rust?
Building a TypeScript compiler in Rust is a monumental task, but that hasn’t
stopped people from trying. Most notably there are the
stc and Ezno
projects. Both have been at it for over a year, but neither is showing signs of
offering “good enough” compatibility to replace the TypeScript compiler anytime
soon. That’s not a dig at them, because I applaud their efforts. But the reason
I think they face an uphill battle is because it’s very hard to convince people
to switch if you only offer 70% or 80% compatibility, no matter how much faster
your offering is. And getting to even that level of compatibility seems to be
well over a year of effort on its own. Not to mention that even when you get to
90% compatibility, you still have
90% of the work
ahead of you.
Imagine the situation where you’re building a TypeScript reimplementation from
scratch, with nary an end in sight, and no users. And while you’re working on
it, the TypeScript team keeps churning out new versions and your target keeps
slipping away again. I don’t think anyone can fault the
stc developers for
giving up on their project, or the Ezno developers for not making fast enough
Where Biome is different is that they intentionally don’t aim to make a reimplementation of the TypeScript compiler. For them, 70% compatibility on type inference alone would be enough to offer valuable type-informed lint rules. Assuming they get there, they will also be likely to continue to improve. And maybe more importantly, because they’re already offering value to users, the developers will be more motivated to keep up the work.
And meanwhile, almost as a side-effect of building increasingly good type inference, the team will be building the foundation on which a true type checker could be built. It may take years to get there, maybe they’ll never get there. So maybe this is all just hopeful thinking on my part. But it is indeed my hope that one day we may actually see a TypeScript reimplementation written in Rust. And I suspect that Biome may be the most promising route to get there.
Of course there’s still plenty of challenges ahead before Biome’s type inference
becomes good enough that it could power a true type checker with sufficient
compatibility that users can use at a replacement. First they’ll need
.d.ts files, NPM compatibility, various module resolution
modes, and plenty of non-trivial stuff. Is it feasible? Other challenges I
hadn’t thought of? Or do you have suggestions that might help the Biome project?