A way to enforce `composite`'s rules without using `incremental`

🔍 Search Terms

composite
incremental
composite without incremental
turborepo caching

✅ Viability Checklist

• 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, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

Sometimes when debugging performance issues with badly specified includess globs, the composite flag can be really helpful because it will enumerate all the code that you are referencing and need to put in the includes, and then you can add paths incrementally instead of just having something like **/*.ts.

There are some reasons why I'm a little bit uneasy about enabling composite and incremental, mainly that we use Turborepo to cache package builds, and I'm a little bit worried about having two different caching mechanisms.

You can see this issue:

• https://github.com/woocommerce/woocommerce/pull/37374

To get an idea of why it can be a problem.

Similar to how --isolatedDeclarations enforces certain rules without actually affecting build output, it'd be nice if there was a way to use composite's rules without being forced to set incremental too.

📃 Motivating Example

Maybe something like:

--enforceCompositeRules

💻 Use Cases

Right now there's no real workaround, composite and incremental have to go together. You can have incremental without composite but you run the risk of having caching bugs.

In CI one could probably just run a typecheck with the flags turned on manually I suppose, and not use it in other contexts

Commencez par retracer comment les options des compilateurs composite et incremental sont validées et où les règles de composite sont appliquées. Comparez ce comportement à celui de isolatedDeclarations, puis déterminez la sémantique d’option nécessaire pour appliquer les règles de composite sans activer incremental. Le travail est considéré comme terminé lorsque le flag proposé fonctionne dans CI et n’introduit pas les problèmes de mise en cache décrits dans l’issue.