Support Typescript incremental build

🚀 Feature request

- [ ] new
- [x] build
- [x] serve
- [x] test
- [x] e2e
- [ ] generate
- [ ] add
- [ ] update
- [ ] lint
- [ ] xi18n
- [ ] run
- [ ] config
- [ ] help
- [ ] version
- [ ] doc

Description

Support of Typescript incremental build https://devblogs.microsoft.com/typescript/announcing-typescript-3-4-rc/

[alan-agius4]

Transfering to the FW repo as the compiler doesn’t support TypeScript incremental API.

Example it uses ts.createProgram, instead of ts.createIncrementalProgram with the latter is require to use the tsbuild info.

I did experiment a bit using the NGTSC plugin API with allows for a program to be supplied and patching on a small project https://github.com/ngrx/platform/tree/master/modules/component/src I saw the compilation to go from 5s to 2.5s.

const host = ts.createIncrementalCompilerHost(compilerOptions);
const wrappedHost = ngtsc.wrapHost(host, config.rootNames, compilerOptions)

const program = ts.createIncrementalProgram({
  options: compilerOptions,
  rootNames: config.rootNames,
  host: wrappedHost,
  createProgram: ts.createEmitAndSemanticDiagnosticsBuilderProgram
})

const { ignoreForEmit } = ngtsc.setupCompilation(program.getProgram(), undefined);

NB: NGTSC would also need to set versions to typechecking source files.

[filipesilva]

I should set expectations regarding the potential usefulness of supporting TS’s --incremental functionality right now. As a recap, this functionality from TS allows a typescript compilation to reuse artifacts from a previous compilation in order to be faster. This doesn’t apply to watch mode. It only applies to whole new compilations (e.g. calling the command from the console again).

In an Angular CLI context this would mean that some calls to ng build, ng serve and ng test might be faster after the first call. Ideally you’d want your slowest builds, usually the production builds, to get faster by using this new typescript functionality. But there are a lot of caveats here.

First and foremost is that the typescript compilation is only one part of building an app, and not necessarily what takes longer. Then there’s the fact that AOT compilation is not just a Typescript compilation, there’s many other things happening there that have nothing to do with compiling TS. Another thing to take into consideration is that CI builds wouldn’t use this either unless you were very careful in managing the TS cache.

Realistically, this means that production builds wouldn’t see any improvement because they use AOT and a big chunk of the time is spent in bundle optimization. JIT development builds are what would benefit from TS’s --incremental functionality. But with Ivy it’s already preferable to develop in AOT, so no benefit again.

I feel this feature looks very desirable because it sounds like it would make all builds much faster. But the reality is that it would make some of the faster builds a bit faster, while the others would remain the same. Notably rebuilds on watch mode are entirely unaffected, because this functionality isn’t related to watch mode.