@angular/core 13.0.0-next.7 → 13.0.0-rc.1

package/esm2020/testing/src/r3_test_bed_compiler.mjs

@@ -0,0 +1,735 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ResourceLoader } from '@angular/compiler';
+import { ApplicationInitStatus, Compiler, COMPILER_OPTIONS, LOCALE_ID, ModuleWithComponentFactories, NgZone, resolveForwardRef, ɵcompileComponent as compileComponent, ɵcompileDirective as compileDirective, ɵcompileNgModuleDefs as compileNgModuleDefs, ɵcompilePipe as compilePipe, ɵDEFAULT_LOCALE_ID as DEFAULT_LOCALE_ID, ɵgetInjectableDef as getInjectableDef, ɵNG_COMP_DEF as NG_COMP_DEF, ɵNG_DIR_DEF as NG_DIR_DEF, ɵNG_INJ_DEF as NG_INJ_DEF, ɵNG_MOD_DEF as NG_MOD_DEF, ɵNG_PIPE_DEF as NG_PIPE_DEF, ɵNgModuleFactory as R3NgModuleFactory, ɵpatchComponentDefWithScope as patchComponentDefWithScope, ɵRender3ComponentFactory as ComponentFactory, ɵRender3NgModuleRef as NgModuleRef, ɵsetLocaleId as setLocaleId, ɵtransitiveScopesFor as transitiveScopesFor } from '@angular/core';
+import { clearResolutionOfComponentResourcesQueue, isComponentDefPendingResolution, resolveComponentResources, restoreComponentResolutionQueue } from '../../src/metadata/resource_loading';
+import { ComponentResolver, DirectiveResolver, NgModuleResolver, PipeResolver } from './resolvers';
+var TestingModuleOverride;
+(function (TestingModuleOverride) {
+    TestingModuleOverride[TestingModuleOverride["DECLARATION"] = 0] = "DECLARATION";
+    TestingModuleOverride[TestingModuleOverride["OVERRIDE_TEMPLATE"] = 1] = "OVERRIDE_TEMPLATE";
+})(TestingModuleOverride || (TestingModuleOverride = {}));
+function isTestingModuleOverride(value) {
+    return value === TestingModuleOverride.DECLARATION ||
+        value === TestingModuleOverride.OVERRIDE_TEMPLATE;
+}
+export class R3TestBedCompiler {
+    constructor(platform, additionalModuleTypes) {
+        this.platform = platform;
+        this.additionalModuleTypes = additionalModuleTypes;
+        this.originalComponentResolutionQueue = null;
+        // Testing module configuration
+        this.declarations = [];
+        this.imports = [];
+        this.providers = [];
+        this.schemas = [];
+        // Queues of components/directives/pipes that should be recompiled.
+        this.pendingComponents = new Set();
+        this.pendingDirectives = new Set();
+        this.pendingPipes = new Set();
+        // Keep track of all components and directives, so we can patch Providers onto defs later.
+        this.seenComponents = new Set();
+        this.seenDirectives = new Set();
+        // Keep track of overridden modules, so that we can collect all affected ones in the module tree.
+        this.overriddenModules = new Set();
+        // Store resolved styles for Components that have template overrides present and `styleUrls`
+        // defined at the same time.
+        this.existingComponentStyles = new Map();
+        this.resolvers = initResolvers();
+        this.componentToModuleScope = new Map();
+        // Map that keeps initial version of component/directive/pipe defs in case
+        // we compile a Type again, thus overriding respective static fields. This is
+        // required to make sure we restore defs to their initial states between test runs
+        // TODO: we should support the case with multiple defs on a type
+        this.initialNgDefs = new Map();
+        // Array that keeps cleanup operations for initial versions of component/directive/pipe/module
+        // defs in case TestBed makes changes to the originals.
+        this.defCleanupOps = [];
+        this._injector = null;
+        this.compilerProviders = null;
+        this.providerOverrides = [];
+        this.rootProviderOverrides = [];
+        // Overrides for injectables with `{providedIn: SomeModule}` need to be tracked and added to that
+        // module's provider list.
+        this.providerOverridesByModule = new Map();
+        this.providerOverridesByToken = new Map();
+        this.moduleProvidersOverridden = new Set();
+        this.testModuleRef = null;
+        class DynamicTestModule {
+        }
+        this.testModuleType = DynamicTestModule;
+    }
+    setCompilerProviders(providers) {
+        this.compilerProviders = providers;
+        this._injector = null;
+    }
+    configureTestingModule(moduleDef) {
+        // Enqueue any compilation tasks for the directly declared component.
+        if (moduleDef.declarations !== undefined) {
+            this.queueTypeArray(moduleDef.declarations, TestingModuleOverride.DECLARATION);
+            this.declarations.push(...moduleDef.declarations);
+        }
+        // Enqueue any compilation tasks for imported modules.
+        if (moduleDef.imports !== undefined) {
+            this.queueTypesFromModulesArray(moduleDef.imports);
+            this.imports.push(...moduleDef.imports);
+        }
+        if (moduleDef.providers !== undefined) {
+            this.providers.push(...moduleDef.providers);
+        }
+        if (moduleDef.schemas !== undefined) {
+            this.schemas.push(...moduleDef.schemas);
+        }
+    }
+    overrideModule(ngModule, override) {
+        this.overriddenModules.add(ngModule);
+        // Compile the module right away.
+        this.resolvers.module.addOverride(ngModule, override);
+        const metadata = this.resolvers.module.resolve(ngModule);
+        if (metadata === null) {
+            throw invalidTypeError(ngModule.name, 'NgModule');
+        }
+        this.recompileNgModule(ngModule, metadata);
+        // At this point, the module has a valid module def (ɵmod), but the override may have introduced
+        // new declarations or imported modules. Ingest any possible new types and add them to the
+        // current queue.
+        this.queueTypesFromModulesArray([ngModule]);
+    }
+    overrideComponent(component, override) {
+        this.resolvers.component.addOverride(component, override);
+        this.pendingComponents.add(component);
+    }
+    overrideDirective(directive, override) {
+        this.resolvers.directive.addOverride(directive, override);
+        this.pendingDirectives.add(directive);
+    }
+    overridePipe(pipe, override) {
+        this.resolvers.pipe.addOverride(pipe, override);
+        this.pendingPipes.add(pipe);
+    }
+    overrideProvider(token, provider) {
+        let providerDef;
+        if (provider.useFactory !== undefined) {
+            providerDef = {
+                provide: token,
+                useFactory: provider.useFactory,
+                deps: provider.deps || [],
+                multi: provider.multi
+            };
+        }
+        else if (provider.useValue !== undefined) {
+            providerDef = { provide: token, useValue: provider.useValue, multi: provider.multi };
+        }
+        else {
+            providerDef = { provide: token };
+        }
+        const injectableDef = typeof token !== 'string' ? getInjectableDef(token) : null;
+        const providedIn = injectableDef === null ? null : resolveForwardRef(injectableDef.providedIn);
+        const overridesBucket = providedIn === 'root' ? this.rootProviderOverrides : this.providerOverrides;
+        overridesBucket.push(providerDef);
+        // Keep overrides grouped by token as well for fast lookups using token
+        this.providerOverridesByToken.set(token, providerDef);
+        if (injectableDef !== null && providedIn !== null && typeof providedIn !== 'string') {
+            const existingOverrides = this.providerOverridesByModule.get(providedIn);
+            if (existingOverrides !== undefined) {
+                existingOverrides.push(providerDef);
+            }
+            else {
+                this.providerOverridesByModule.set(providedIn, [providerDef]);
+            }
+        }
+    }
+    overrideTemplateUsingTestingModule(type, template) {
+        const def = type[NG_COMP_DEF];
+        const hasStyleUrls = () => {
+            const metadata = this.resolvers.component.resolve(type);
+            return !!metadata.styleUrls && metadata.styleUrls.length > 0;
+        };
+        const overrideStyleUrls = !!def && !isComponentDefPendingResolution(type) && hasStyleUrls();
+        // In Ivy, compiling a component does not require knowing the module providing the
+        // component's scope, so overrideTemplateUsingTestingModule can be implemented purely via
+        // overrideComponent. Important: overriding template requires full Component re-compilation,
+        // which may fail in case styleUrls are also present (thus Component is considered as required
+        // resolution). In order to avoid this, we preemptively set styleUrls to an empty array,
+        // preserve current styles available on Component def and restore styles back once compilation
+        // is complete.
+        const override = overrideStyleUrls ? { template, styles: [], styleUrls: [] } : { template };
+        this.overrideComponent(type, { set: override });
+        if (overrideStyleUrls && def.styles && def.styles.length > 0) {
+            this.existingComponentStyles.set(type, def.styles);
+        }
+        // Set the component's scope to be the testing module.
+        this.componentToModuleScope.set(type, TestingModuleOverride.OVERRIDE_TEMPLATE);
+    }
+    async compileComponents() {
+        this.clearComponentResolutionQueue();
+        // Run compilers for all queued types.
+        let needsAsyncResources = this.compileTypesSync();
+        // compileComponents() should not be async unless it needs to be.
+        if (needsAsyncResources) {
+            let resourceLoader;
+            let resolver = (url) => {
+                if (!resourceLoader) {
+                    resourceLoader = this.injector.get(ResourceLoader);
+                }
+                return Promise.resolve(resourceLoader.get(url));
+            };
+            await resolveComponentResources(resolver);
+        }
+    }
+    finalize() {
+        // One last compile
+        this.compileTypesSync();
+        // Create the testing module itself.
+        this.compileTestModule();
+        this.applyTransitiveScopes();
+        this.applyProviderOverrides();
+        // Patch previously stored `styles` Component values (taken from ɵcmp), in case these
+        // Components have `styleUrls` fields defined and template override was requested.
+        this.patchComponentsWithExistingStyles();
+        // Clear the componentToModuleScope map, so that future compilations don't reset the scope of
+        // every component.
+        this.componentToModuleScope.clear();
+        const parentInjector = this.platform.injector;
+        this.testModuleRef = new NgModuleRef(this.testModuleType, parentInjector);
+        // ApplicationInitStatus.runInitializers() is marked @internal to core.
+        // Cast it to any before accessing it.
+        this.testModuleRef.injector.get(ApplicationInitStatus).runInitializers();
+        // Set locale ID after running app initializers, since locale information might be updated while
+        // running initializers. This is also consistent with the execution order while bootstrapping an
+        // app (see `packages/core/src/application_ref.ts` file).
+        const localeId = this.testModuleRef.injector.get(LOCALE_ID, DEFAULT_LOCALE_ID);
+        setLocaleId(localeId);
+        return this.testModuleRef;
+    }
+    /**
+     * @internal
+     */
+    _compileNgModuleSync(moduleType) {
+        this.queueTypesFromModulesArray([moduleType]);
+        this.compileTypesSync();
+        this.applyProviderOverrides();
+        this.applyProviderOverridesToModule(moduleType);
+        this.applyTransitiveScopes();
+    }
+    /**
+     * @internal
+     */
+    async _compileNgModuleAsync(moduleType) {
+        this.queueTypesFromModulesArray([moduleType]);
+        await this.compileComponents();
+        this.applyProviderOverrides();
+        this.applyProviderOverridesToModule(moduleType);
+        this.applyTransitiveScopes();
+    }
+    /**
+     * @internal
+     */
+    _getModuleResolver() {
+        return this.resolvers.module;
+    }
+    /**
+     * @internal
+     */
+    _getComponentFactories(moduleType) {
+        return maybeUnwrapFn(moduleType.ɵmod.declarations).reduce((factories, declaration) => {
+            const componentDef = declaration.ɵcmp;
+            componentDef && factories.push(new ComponentFactory(componentDef, this.testModuleRef));
+            return factories;
+        }, []);
+    }
+    compileTypesSync() {
+        // Compile all queued components, directives, pipes.
+        let needsAsyncResources = false;
+        this.pendingComponents.forEach(declaration => {
+            needsAsyncResources = needsAsyncResources || isComponentDefPendingResolution(declaration);
+            const metadata = this.resolvers.component.resolve(declaration);
+            if (metadata === null) {
+                throw invalidTypeError(declaration.name, 'Component');
+            }
+            this.maybeStoreNgDef(NG_COMP_DEF, declaration);
+            compileComponent(declaration, metadata);
+        });
+        this.pendingComponents.clear();
+        this.pendingDirectives.forEach(declaration => {
+            const metadata = this.resolvers.directive.resolve(declaration);
+            if (metadata === null) {
+                throw invalidTypeError(declaration.name, 'Directive');
+            }
+            this.maybeStoreNgDef(NG_DIR_DEF, declaration);
+            compileDirective(declaration, metadata);
+        });
+        this.pendingDirectives.clear();
+        this.pendingPipes.forEach(declaration => {
+            const metadata = this.resolvers.pipe.resolve(declaration);
+            if (metadata === null) {
+                throw invalidTypeError(declaration.name, 'Pipe');
+            }
+            this.maybeStoreNgDef(NG_PIPE_DEF, declaration);
+            compilePipe(declaration, metadata);
+        });
+        this.pendingPipes.clear();
+        return needsAsyncResources;
+    }
+    applyTransitiveScopes() {
+        if (this.overriddenModules.size > 0) {
+            // Module overrides (via `TestBed.overrideModule`) might affect scopes that were previously
+            // calculated and stored in `transitiveCompileScopes`. If module overrides are present,
+            // collect all affected modules and reset scopes to force their re-calculation.
+            const testingModuleDef = this.testModuleType[NG_MOD_DEF];
+            const affectedModules = this.collectModulesAffectedByOverrides(testingModuleDef.imports);
+            if (affectedModules.size > 0) {
+                affectedModules.forEach(moduleType => {
+                    this.storeFieldOfDefOnType(moduleType, NG_MOD_DEF, 'transitiveCompileScopes');
+                    moduleType[NG_MOD_DEF].transitiveCompileScopes = null;
+                });
+            }
+        }
+        const moduleToScope = new Map();
+        const getScopeOfModule = (moduleType) => {
+            if (!moduleToScope.has(moduleType)) {
+                const isTestingModule = isTestingModuleOverride(moduleType);
+                const realType = isTestingModule ? this.testModuleType : moduleType;
+                moduleToScope.set(moduleType, transitiveScopesFor(realType));
+            }
+            return moduleToScope.get(moduleType);
+        };
+        this.componentToModuleScope.forEach((moduleType, componentType) => {
+            const moduleScope = getScopeOfModule(moduleType);
+            this.storeFieldOfDefOnType(componentType, NG_COMP_DEF, 'directiveDefs');
+            this.storeFieldOfDefOnType(componentType, NG_COMP_DEF, 'pipeDefs');
+            // `tView` that is stored on component def contains information about directives and pipes
+            // that are in the scope of this component. Patching component scope will cause `tView` to be
+            // changed. Store original `tView` before patching scope, so the `tView` (including scope
+            // information) is restored back to its previous/original state before running next test.
+            this.storeFieldOfDefOnType(componentType, NG_COMP_DEF, 'tView');
+            patchComponentDefWithScope(componentType.ɵcmp, moduleScope);
+        });
+        this.componentToModuleScope.clear();
+    }
+    applyProviderOverrides() {
+        const maybeApplyOverrides = (field) => (type) => {
+            const resolver = field === NG_COMP_DEF ? this.resolvers.component : this.resolvers.directive;
+            const metadata = resolver.resolve(type);
+            if (this.hasProviderOverrides(metadata.providers)) {
+                this.patchDefWithProviderOverrides(type, field);
+            }
+        };
+        this.seenComponents.forEach(maybeApplyOverrides(NG_COMP_DEF));
+        this.seenDirectives.forEach(maybeApplyOverrides(NG_DIR_DEF));
+        this.seenComponents.clear();
+        this.seenDirectives.clear();
+    }
+    applyProviderOverridesToModule(moduleType) {
+        if (this.moduleProvidersOverridden.has(moduleType)) {
+            return;
+        }
+        this.moduleProvidersOverridden.add(moduleType);
+        const injectorDef = moduleType[NG_INJ_DEF];
+        if (this.providerOverridesByToken.size > 0) {
+            const providers = [
+                ...injectorDef.providers,
+                ...(this.providerOverridesByModule.get(moduleType) || [])
+            ];
+            if (this.hasProviderOverrides(providers)) {
+                this.maybeStoreNgDef(NG_INJ_DEF, moduleType);
+                this.storeFieldOfDefOnType(moduleType, NG_INJ_DEF, 'providers');
+                injectorDef.providers = this.getOverriddenProviders(providers);
+            }
+            // Apply provider overrides to imported modules recursively
+            const moduleDef = moduleType[NG_MOD_DEF];
+            const imports = maybeUnwrapFn(moduleDef.imports);
+            for (const importedModule of imports) {
+                this.applyProviderOverridesToModule(importedModule);
+            }
+            // Also override the providers on any ModuleWithProviders imports since those don't appear in
+            // the moduleDef.
+            for (const importedModule of flatten(injectorDef.imports)) {
+                if (isModuleWithProviders(importedModule)) {
+                    this.defCleanupOps.push({
+                        object: importedModule,
+                        fieldName: 'providers',
+                        originalValue: importedModule.providers
+                    });
+                    importedModule.providers = this.getOverriddenProviders(importedModule.providers);
+                }
+            }
+        }
+    }
+    patchComponentsWithExistingStyles() {
+        this.existingComponentStyles.forEach((styles, type) => type[NG_COMP_DEF].styles = styles);
+        this.existingComponentStyles.clear();
+    }
+    queueTypeArray(arr, moduleType) {
+        for (const value of arr) {
+            if (Array.isArray(value)) {
+                this.queueTypeArray(value, moduleType);
+            }
+            else {
+                this.queueType(value, moduleType);
+            }
+        }
+    }
+    recompileNgModule(ngModule, metadata) {
+        // Cache the initial ngModuleDef as it will be overwritten.
+        this.maybeStoreNgDef(NG_MOD_DEF, ngModule);
+        this.maybeStoreNgDef(NG_INJ_DEF, ngModule);
+        compileNgModuleDefs(ngModule, metadata);
+    }
+    queueType(type, moduleType) {
+        const component = this.resolvers.component.resolve(type);
+        if (component) {
+            // Check whether a give Type has respective NG def (ɵcmp) and compile if def is
+            // missing. That might happen in case a class without any Angular decorators extends another
+            // class where Component/Directive/Pipe decorator is defined.
+            if (isComponentDefPendingResolution(type) || !type.hasOwnProperty(NG_COMP_DEF)) {
+                this.pendingComponents.add(type);
+            }
+            this.seenComponents.add(type);
+            // Keep track of the module which declares this component, so later the component's scope
+            // can be set correctly. If the component has already been recorded here, then one of several
+            // cases is true:
+            // * the module containing the component was imported multiple times (common).
+            // * the component is declared in multiple modules (which is an error).
+            // * the component was in 'declarations' of the testing module, and also in an imported module
+            //   in which case the module scope will be TestingModuleOverride.DECLARATION.
+            // * overrideTemplateUsingTestingModule was called for the component in which case the module
+            //   scope will be TestingModuleOverride.OVERRIDE_TEMPLATE.
+            //
+            // If the component was previously in the testing module's 'declarations' (meaning the
+            // current value is TestingModuleOverride.DECLARATION), then `moduleType` is the component's
+            // real module, which was imported. This pattern is understood to mean that the component
+            // should use its original scope, but that the testing module should also contain the
+            // component in its scope.
+            if (!this.componentToModuleScope.has(type) ||
+                this.componentToModuleScope.get(type) === TestingModuleOverride.DECLARATION) {
+                this.componentToModuleScope.set(type, moduleType);
+            }
+            return;
+        }
+        const directive = this.resolvers.directive.resolve(type);
+        if (directive) {
+            if (!type.hasOwnProperty(NG_DIR_DEF)) {
+                this.pendingDirectives.add(type);
+            }
+            this.seenDirectives.add(type);
+            return;
+        }
+        const pipe = this.resolvers.pipe.resolve(type);
+        if (pipe && !type.hasOwnProperty(NG_PIPE_DEF)) {
+            this.pendingPipes.add(type);
+            return;
+        }
+    }
+    queueTypesFromModulesArray(arr) {
+        // Because we may encounter the same NgModule while processing the imports and exports of an
+        // NgModule tree, we cache them in this set so we can skip ones that have already been seen
+        // encountered. In some test setups, this caching resulted in 10X runtime improvement.
+        const processedNgModuleDefs = new Set();
+        const queueTypesFromModulesArrayRecur = (arr) => {
+            for (const value of arr) {
+                if (Array.isArray(value)) {
+                    queueTypesFromModulesArrayRecur(value);
+                }
+                else if (hasNgModuleDef(value)) {
+                    const def = value.ɵmod;
+                    if (processedNgModuleDefs.has(def)) {
+                        continue;
+                    }
+                    processedNgModuleDefs.add(def);
+                    // Look through declarations, imports, and exports, and queue
+                    // everything found there.
+                    this.queueTypeArray(maybeUnwrapFn(def.declarations), value);
+                    queueTypesFromModulesArrayRecur(maybeUnwrapFn(def.imports));
+                    queueTypesFromModulesArrayRecur(maybeUnwrapFn(def.exports));
+                }
+                else if (isModuleWithProviders(value)) {
+                    queueTypesFromModulesArrayRecur([value.ngModule]);
+                }
+            }
+        };
+        queueTypesFromModulesArrayRecur(arr);
+    }
+    // When module overrides (via `TestBed.overrideModule`) are present, it might affect all modules
+    // that import (even transitively) an overridden one. For all affected modules we need to
+    // recalculate their scopes for a given test run and restore original scopes at the end. The goal
+    // of this function is to collect all affected modules in a set for further processing. Example:
+    // if we have the following module hierarchy: A -> B -> C (where `->` means `imports`) and module
+    // `C` is overridden, we consider `A` and `B` as affected, since their scopes might become
+    // invalidated with the override.
+    collectModulesAffectedByOverrides(arr) {
+        const seenModules = new Set();
+        const affectedModules = new Set();
+        const calcAffectedModulesRecur = (arr, path) => {
+            for (const value of arr) {
+                if (Array.isArray(value)) {
+                    // If the value is an array, just flatten it (by invoking this function recursively),
+                    // keeping "path" the same.
+                    calcAffectedModulesRecur(value, path);
+                }
+                else if (hasNgModuleDef(value)) {
+                    if (seenModules.has(value)) {
+                        // If we've seen this module before and it's included into "affected modules" list, mark
+                        // the whole path that leads to that module as affected, but do not descend into its
+                        // imports, since we already examined them before.
+                        if (affectedModules.has(value)) {
+                            path.forEach(item => affectedModules.add(item));
+                        }
+                        continue;
+                    }
+                    seenModules.add(value);
+                    if (this.overriddenModules.has(value)) {
+                        path.forEach(item => affectedModules.add(item));
+                    }
+                    // Examine module imports recursively to look for overridden modules.
+                    const moduleDef = value[NG_MOD_DEF];
+                    calcAffectedModulesRecur(maybeUnwrapFn(moduleDef.imports), path.concat(value));
+                }
+            }
+        };
+        calcAffectedModulesRecur(arr, []);
+        return affectedModules;
+    }
+    maybeStoreNgDef(prop, type) {
+        if (!this.initialNgDefs.has(type)) {
+            const currentDef = Object.getOwnPropertyDescriptor(type, prop);
+            this.initialNgDefs.set(type, [prop, currentDef]);
+        }
+    }
+    storeFieldOfDefOnType(type, defField, fieldName) {
+        const def = type[defField];
+        const originalValue = def[fieldName];
+        this.defCleanupOps.push({ object: def, fieldName, originalValue });
+    }
+    /**
+     * Clears current components resolution queue, but stores the state of the queue, so we can
+     * restore it later. Clearing the queue is required before we try to compile components (via
+     * `TestBed.compileComponents`), so that component defs are in sync with the resolution queue.
+     */
+    clearComponentResolutionQueue() {
+        if (this.originalComponentResolutionQueue === null) {
+            this.originalComponentResolutionQueue = new Map();
+        }
+        clearResolutionOfComponentResourcesQueue().forEach((value, key) => this.originalComponentResolutionQueue.set(key, value));
+    }
+    /*
+     * Restores component resolution queue to the previously saved state. This operation is performed
+     * as a part of restoring the state after completion of the current set of tests (that might
+     * potentially mutate the state).
+     */
+    restoreComponentResolutionQueue() {
+        if (this.originalComponentResolutionQueue !== null) {
+            restoreComponentResolutionQueue(this.originalComponentResolutionQueue);
+            this.originalComponentResolutionQueue = null;
+        }
+    }
+    restoreOriginalState() {
+        // Process cleanup ops in reverse order so the field's original value is restored correctly (in
+        // case there were multiple overrides for the same field).
+        forEachRight(this.defCleanupOps, (op) => {
+            op.object[op.fieldName] = op.originalValue;
+        });
+        // Restore initial component/directive/pipe defs
+        this.initialNgDefs.forEach((value, type) => {
+            const [prop, descriptor] = value;
+            if (!descriptor) {
+                // Delete operations are generally undesirable since they have performance implications
+                // on objects they were applied to. In this particular case, situations where this code
+                // is invoked should be quite rare to cause any noticeable impact, since it's applied
+                // only to some test cases (for example when class with no annotations extends some
+                // @Component) when we need to clear 'ɵcmp' field on a given class to restore
+                // its original state (before applying overrides and running tests).
+                delete type[prop];
+            }
+            else {
+                Object.defineProperty(type, prop, descriptor);
+            }
+        });
+        this.initialNgDefs.clear();
+        this.moduleProvidersOverridden.clear();
+        this.restoreComponentResolutionQueue();
+        // Restore the locale ID to the default value, this shouldn't be necessary but we never know
+        setLocaleId(DEFAULT_LOCALE_ID);
+    }
+    compileTestModule() {
+        class RootScopeModule {
+        }
+        compileNgModuleDefs(RootScopeModule, {
+            providers: [...this.rootProviderOverrides],
+        });
+        const ngZone = new NgZone({ enableLongStackTrace: true });
+        const providers = [
+            { provide: NgZone, useValue: ngZone },
+            { provide: Compiler, useFactory: () => new R3TestCompiler(this) },
+            ...this.providers,
+            ...this.providerOverrides,
+        ];
+        const imports = [RootScopeModule, this.additionalModuleTypes, this.imports || []];
+        // clang-format off
+        compileNgModuleDefs(this.testModuleType, {
+            declarations: this.declarations,
+            imports,
+            schemas: this.schemas,
+            providers,
+        }, /* allowDuplicateDeclarationsInRoot */ true);
+        // clang-format on
+        this.applyProviderOverridesToModule(this.testModuleType);
+    }
+    get injector() {
+        if (this._injector !== null) {
+            return this._injector;
+        }
+        const providers = [];
+        const compilerOptions = this.platform.injector.get(COMPILER_OPTIONS);
+        compilerOptions.forEach(opts => {
+            if (opts.providers) {
+                providers.push(opts.providers);
+            }
+        });
+        if (this.compilerProviders !== null) {
+            providers.push(...this.compilerProviders);
+        }
+        // TODO(ocombe): make this work with an Injector directly instead of creating a module for it
+        class CompilerModule {
+        }
+        compileNgModuleDefs(CompilerModule, { providers });
+        const CompilerModuleFactory = new R3NgModuleFactory(CompilerModule);
+        this._injector = CompilerModuleFactory.create(this.platform.injector).injector;
+        return this._injector;
+    }
+    // get overrides for a specific provider (if any)
+    getSingleProviderOverrides(provider) {
+        const token = getProviderToken(provider);
+        return this.providerOverridesByToken.get(token) || null;
+    }
+    getProviderOverrides(providers) {
+        if (!providers || !providers.length || this.providerOverridesByToken.size === 0)
+            return [];
+        // There are two flattening operations here. The inner flatten() operates on the metadata's
+        // providers and applies a mapping function which retrieves overrides for each incoming
+        // provider. The outer flatten() then flattens the produced overrides array. If this is not
+        // done, the array can contain other empty arrays (e.g. `[[], []]`) which leak into the
+        // providers array and contaminate any error messages that might be generated.
+        return flatten(flatten(providers, (provider) => this.getSingleProviderOverrides(provider) || []));
+    }
+    getOverriddenProviders(providers) {
+        if (!providers || !providers.length || this.providerOverridesByToken.size === 0)
+            return [];
+        const flattenedProviders = flatten(providers);
+        const overrides = this.getProviderOverrides(flattenedProviders);
+        const overriddenProviders = [...flattenedProviders, ...overrides];
+        const final = [];
+        const seenOverriddenProviders = new Set();
+        // We iterate through the list of providers in reverse order to make sure provider overrides
+        // take precedence over the values defined in provider list. We also filter out all providers
+        // that have overrides, keeping overridden values only. This is needed, since presence of a
+        // provider with `ngOnDestroy` hook will cause this hook to be registered and invoked later.
+        forEachRight(overriddenProviders, (provider) => {
+            const token = getProviderToken(provider);
+            if (this.providerOverridesByToken.has(token)) {
+                if (!seenOverriddenProviders.has(token)) {
+                    seenOverriddenProviders.add(token);
+                    // Treat all overridden providers as `{multi: false}` (even if it's a multi-provider) to
+                    // make sure that provided override takes highest precedence and is not combined with
+                    // other instances of the same multi provider.
+                    final.unshift({ ...provider, multi: false });
+                }
+            }
+            else {
+                final.unshift(provider);
+            }
+        });
+        return final;
+    }
+    hasProviderOverrides(providers) {
+        return this.getProviderOverrides(providers).length > 0;
+    }
+    patchDefWithProviderOverrides(declaration, field) {
+        const def = declaration[field];
+        if (def && def.providersResolver) {
+            this.maybeStoreNgDef(field, declaration);
+            const resolver = def.providersResolver;
+            const processProvidersFn = (providers) => this.getOverriddenProviders(providers);
+            this.storeFieldOfDefOnType(declaration, field, 'providersResolver');
+            def.providersResolver = (ngDef) => resolver(ngDef, processProvidersFn);
+        }
+    }
+}
+function initResolvers() {
+    return {
+        module: new NgModuleResolver(),
+        component: new ComponentResolver(),
+        directive: new DirectiveResolver(),
+        pipe: new PipeResolver()
+    };
+}
+function hasNgModuleDef(value) {
+    return value.hasOwnProperty('ɵmod');
+}
+function maybeUnwrapFn(maybeFn) {
+    return maybeFn instanceof Function ? maybeFn() : maybeFn;
+}
+function flatten(values, mapFn) {
+    const out = [];
+    values.forEach(value => {
+        if (Array.isArray(value)) {
+            out.push(...flatten(value, mapFn));
+        }
+        else {
+            out.push(mapFn ? mapFn(value) : value);
+        }
+    });
+    return out;
+}
+function getProviderField(provider, field) {
+    return provider && typeof provider === 'object' && provider[field];
+}
+function getProviderToken(provider) {
+    return getProviderField(provider, 'provide') || provider;
+}
+function isModuleWithProviders(value) {
+    return value.hasOwnProperty('ngModule');
+}
+function forEachRight(values, fn) {
+    for (let idx = values.length - 1; idx >= 0; idx--) {
+        fn(values[idx], idx);
+    }
+}
+function invalidTypeError(name, expectedType) {
+    return new Error(`${name} class doesn't have @${expectedType} decorator or is missing metadata.`);
+}
+class R3TestCompiler {
+    constructor(testBed) {
+        this.testBed = testBed;
+    }
+    compileModuleSync(moduleType) {
+        this.testBed._compileNgModuleSync(moduleType);
+        return new R3NgModuleFactory(moduleType);
+    }
+    async compileModuleAsync(moduleType) {
+        await this.testBed._compileNgModuleAsync(moduleType);
+        return new R3NgModuleFactory(moduleType);
+    }
+    compileModuleAndAllComponentsSync(moduleType) {
+        const ngModuleFactory = this.compileModuleSync(moduleType);
+        const componentFactories = this.testBed._getComponentFactories(moduleType);
+        return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);
+    }
+    async compileModuleAndAllComponentsAsync(moduleType) {
+        const ngModuleFactory = await this.compileModuleAsync(moduleType);
+        const componentFactories = this.testBed._getComponentFactories(moduleType);
+        return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);
+    }
+    clearCache() { }
+    clearCacheFor(type) { }
+    getModuleId(moduleType) {
+        const meta = this.testBed._getModuleResolver().resolve(moduleType);
+        return meta && meta.id || undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"r3_test_bed_compiler.js","sourceRoot":"","sources":["../../../../../../../packages/core/testing/src/r3_test_bed_compiler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ResourceLoader} from '@angular/compiler';\nimport {ApplicationInitStatus, Compiler, COMPILER_OPTIONS, Component, Directive, Injector, InjectorType, LOCALE_ID, ModuleWithComponentFactories, ModuleWithProviders, NgModule, NgModuleFactory, NgZone, Pipe, PlatformRef, Provider, resolveForwardRef, Type, ɵcompileComponent as compileComponent, ɵcompileDirective as compileDirective, ɵcompileNgModuleDefs as compileNgModuleDefs, ɵcompilePipe as compilePipe, ɵDEFAULT_LOCALE_ID as DEFAULT_LOCALE_ID, ɵDirectiveDef as DirectiveDef, ɵgetInjectableDef as getInjectableDef, ɵNG_COMP_DEF as NG_COMP_DEF, ɵNG_DIR_DEF as NG_DIR_DEF, ɵNG_INJ_DEF as NG_INJ_DEF, ɵNG_MOD_DEF as NG_MOD_DEF, ɵNG_PIPE_DEF as NG_PIPE_DEF, ɵNgModuleFactory as R3NgModuleFactory, ɵNgModuleTransitiveScopes as NgModuleTransitiveScopes, ɵNgModuleType as NgModuleType, ɵpatchComponentDefWithScope as patchComponentDefWithScope, ɵRender3ComponentFactory as ComponentFactory, ɵRender3NgModuleRef as NgModuleRef, ɵsetLocaleId as setLocaleId, ɵtransitiveScopesFor as transitiveScopesFor, ɵɵInjectableDeclaration as InjectableDeclaration} from '@angular/core';\n\nimport {clearResolutionOfComponentResourcesQueue, isComponentDefPendingResolution, resolveComponentResources, restoreComponentResolutionQueue} from '../../src/metadata/resource_loading';\n\nimport {MetadataOverride} from './metadata_override';\nimport {ComponentResolver, DirectiveResolver, NgModuleResolver, PipeResolver, Resolver} from './resolvers';\nimport {TestModuleMetadata} from './test_bed_common';\n\nenum TestingModuleOverride {\n  DECLARATION,\n  OVERRIDE_TEMPLATE,\n}\n\nfunction isTestingModuleOverride(value: unknown): value is TestingModuleOverride {\n  return value === TestingModuleOverride.DECLARATION ||\n      value === TestingModuleOverride.OVERRIDE_TEMPLATE;\n}\n\n// Resolvers for Angular decorators\ntype Resolvers = {\n  module: Resolver<NgModule>,\n  component: Resolver<Directive>,\n  directive: Resolver<Component>,\n  pipe: Resolver<Pipe>,\n};\n\ninterface CleanupOperation {\n  fieldName: string;\n  object: any;\n  originalValue: unknown;\n}\n\nexport class R3TestBedCompiler {\n  private originalComponentResolutionQueue: Map<Type<any>, Component>|null = null;\n\n  // Testing module configuration\n  private declarations: Type<any>[] = [];\n  private imports: Type<any>[] = [];\n  private providers: Provider[] = [];\n  private schemas: any[] = [];\n\n  // Queues of components/directives/pipes that should be recompiled.\n  private pendingComponents = new Set<Type<any>>();\n  private pendingDirectives = new Set<Type<any>>();\n  private pendingPipes = new Set<Type<any>>();\n\n  // Keep track of all components and directives, so we can patch Providers onto defs later.\n  private seenComponents = new Set<Type<any>>();\n  private seenDirectives = new Set<Type<any>>();\n\n  // Keep track of overridden modules, so that we can collect all affected ones in the module tree.\n  private overriddenModules = new Set<NgModuleType<any>>();\n\n  // Store resolved styles for Components that have template overrides present and `styleUrls`\n  // defined at the same time.\n  private existingComponentStyles = new Map<Type<any>, string[]>();\n\n  private resolvers: Resolvers = initResolvers();\n\n  private componentToModuleScope = new Map<Type<any>, Type<any>|TestingModuleOverride>();\n\n  // Map that keeps initial version of component/directive/pipe defs in case\n  // we compile a Type again, thus overriding respective static fields. This is\n  // required to make sure we restore defs to their initial states between test runs\n  // TODO: we should support the case with multiple defs on a type\n  private initialNgDefs = new Map<Type<any>, [string, PropertyDescriptor|undefined]>();\n\n  // Array that keeps cleanup operations for initial versions of component/directive/pipe/module\n  // defs in case TestBed makes changes to the originals.\n  private defCleanupOps: CleanupOperation[] = [];\n\n  private _injector: Injector|null = null;\n  private compilerProviders: Provider[]|null = null;\n\n  private providerOverrides: Provider[] = [];\n  private rootProviderOverrides: Provider[] = [];\n  // Overrides for injectables with `{providedIn: SomeModule}` need to be tracked and added to that\n  // module's provider list.\n  private providerOverridesByModule = new Map<InjectorType<any>, Provider[]>();\n  private providerOverridesByToken = new Map<any, Provider>();\n  private moduleProvidersOverridden = new Set<Type<any>>();\n\n  private testModuleType: NgModuleType<any>;\n  private testModuleRef: NgModuleRef<any>|null = null;\n\n  constructor(private platform: PlatformRef, private additionalModuleTypes: Type<any>|Type<any>[]) {\n    class DynamicTestModule {}\n    this.testModuleType = DynamicTestModule as any;\n  }\n\n  setCompilerProviders(providers: Provider[]|null): void {\n    this.compilerProviders = providers;\n    this._injector = null;\n  }\n\n  configureTestingModule(moduleDef: TestModuleMetadata): void {\n    // Enqueue any compilation tasks for the directly declared component.\n    if (moduleDef.declarations !== undefined) {\n      this.queueTypeArray(moduleDef.declarations, TestingModuleOverride.DECLARATION);\n      this.declarations.push(...moduleDef.declarations);\n    }\n\n    // Enqueue any compilation tasks for imported modules.\n    if (moduleDef.imports !== undefined) {\n      this.queueTypesFromModulesArray(moduleDef.imports);\n      this.imports.push(...moduleDef.imports);\n    }\n\n    if (moduleDef.providers !== undefined) {\n      this.providers.push(...moduleDef.providers);\n    }\n\n    if (moduleDef.schemas !== undefined) {\n      this.schemas.push(...moduleDef.schemas);\n    }\n  }\n\n  overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): void {\n    this.overriddenModules.add(ngModule as NgModuleType<any>);\n\n    // Compile the module right away.\n    this.resolvers.module.addOverride(ngModule, override);\n    const metadata = this.resolvers.module.resolve(ngModule);\n    if (metadata === null) {\n      throw invalidTypeError(ngModule.name, 'NgModule');\n    }\n\n    this.recompileNgModule(ngModule, metadata);\n\n    // At this point, the module has a valid module def (ɵmod), but the override may have introduced\n    // new declarations or imported modules. Ingest any possible new types and add them to the\n    // current queue.\n    this.queueTypesFromModulesArray([ngModule]);\n  }\n\n  overrideComponent(component: Type<any>, override: MetadataOverride<Component>): void {\n    this.resolvers.component.addOverride(component, override);\n    this.pendingComponents.add(component);\n  }\n\n  overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): void {\n    this.resolvers.directive.addOverride(directive, override);\n    this.pendingDirectives.add(directive);\n  }\n\n  overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): void {\n    this.resolvers.pipe.addOverride(pipe, override);\n    this.pendingPipes.add(pipe);\n  }\n\n  overrideProvider(\n      token: any,\n      provider: {useFactory?: Function, useValue?: any, deps?: any[], multi?: boolean}): void {\n    let providerDef: Provider;\n    if (provider.useFactory !== undefined) {\n      providerDef = {\n        provide: token,\n        useFactory: provider.useFactory,\n        deps: provider.deps || [],\n        multi: provider.multi\n      };\n    } else if (provider.useValue !== undefined) {\n      providerDef = {provide: token, useValue: provider.useValue, multi: provider.multi};\n    } else {\n      providerDef = {provide: token};\n    }\n\n    const injectableDef: InjectableDeclaration<any>|null =\n        typeof token !== 'string' ? getInjectableDef(token) : null;\n    const providedIn = injectableDef === null ? null : resolveForwardRef(injectableDef.providedIn);\n    const overridesBucket =\n        providedIn === 'root' ? this.rootProviderOverrides : this.providerOverrides;\n    overridesBucket.push(providerDef);\n\n    // Keep overrides grouped by token as well for fast lookups using token\n    this.providerOverridesByToken.set(token, providerDef);\n    if (injectableDef !== null && providedIn !== null && typeof providedIn !== 'string') {\n      const existingOverrides = this.providerOverridesByModule.get(providedIn);\n      if (existingOverrides !== undefined) {\n        existingOverrides.push(providerDef);\n      } else {\n        this.providerOverridesByModule.set(providedIn, [providerDef]);\n      }\n    }\n  }\n\n  overrideTemplateUsingTestingModule(type: Type<any>, template: string): void {\n    const def = (type as any)[NG_COMP_DEF];\n    const hasStyleUrls = (): boolean => {\n      const metadata = this.resolvers.component.resolve(type)! as Component;\n      return !!metadata.styleUrls && metadata.styleUrls.length > 0;\n    };\n    const overrideStyleUrls = !!def && !isComponentDefPendingResolution(type) && hasStyleUrls();\n\n    // In Ivy, compiling a component does not require knowing the module providing the\n    // component's scope, so overrideTemplateUsingTestingModule can be implemented purely via\n    // overrideComponent. Important: overriding template requires full Component re-compilation,\n    // which may fail in case styleUrls are also present (thus Component is considered as required\n    // resolution). In order to avoid this, we preemptively set styleUrls to an empty array,\n    // preserve current styles available on Component def and restore styles back once compilation\n    // is complete.\n    const override = overrideStyleUrls ? {template, styles: [], styleUrls: []} : {template};\n    this.overrideComponent(type, {set: override});\n\n    if (overrideStyleUrls && def.styles && def.styles.length > 0) {\n      this.existingComponentStyles.set(type, def.styles);\n    }\n\n    // Set the component's scope to be the testing module.\n    this.componentToModuleScope.set(type, TestingModuleOverride.OVERRIDE_TEMPLATE);\n  }\n\n  async compileComponents(): Promise<void> {\n    this.clearComponentResolutionQueue();\n    // Run compilers for all queued types.\n    let needsAsyncResources = this.compileTypesSync();\n\n    // compileComponents() should not be async unless it needs to be.\n    if (needsAsyncResources) {\n      let resourceLoader: ResourceLoader;\n      let resolver = (url: string): Promise<string> => {\n        if (!resourceLoader) {\n          resourceLoader = this.injector.get(ResourceLoader);\n        }\n        return Promise.resolve(resourceLoader.get(url));\n      };\n      await resolveComponentResources(resolver);\n    }\n  }\n\n  finalize(): NgModuleRef<any> {\n    // One last compile\n    this.compileTypesSync();\n\n    // Create the testing module itself.\n    this.compileTestModule();\n\n    this.applyTransitiveScopes();\n\n    this.applyProviderOverrides();\n\n    // Patch previously stored `styles` Component values (taken from ɵcmp), in case these\n    // Components have `styleUrls` fields defined and template override was requested.\n    this.patchComponentsWithExistingStyles();\n\n    // Clear the componentToModuleScope map, so that future compilations don't reset the scope of\n    // every component.\n    this.componentToModuleScope.clear();\n\n    const parentInjector = this.platform.injector;\n    this.testModuleRef = new NgModuleRef(this.testModuleType, parentInjector);\n\n    // ApplicationInitStatus.runInitializers() is marked @internal to core.\n    // Cast it to any before accessing it.\n    (this.testModuleRef.injector.get(ApplicationInitStatus) as any).runInitializers();\n\n    // Set locale ID after running app initializers, since locale information might be updated while\n    // running initializers. This is also consistent with the execution order while bootstrapping an\n    // app (see `packages/core/src/application_ref.ts` file).\n    const localeId = this.testModuleRef.injector.get(LOCALE_ID, DEFAULT_LOCALE_ID);\n    setLocaleId(localeId);\n\n    return this.testModuleRef;\n  }\n\n  /**\n   * @internal\n   */\n  _compileNgModuleSync(moduleType: Type<any>): void {\n    this.queueTypesFromModulesArray([moduleType]);\n    this.compileTypesSync();\n    this.applyProviderOverrides();\n    this.applyProviderOverridesToModule(moduleType);\n    this.applyTransitiveScopes();\n  }\n\n  /**\n   * @internal\n   */\n  async _compileNgModuleAsync(moduleType: Type<any>): Promise<void> {\n    this.queueTypesFromModulesArray([moduleType]);\n    await this.compileComponents();\n    this.applyProviderOverrides();\n    this.applyProviderOverridesToModule(moduleType);\n    this.applyTransitiveScopes();\n  }\n\n  /**\n   * @internal\n   */\n  _getModuleResolver(): Resolver<NgModule> {\n    return this.resolvers.module;\n  }\n\n  /**\n   * @internal\n   */\n  _getComponentFactories(moduleType: NgModuleType): ComponentFactory<any>[] {\n    return maybeUnwrapFn(moduleType.ɵmod.declarations).reduce((factories, declaration) => {\n      const componentDef = (declaration as any).ɵcmp;\n      componentDef && factories.push(new ComponentFactory(componentDef, this.testModuleRef!));\n      return factories;\n    }, [] as ComponentFactory<any>[]);\n  }\n\n  private compileTypesSync(): boolean {\n    // Compile all queued components, directives, pipes.\n    let needsAsyncResources = false;\n    this.pendingComponents.forEach(declaration => {\n      needsAsyncResources = needsAsyncResources || isComponentDefPendingResolution(declaration);\n      const metadata = this.resolvers.component.resolve(declaration);\n      if (metadata === null) {\n        throw invalidTypeError(declaration.name, 'Component');\n      }\n      this.maybeStoreNgDef(NG_COMP_DEF, declaration);\n      compileComponent(declaration, metadata);\n    });\n    this.pendingComponents.clear();\n\n    this.pendingDirectives.forEach(declaration => {\n      const metadata = this.resolvers.directive.resolve(declaration);\n      if (metadata === null) {\n        throw invalidTypeError(declaration.name, 'Directive');\n      }\n      this.maybeStoreNgDef(NG_DIR_DEF, declaration);\n      compileDirective(declaration, metadata);\n    });\n    this.pendingDirectives.clear();\n\n    this.pendingPipes.forEach(declaration => {\n      const metadata = this.resolvers.pipe.resolve(declaration);\n      if (metadata === null) {\n        throw invalidTypeError(declaration.name, 'Pipe');\n      }\n      this.maybeStoreNgDef(NG_PIPE_DEF, declaration);\n      compilePipe(declaration, metadata);\n    });\n    this.pendingPipes.clear();\n\n    return needsAsyncResources;\n  }\n\n  private applyTransitiveScopes(): void {\n    if (this.overriddenModules.size > 0) {\n      // Module overrides (via `TestBed.overrideModule`) might affect scopes that were previously\n      // calculated and stored in `transitiveCompileScopes`. If module overrides are present,\n      // collect all affected modules and reset scopes to force their re-calculation.\n      const testingModuleDef = (this.testModuleType as any)[NG_MOD_DEF];\n      const affectedModules = this.collectModulesAffectedByOverrides(testingModuleDef.imports);\n      if (affectedModules.size > 0) {\n        affectedModules.forEach(moduleType => {\n          this.storeFieldOfDefOnType(moduleType as any, NG_MOD_DEF, 'transitiveCompileScopes');\n          (moduleType as any)[NG_MOD_DEF].transitiveCompileScopes = null;\n        });\n      }\n    }\n\n    const moduleToScope = new Map<Type<any>|TestingModuleOverride, NgModuleTransitiveScopes>();\n    const getScopeOfModule =\n        (moduleType: Type<any>|TestingModuleOverride): NgModuleTransitiveScopes => {\n          if (!moduleToScope.has(moduleType)) {\n            const isTestingModule = isTestingModuleOverride(moduleType);\n            const realType = isTestingModule ? this.testModuleType : moduleType as Type<any>;\n            moduleToScope.set(moduleType, transitiveScopesFor(realType));\n          }\n          return moduleToScope.get(moduleType)!;\n        };\n\n    this.componentToModuleScope.forEach((moduleType, componentType) => {\n      const moduleScope = getScopeOfModule(moduleType);\n      this.storeFieldOfDefOnType(componentType, NG_COMP_DEF, 'directiveDefs');\n      this.storeFieldOfDefOnType(componentType, NG_COMP_DEF, 'pipeDefs');\n      // `tView` that is stored on component def contains information about directives and pipes\n      // that are in the scope of this component. Patching component scope will cause `tView` to be\n      // changed. Store original `tView` before patching scope, so the `tView` (including scope\n      // information) is restored back to its previous/original state before running next test.\n      this.storeFieldOfDefOnType(componentType, NG_COMP_DEF, 'tView');\n      patchComponentDefWithScope((componentType as any).ɵcmp, moduleScope);\n    });\n\n    this.componentToModuleScope.clear();\n  }\n\n  private applyProviderOverrides(): void {\n    const maybeApplyOverrides = (field: string) => (type: Type<any>) => {\n      const resolver = field === NG_COMP_DEF ? this.resolvers.component : this.resolvers.directive;\n      const metadata = resolver.resolve(type)!;\n      if (this.hasProviderOverrides(metadata.providers)) {\n        this.patchDefWithProviderOverrides(type, field);\n      }\n    };\n    this.seenComponents.forEach(maybeApplyOverrides(NG_COMP_DEF));\n    this.seenDirectives.forEach(maybeApplyOverrides(NG_DIR_DEF));\n\n    this.seenComponents.clear();\n    this.seenDirectives.clear();\n  }\n\n  private applyProviderOverridesToModule(moduleType: Type<any>): void {\n    if (this.moduleProvidersOverridden.has(moduleType)) {\n      return;\n    }\n    this.moduleProvidersOverridden.add(moduleType);\n\n    const injectorDef: any = (moduleType as any)[NG_INJ_DEF];\n    if (this.providerOverridesByToken.size > 0) {\n      const providers = [\n        ...injectorDef.providers,\n        ...(this.providerOverridesByModule.get(moduleType as InjectorType<any>) || [])\n      ];\n      if (this.hasProviderOverrides(providers)) {\n        this.maybeStoreNgDef(NG_INJ_DEF, moduleType);\n\n        this.storeFieldOfDefOnType(moduleType, NG_INJ_DEF, 'providers');\n        injectorDef.providers = this.getOverriddenProviders(providers);\n      }\n\n      // Apply provider overrides to imported modules recursively\n      const moduleDef = (moduleType as any)[NG_MOD_DEF];\n      const imports = maybeUnwrapFn(moduleDef.imports);\n      for (const importedModule of imports) {\n        this.applyProviderOverridesToModule(importedModule);\n      }\n      // Also override the providers on any ModuleWithProviders imports since those don't appear in\n      // the moduleDef.\n      for (const importedModule of flatten(injectorDef.imports)) {\n        if (isModuleWithProviders(importedModule)) {\n          this.defCleanupOps.push({\n            object: importedModule,\n            fieldName: 'providers',\n            originalValue: importedModule.providers\n          });\n          importedModule.providers = this.getOverriddenProviders(importedModule.providers);\n        }\n      }\n    }\n  }\n\n  private patchComponentsWithExistingStyles(): void {\n    this.existingComponentStyles.forEach(\n        (styles, type) => (type as any)[NG_COMP_DEF].styles = styles);\n    this.existingComponentStyles.clear();\n  }\n\n  private queueTypeArray(arr: any[], moduleType: Type<any>|TestingModuleOverride): void {\n    for (const value of arr) {\n      if (Array.isArray(value)) {\n        this.queueTypeArray(value, moduleType);\n      } else {\n        this.queueType(value, moduleType);\n      }\n    }\n  }\n\n  private recompileNgModule(ngModule: Type<any>, metadata: NgModule): void {\n    // Cache the initial ngModuleDef as it will be overwritten.\n    this.maybeStoreNgDef(NG_MOD_DEF, ngModule);\n    this.maybeStoreNgDef(NG_INJ_DEF, ngModule);\n\n    compileNgModuleDefs(ngModule as NgModuleType<any>, metadata);\n  }\n\n  private queueType(type: Type<any>, moduleType: Type<any>|TestingModuleOverride): void {\n    const component = this.resolvers.component.resolve(type);\n    if (component) {\n      // Check whether a give Type has respective NG def (ɵcmp) and compile if def is\n      // missing. That might happen in case a class without any Angular decorators extends another\n      // class where Component/Directive/Pipe decorator is defined.\n      if (isComponentDefPendingResolution(type) || !type.hasOwnProperty(NG_COMP_DEF)) {\n        this.pendingComponents.add(type);\n      }\n      this.seenComponents.add(type);\n\n      // Keep track of the module which declares this component, so later the component's scope\n      // can be set correctly. If the component has already been recorded here, then one of several\n      // cases is true:\n      // * the module containing the component was imported multiple times (common).\n      // * the component is declared in multiple modules (which is an error).\n      // * the component was in 'declarations' of the testing module, and also in an imported module\n      //   in which case the module scope will be TestingModuleOverride.DECLARATION.\n      // * overrideTemplateUsingTestingModule was called for the component in which case the module\n      //   scope will be TestingModuleOverride.OVERRIDE_TEMPLATE.\n      //\n      // If the component was previously in the testing module's 'declarations' (meaning the\n      // current value is TestingModuleOverride.DECLARATION), then `moduleType` is the component's\n      // real module, which was imported. This pattern is understood to mean that the component\n      // should use its original scope, but that the testing module should also contain the\n      // component in its scope.\n      if (!this.componentToModuleScope.has(type) ||\n          this.componentToModuleScope.get(type) === TestingModuleOverride.DECLARATION) {\n        this.componentToModuleScope.set(type, moduleType);\n      }\n      return;\n    }\n\n    const directive = this.resolvers.directive.resolve(type);\n    if (directive) {\n      if (!type.hasOwnProperty(NG_DIR_DEF)) {\n        this.pendingDirectives.add(type);\n      }\n      this.seenDirectives.add(type);\n      return;\n    }\n\n    const pipe = this.resolvers.pipe.resolve(type);\n    if (pipe && !type.hasOwnProperty(NG_PIPE_DEF)) {\n      this.pendingPipes.add(type);\n      return;\n    }\n  }\n\n  private queueTypesFromModulesArray(arr: any[]): void {\n    // Because we may encounter the same NgModule while processing the imports and exports of an\n    // NgModule tree, we cache them in this set so we can skip ones that have already been seen\n    // encountered. In some test setups, this caching resulted in 10X runtime improvement.\n    const processedNgModuleDefs = new Set();\n    const queueTypesFromModulesArrayRecur = (arr: any[]): void => {\n      for (const value of arr) {\n        if (Array.isArray(value)) {\n          queueTypesFromModulesArrayRecur(value);\n        } else if (hasNgModuleDef(value)) {\n          const def = value.ɵmod;\n          if (processedNgModuleDefs.has(def)) {\n            continue;\n          }\n          processedNgModuleDefs.add(def);\n          // Look through declarations, imports, and exports, and queue\n          // everything found there.\n          this.queueTypeArray(maybeUnwrapFn(def.declarations), value);\n          queueTypesFromModulesArrayRecur(maybeUnwrapFn(def.imports));\n          queueTypesFromModulesArrayRecur(maybeUnwrapFn(def.exports));\n        } else if (isModuleWithProviders(value)) {\n          queueTypesFromModulesArrayRecur([value.ngModule]);\n        }\n      }\n    };\n    queueTypesFromModulesArrayRecur(arr);\n  }\n\n  // When module overrides (via `TestBed.overrideModule`) are present, it might affect all modules\n  // that import (even transitively) an overridden one. For all affected modules we need to\n  // recalculate their scopes for a given test run and restore original scopes at the end. The goal\n  // of this function is to collect all affected modules in a set for further processing. Example:\n  // if we have the following module hierarchy: A -> B -> C (where `->` means `imports`) and module\n  // `C` is overridden, we consider `A` and `B` as affected, since their scopes might become\n  // invalidated with the override.\n  private collectModulesAffectedByOverrides(arr: any[]): Set<NgModuleType<any>> {\n    const seenModules = new Set<NgModuleType<any>>();\n    const affectedModules = new Set<NgModuleType<any>>();\n    const calcAffectedModulesRecur = (arr: any[], path: NgModuleType<any>[]): void => {\n      for (const value of arr) {\n        if (Array.isArray(value)) {\n          // If the value is an array, just flatten it (by invoking this function recursively),\n          // keeping \"path\" the same.\n          calcAffectedModulesRecur(value, path);\n        } else if (hasNgModuleDef(value)) {\n          if (seenModules.has(value)) {\n            // If we've seen this module before and it's included into \"affected modules\" list, mark\n            // the whole path that leads to that module as affected, but do not descend into its\n            // imports, since we already examined them before.\n            if (affectedModules.has(value)) {\n              path.forEach(item => affectedModules.add(item));\n            }\n            continue;\n          }\n          seenModules.add(value);\n          if (this.overriddenModules.has(value)) {\n            path.forEach(item => affectedModules.add(item));\n          }\n          // Examine module imports recursively to look for overridden modules.\n          const moduleDef = (value as any)[NG_MOD_DEF];\n          calcAffectedModulesRecur(maybeUnwrapFn(moduleDef.imports), path.concat(value));\n        }\n      }\n    };\n    calcAffectedModulesRecur(arr, []);\n    return affectedModules;\n  }\n\n  private maybeStoreNgDef(prop: string, type: Type<any>) {\n    if (!this.initialNgDefs.has(type)) {\n      const currentDef = Object.getOwnPropertyDescriptor(type, prop);\n      this.initialNgDefs.set(type, [prop, currentDef]);\n    }\n  }\n\n  private storeFieldOfDefOnType(type: Type<any>, defField: string, fieldName: string): void {\n    const def: any = (type as any)[defField];\n    const originalValue: any = def[fieldName];\n    this.defCleanupOps.push({object: def, fieldName, originalValue});\n  }\n\n  /**\n   * Clears current components resolution queue, but stores the state of the queue, so we can\n   * restore it later. Clearing the queue is required before we try to compile components (via\n   * `TestBed.compileComponents`), so that component defs are in sync with the resolution queue.\n   */\n  private clearComponentResolutionQueue() {\n    if (this.originalComponentResolutionQueue === null) {\n      this.originalComponentResolutionQueue = new Map();\n    }\n    clearResolutionOfComponentResourcesQueue().forEach(\n        (value, key) => this.originalComponentResolutionQueue!.set(key, value));\n  }\n\n  /*\n   * Restores component resolution queue to the previously saved state. This operation is performed\n   * as a part of restoring the state after completion of the current set of tests (that might\n   * potentially mutate the state).\n   */\n  private restoreComponentResolutionQueue() {\n    if (this.originalComponentResolutionQueue !== null) {\n      restoreComponentResolutionQueue(this.originalComponentResolutionQueue);\n      this.originalComponentResolutionQueue = null;\n    }\n  }\n\n  restoreOriginalState(): void {\n    // Process cleanup ops in reverse order so the field's original value is restored correctly (in\n    // case there were multiple overrides for the same field).\n    forEachRight(this.defCleanupOps, (op: CleanupOperation) => {\n      op.object[op.fieldName] = op.originalValue;\n    });\n    // Restore initial component/directive/pipe defs\n    this.initialNgDefs.forEach((value: [string, PropertyDescriptor|undefined], type: Type<any>) => {\n      const [prop, descriptor] = value;\n      if (!descriptor) {\n        // Delete operations are generally undesirable since they have performance implications\n        // on objects they were applied to. In this particular case, situations where this code\n        // is invoked should be quite rare to cause any noticeable impact, since it's applied\n        // only to some test cases (for example when class with no annotations extends some\n        // @Component) when we need to clear 'ɵcmp' field on a given class to restore\n        // its original state (before applying overrides and running tests).\n        delete (type as any)[prop];\n      } else {\n        Object.defineProperty(type, prop, descriptor);\n      }\n    });\n    this.initialNgDefs.clear();\n    this.moduleProvidersOverridden.clear();\n    this.restoreComponentResolutionQueue();\n    // Restore the locale ID to the default value, this shouldn't be necessary but we never know\n    setLocaleId(DEFAULT_LOCALE_ID);\n  }\n\n  private compileTestModule(): void {\n    class RootScopeModule {}\n    compileNgModuleDefs(RootScopeModule as NgModuleType<any>, {\n      providers: [...this.rootProviderOverrides],\n    });\n\n    const ngZone = new NgZone({enableLongStackTrace: true});\n    const providers: Provider[] = [\n      {provide: NgZone, useValue: ngZone},\n      {provide: Compiler, useFactory: () => new R3TestCompiler(this)},\n      ...this.providers,\n      ...this.providerOverrides,\n    ];\n    const imports = [RootScopeModule, this.additionalModuleTypes, this.imports || []];\n\n    // clang-format off\n    compileNgModuleDefs(this.testModuleType, {\n      declarations: this.declarations,\n      imports,\n      schemas: this.schemas,\n      providers,\n    }, /* allowDuplicateDeclarationsInRoot */ true);\n    // clang-format on\n\n    this.applyProviderOverridesToModule(this.testModuleType);\n  }\n\n  get injector(): Injector {\n    if (this._injector !== null) {\n      return this._injector;\n    }\n\n    const providers: Provider[] = [];\n    const compilerOptions = this.platform.injector.get(COMPILER_OPTIONS);\n    compilerOptions.forEach(opts => {\n      if (opts.providers) {\n        providers.push(opts.providers);\n      }\n    });\n    if (this.compilerProviders !== null) {\n      providers.push(...this.compilerProviders);\n    }\n\n    // TODO(ocombe): make this work with an Injector directly instead of creating a module for it\n    class CompilerModule {}\n    compileNgModuleDefs(CompilerModule as NgModuleType<any>, {providers});\n\n    const CompilerModuleFactory = new R3NgModuleFactory(CompilerModule);\n    this._injector = CompilerModuleFactory.create(this.platform.injector).injector;\n    return this._injector;\n  }\n\n  // get overrides for a specific provider (if any)\n  private getSingleProviderOverrides(provider: Provider): Provider|null {\n    const token = getProviderToken(provider);\n    return this.providerOverridesByToken.get(token) || null;\n  }\n\n  private getProviderOverrides(providers?: Provider[]): Provider[] {\n    if (!providers || !providers.length || this.providerOverridesByToken.size === 0) return [];\n    // There are two flattening operations here. The inner flatten() operates on the metadata's\n    // providers and applies a mapping function which retrieves overrides for each incoming\n    // provider. The outer flatten() then flattens the produced overrides array. If this is not\n    // done, the array can contain other empty arrays (e.g. `[[], []]`) which leak into the\n    // providers array and contaminate any error messages that might be generated.\n    return flatten(flatten(\n        providers, (provider: Provider) => this.getSingleProviderOverrides(provider) || []));\n  }\n\n  private getOverriddenProviders(providers?: Provider[]): Provider[] {\n    if (!providers || !providers.length || this.providerOverridesByToken.size === 0) return [];\n\n    const flattenedProviders = flatten<Provider[]>(providers);\n    const overrides = this.getProviderOverrides(flattenedProviders);\n    const overriddenProviders = [...flattenedProviders, ...overrides];\n    const final: Provider[] = [];\n    const seenOverriddenProviders = new Set<Provider>();\n\n    // We iterate through the list of providers in reverse order to make sure provider overrides\n    // take precedence over the values defined in provider list. We also filter out all providers\n    // that have overrides, keeping overridden values only. This is needed, since presence of a\n    // provider with `ngOnDestroy` hook will cause this hook to be registered and invoked later.\n    forEachRight(overriddenProviders, (provider: any) => {\n      const token: any = getProviderToken(provider);\n      if (this.providerOverridesByToken.has(token)) {\n        if (!seenOverriddenProviders.has(token)) {\n          seenOverriddenProviders.add(token);\n          // Treat all overridden providers as `{multi: false}` (even if it's a multi-provider) to\n          // make sure that provided override takes highest precedence and is not combined with\n          // other instances of the same multi provider.\n          final.unshift({...provider, multi: false});\n        }\n      } else {\n        final.unshift(provider);\n      }\n    });\n    return final;\n  }\n\n  private hasProviderOverrides(providers?: Provider[]): boolean {\n    return this.getProviderOverrides(providers).length > 0;\n  }\n\n  private patchDefWithProviderOverrides(declaration: Type<any>, field: string): void {\n    const def = (declaration as any)[field];\n    if (def && def.providersResolver) {\n      this.maybeStoreNgDef(field, declaration);\n\n      const resolver = def.providersResolver;\n      const processProvidersFn = (providers: Provider[]) => this.getOverriddenProviders(providers);\n      this.storeFieldOfDefOnType(declaration, field, 'providersResolver');\n      def.providersResolver = (ngDef: DirectiveDef<any>) => resolver(ngDef, processProvidersFn);\n    }\n  }\n}\n\nfunction initResolvers(): Resolvers {\n  return {\n    module: new NgModuleResolver(),\n    component: new ComponentResolver(),\n    directive: new DirectiveResolver(),\n    pipe: new PipeResolver()\n  };\n}\n\nfunction hasNgModuleDef<T>(value: Type<T>): value is NgModuleType<T> {\n  return value.hasOwnProperty('ɵmod');\n}\n\nfunction maybeUnwrapFn<T>(maybeFn: (() => T)|T): T {\n  return maybeFn instanceof Function ? maybeFn() : maybeFn;\n}\n\nfunction flatten<T>(values: any[], mapFn?: (value: T) => any): T[] {\n  const out: T[] = [];\n  values.forEach(value => {\n    if (Array.isArray(value)) {\n      out.push(...flatten<T>(value, mapFn));\n    } else {\n      out.push(mapFn ? mapFn(value) : value);\n    }\n  });\n  return out;\n}\n\nfunction getProviderField(provider: Provider, field: string) {\n  return provider && typeof provider === 'object' && (provider as any)[field];\n}\n\nfunction getProviderToken(provider: Provider) {\n  return getProviderField(provider, 'provide') || provider;\n}\n\nfunction isModuleWithProviders(value: any): value is ModuleWithProviders<any> {\n  return value.hasOwnProperty('ngModule');\n}\n\nfunction forEachRight<T>(values: T[], fn: (value: T, idx: number) => void): void {\n  for (let idx = values.length - 1; idx >= 0; idx--) {\n    fn(values[idx], idx);\n  }\n}\n\nfunction invalidTypeError(name: string, expectedType: string): Error {\n  return new Error(`${name} class doesn't have @${expectedType} decorator or is missing metadata.`);\n}\n\nclass R3TestCompiler implements Compiler {\n  constructor(private testBed: R3TestBedCompiler) {}\n\n  compileModuleSync<T>(moduleType: Type<T>): NgModuleFactory<T> {\n    this.testBed._compileNgModuleSync(moduleType);\n    return new R3NgModuleFactory(moduleType);\n  }\n\n  async compileModuleAsync<T>(moduleType: Type<T>): Promise<NgModuleFactory<T>> {\n    await this.testBed._compileNgModuleAsync(moduleType);\n    return new R3NgModuleFactory(moduleType);\n  }\n\n  compileModuleAndAllComponentsSync<T>(moduleType: Type<T>): ModuleWithComponentFactories<T> {\n    const ngModuleFactory = this.compileModuleSync(moduleType);\n    const componentFactories = this.testBed._getComponentFactories(moduleType as NgModuleType<T>);\n    return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);\n  }\n\n  async compileModuleAndAllComponentsAsync<T>(moduleType: Type<T>):\n      Promise<ModuleWithComponentFactories<T>> {\n    const ngModuleFactory = await this.compileModuleAsync(moduleType);\n    const componentFactories = this.testBed._getComponentFactories(moduleType as NgModuleType<T>);\n    return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);\n  }\n\n  clearCache(): void {}\n\n  clearCacheFor(type: Type<any>): void {}\n\n  getModuleId(moduleType: Type<any>): string|undefined {\n    const meta = this.testBed._getModuleResolver().resolve(moduleType);\n    return meta && meta.id || undefined;\n  }\n}\n"]}