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

Chưa có ai nhận issue này.

### 🔍 Search Terms

composite
incremental
composite without incremental
turborepo caching

### ✅ Viability Checklist

- [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
- [x] This wouldn't change the runtime behavior of existing JavaScript code
- [x] This could be implemented without emitting different JS based on the types of the expressions
- [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
- [x] This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
- [x] 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 `includes`s 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 `include`s, 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

Bắt đầu bằng cách truy vết cách các tùy chọn của trình biên dịch composite và incremental được xác thực, cũng như nơi các quy tắc composite được thực thi. So sánh hành vi đó với isolatedDeclarations, sau đó xác định ngữ nghĩa tùy chọn cần thiết để thực thi các quy tắc composite mà không bật incremental. Công việc được xem là hoàn tất khi flag được đề xuất hoạt động trong CI và không đưa vào các vấn đề về caching được mô tả trong issue.

Do mô hình lập chỉ mục viết ra từ nội dung của issue.