5a2c3ff8b5
Ivy allows Components to extend Directives (but not the other way around) and as a result we may have Component and Directive annotations present at the same time. The logic that resolves annotations to pick the necessary one didn't take this into account and as a result Components were recognized as Directives (and vice versa) in case of inheritance. This change updates the resolution logic by picking known annotation that is the nearest one (in inheritance tree) and compares it with expected type. That should help avoid mis-classification of Components/Directives during resolution. PR Close #28439
94 lines
3.0 KiB
TypeScript
94 lines
3.0 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright Google Inc. 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 {Component, Directive, NgModule, Pipe, Type, ɵReflectionCapabilities as ReflectionCapabilities} from '@angular/core';
|
|
|
|
import {MetadataOverride} from './metadata_override';
|
|
import {MetadataOverrider} from './metadata_overrider';
|
|
|
|
const reflection = new ReflectionCapabilities();
|
|
|
|
/**
|
|
* Base interface to resolve `@Component`, `@Directive`, `@Pipe` and `@NgModule`.
|
|
*/
|
|
export interface Resolver<T> { resolve(type: Type<any>): T|null; }
|
|
|
|
/**
|
|
* Allows to override ivy metadata for tests (via the `TestBed`).
|
|
*/
|
|
abstract class OverrideResolver<T> implements Resolver<T> {
|
|
private overrides = new Map<Type<any>, MetadataOverride<T>[]>();
|
|
private resolved = new Map<Type<any>, T|null>();
|
|
|
|
abstract get type(): any;
|
|
|
|
setOverrides(overrides: Array<[Type<any>, MetadataOverride<T>]>) {
|
|
this.overrides.clear();
|
|
overrides.forEach(([type, override]) => {
|
|
const overrides = this.overrides.get(type) || [];
|
|
overrides.push(override);
|
|
this.overrides.set(type, overrides);
|
|
});
|
|
}
|
|
|
|
getAnnotation(type: Type<any>): T|null {
|
|
const annotations = reflection.annotations(type);
|
|
// Try to find the nearest known Type annotation and make sure that this annotation is an
|
|
// instance of the type we are looking for, so we can use it for resolution. Note: there might
|
|
// be multiple known annotations found due to the fact that Components can extend Directives (so
|
|
// both Directive and Component annotations would be present), so we always check if the known
|
|
// annotation has the right type.
|
|
for (let i = annotations.length - 1; i >= 0; i--) {
|
|
const annotation = annotations[i];
|
|
const isKnownType = annotation instanceof Directive || annotation instanceof Component ||
|
|
annotation instanceof Pipe || annotation instanceof NgModule;
|
|
if (isKnownType) {
|
|
return annotation instanceof this.type ? annotation : null;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
resolve(type: Type<any>): T|null {
|
|
let resolved = this.resolved.get(type) || null;
|
|
|
|
if (!resolved) {
|
|
resolved = this.getAnnotation(type);
|
|
if (resolved) {
|
|
const overrides = this.overrides.get(type);
|
|
if (overrides) {
|
|
const overrider = new MetadataOverrider();
|
|
overrides.forEach(override => {
|
|
resolved = overrider.overrideMetadata(this.type, resolved !, override);
|
|
});
|
|
}
|
|
}
|
|
this.resolved.set(type, resolved);
|
|
}
|
|
|
|
return resolved;
|
|
}
|
|
}
|
|
|
|
|
|
export class DirectiveResolver extends OverrideResolver<Directive> {
|
|
get type() { return Directive; }
|
|
}
|
|
|
|
export class ComponentResolver extends OverrideResolver<Component> {
|
|
get type() { return Component; }
|
|
}
|
|
|
|
export class PipeResolver extends OverrideResolver<Pipe> {
|
|
get type() { return Pipe; }
|
|
}
|
|
|
|
export class NgModuleResolver extends OverrideResolver<NgModule> {
|
|
get type() { return NgModule; }
|
|
}
|