source: trip-planner-front/node_modules/@angular/compiler/esm2015/src/aot/static_symbol_resolver.js@ 6a3a178

Last change on this file since 6a3a178 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 71.9 KB
Line 
1/**
2 * @license
3 * Copyright Google LLC All Rights Reserved.
4 *
5 * Use of this source code is governed by an MIT-style license that can be
6 * found in the LICENSE file at https://angular.io/license
7 */
8import { ValueTransformer, visitValue } from '../util';
9import { StaticSymbol } from './static_symbol';
10import { isGeneratedFile, stripSummaryForJitFileSuffix, stripSummaryForJitNameSuffix, summaryForJitFileName, summaryForJitName } from './util';
11const TS = /^(?!.*\.d\.ts$).*\.ts$/;
12export class ResolvedStaticSymbol {
13 constructor(symbol, metadata) {
14 this.symbol = symbol;
15 this.metadata = metadata;
16 }
17}
18const SUPPORTED_SCHEMA_VERSION = 4;
19/**
20 * This class is responsible for loading metadata per symbol,
21 * and normalizing references between symbols.
22 *
23 * Internally, it only uses symbols without members,
24 * and deduces the values for symbols with members based
25 * on these symbols.
26 */
27export class StaticSymbolResolver {
28 constructor(host, staticSymbolCache, summaryResolver, errorRecorder) {
29 this.host = host;
30 this.staticSymbolCache = staticSymbolCache;
31 this.summaryResolver = summaryResolver;
32 this.errorRecorder = errorRecorder;
33 this.metadataCache = new Map();
34 // Note: this will only contain StaticSymbols without members!
35 this.resolvedSymbols = new Map();
36 // Note: this will only contain StaticSymbols without members!
37 this.importAs = new Map();
38 this.symbolResourcePaths = new Map();
39 this.symbolFromFile = new Map();
40 this.knownFileNameToModuleNames = new Map();
41 }
42 resolveSymbol(staticSymbol) {
43 if (staticSymbol.members.length > 0) {
44 return this._resolveSymbolMembers(staticSymbol);
45 }
46 // Note: always ask for a summary first,
47 // as we might have read shallow metadata via a .d.ts file
48 // for the symbol.
49 const resultFromSummary = this._resolveSymbolFromSummary(staticSymbol);
50 if (resultFromSummary) {
51 return resultFromSummary;
52 }
53 const resultFromCache = this.resolvedSymbols.get(staticSymbol);
54 if (resultFromCache) {
55 return resultFromCache;
56 }
57 // Note: Some users use libraries that were not compiled with ngc, i.e. they don't
58 // have summaries, only .d.ts files. So we always need to check both, the summary
59 // and metadata.
60 this._createSymbolsOf(staticSymbol.filePath);
61 return this.resolvedSymbols.get(staticSymbol);
62 }
63 /**
64 * getImportAs produces a symbol that can be used to import the given symbol.
65 * The import might be different than the symbol if the symbol is exported from
66 * a library with a summary; in which case we want to import the symbol from the
67 * ngfactory re-export instead of directly to avoid introducing a direct dependency
68 * on an otherwise indirect dependency.
69 *
70 * @param staticSymbol the symbol for which to generate a import symbol
71 */
72 getImportAs(staticSymbol, useSummaries = true) {
73 if (staticSymbol.members.length) {
74 const baseSymbol = this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name);
75 const baseImportAs = this.getImportAs(baseSymbol, useSummaries);
76 return baseImportAs ?
77 this.getStaticSymbol(baseImportAs.filePath, baseImportAs.name, staticSymbol.members) :
78 null;
79 }
80 const summarizedFileName = stripSummaryForJitFileSuffix(staticSymbol.filePath);
81 if (summarizedFileName !== staticSymbol.filePath) {
82 const summarizedName = stripSummaryForJitNameSuffix(staticSymbol.name);
83 const baseSymbol = this.getStaticSymbol(summarizedFileName, summarizedName, staticSymbol.members);
84 const baseImportAs = this.getImportAs(baseSymbol, useSummaries);
85 return baseImportAs ? this.getStaticSymbol(summaryForJitFileName(baseImportAs.filePath), summaryForJitName(baseImportAs.name), baseSymbol.members) :
86 null;
87 }
88 let result = (useSummaries && this.summaryResolver.getImportAs(staticSymbol)) || null;
89 if (!result) {
90 result = this.importAs.get(staticSymbol);
91 }
92 return result;
93 }
94 /**
95 * getResourcePath produces the path to the original location of the symbol and should
96 * be used to determine the relative location of resource references recorded in
97 * symbol metadata.
98 */
99 getResourcePath(staticSymbol) {
100 return this.symbolResourcePaths.get(staticSymbol) || staticSymbol.filePath;
101 }
102 /**
103 * getTypeArity returns the number of generic type parameters the given symbol
104 * has. If the symbol is not a type the result is null.
105 */
106 getTypeArity(staticSymbol) {
107 // If the file is a factory/ngsummary file, don't resolve the symbol as doing so would
108 // cause the metadata for an factory/ngsummary file to be loaded which doesn't exist.
109 // All references to generated classes must include the correct arity whenever
110 // generating code.
111 if (isGeneratedFile(staticSymbol.filePath)) {
112 return null;
113 }
114 let resolvedSymbol = unwrapResolvedMetadata(this.resolveSymbol(staticSymbol));
115 while (resolvedSymbol && resolvedSymbol.metadata instanceof StaticSymbol) {
116 resolvedSymbol = unwrapResolvedMetadata(this.resolveSymbol(resolvedSymbol.metadata));
117 }
118 return (resolvedSymbol && resolvedSymbol.metadata && resolvedSymbol.metadata.arity) || null;
119 }
120 getKnownModuleName(filePath) {
121 return this.knownFileNameToModuleNames.get(filePath) || null;
122 }
123 recordImportAs(sourceSymbol, targetSymbol) {
124 sourceSymbol.assertNoMembers();
125 targetSymbol.assertNoMembers();
126 this.importAs.set(sourceSymbol, targetSymbol);
127 }
128 recordModuleNameForFileName(fileName, moduleName) {
129 this.knownFileNameToModuleNames.set(fileName, moduleName);
130 }
131 /**
132 * Invalidate all information derived from the given file and return the
133 * static symbols contained in the file.
134 *
135 * @param fileName the file to invalidate
136 */
137 invalidateFile(fileName) {
138 this.metadataCache.delete(fileName);
139 const symbols = this.symbolFromFile.get(fileName);
140 if (!symbols) {
141 return [];
142 }
143 this.symbolFromFile.delete(fileName);
144 for (const symbol of symbols) {
145 this.resolvedSymbols.delete(symbol);
146 this.importAs.delete(symbol);
147 this.symbolResourcePaths.delete(symbol);
148 }
149 return symbols;
150 }
151 /** @internal */
152 ignoreErrorsFor(cb) {
153 const recorder = this.errorRecorder;
154 this.errorRecorder = () => { };
155 try {
156 return cb();
157 }
158 finally {
159 this.errorRecorder = recorder;
160 }
161 }
162 _resolveSymbolMembers(staticSymbol) {
163 const members = staticSymbol.members;
164 const baseResolvedSymbol = this.resolveSymbol(this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name));
165 if (!baseResolvedSymbol) {
166 return null;
167 }
168 let baseMetadata = unwrapResolvedMetadata(baseResolvedSymbol.metadata);
169 if (baseMetadata instanceof StaticSymbol) {
170 return new ResolvedStaticSymbol(staticSymbol, this.getStaticSymbol(baseMetadata.filePath, baseMetadata.name, members));
171 }
172 else if (baseMetadata && baseMetadata.__symbolic === 'class') {
173 if (baseMetadata.statics && members.length === 1) {
174 return new ResolvedStaticSymbol(staticSymbol, baseMetadata.statics[members[0]]);
175 }
176 }
177 else {
178 let value = baseMetadata;
179 for (let i = 0; i < members.length && value; i++) {
180 value = value[members[i]];
181 }
182 return new ResolvedStaticSymbol(staticSymbol, value);
183 }
184 return null;
185 }
186 _resolveSymbolFromSummary(staticSymbol) {
187 const summary = this.summaryResolver.resolveSummary(staticSymbol);
188 return summary ? new ResolvedStaticSymbol(staticSymbol, summary.metadata) : null;
189 }
190 /**
191 * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.
192 * All types passed to the StaticResolver should be pseudo-types returned by this method.
193 *
194 * @param declarationFile the absolute path of the file where the symbol is declared
195 * @param name the name of the type.
196 * @param members a symbol for a static member of the named type
197 */
198 getStaticSymbol(declarationFile, name, members) {
199 return this.staticSymbolCache.get(declarationFile, name, members);
200 }
201 /**
202 * hasDecorators checks a file's metadata for the presence of decorators without evaluating the
203 * metadata.
204 *
205 * @param filePath the absolute path to examine for decorators.
206 * @returns true if any class in the file has a decorator.
207 */
208 hasDecorators(filePath) {
209 const metadata = this.getModuleMetadata(filePath);
210 if (metadata['metadata']) {
211 return Object.keys(metadata['metadata']).some((metadataKey) => {
212 const entry = metadata['metadata'][metadataKey];
213 return entry && entry.__symbolic === 'class' && entry.decorators;
214 });
215 }
216 return false;
217 }
218 getSymbolsOf(filePath) {
219 const summarySymbols = this.summaryResolver.getSymbolsOf(filePath);
220 if (summarySymbols) {
221 return summarySymbols;
222 }
223 // Note: Some users use libraries that were not compiled with ngc, i.e. they don't
224 // have summaries, only .d.ts files, but `summaryResolver.isLibraryFile` returns true.
225 this._createSymbolsOf(filePath);
226 return this.symbolFromFile.get(filePath) || [];
227 }
228 _createSymbolsOf(filePath) {
229 if (this.symbolFromFile.has(filePath)) {
230 return;
231 }
232 const resolvedSymbols = [];
233 const metadata = this.getModuleMetadata(filePath);
234 if (metadata['importAs']) {
235 // Index bundle indices should use the importAs module name defined
236 // in the bundle.
237 this.knownFileNameToModuleNames.set(filePath, metadata['importAs']);
238 }
239 // handle the symbols in one of the re-export location
240 if (metadata['exports']) {
241 for (const moduleExport of metadata['exports']) {
242 // handle the symbols in the list of explicitly re-exported symbols.
243 if (moduleExport.export) {
244 moduleExport.export.forEach((exportSymbol) => {
245 let symbolName;
246 if (typeof exportSymbol === 'string') {
247 symbolName = exportSymbol;
248 }
249 else {
250 symbolName = exportSymbol.as;
251 }
252 symbolName = unescapeIdentifier(symbolName);
253 let symName = symbolName;
254 if (typeof exportSymbol !== 'string') {
255 symName = unescapeIdentifier(exportSymbol.name);
256 }
257 const resolvedModule = this.resolveModule(moduleExport.from, filePath);
258 if (resolvedModule) {
259 const targetSymbol = this.getStaticSymbol(resolvedModule, symName);
260 const sourceSymbol = this.getStaticSymbol(filePath, symbolName);
261 resolvedSymbols.push(this.createExport(sourceSymbol, targetSymbol));
262 }
263 });
264 }
265 else {
266 // Handle the symbols loaded by 'export *' directives.
267 const resolvedModule = this.resolveModule(moduleExport.from, filePath);
268 if (resolvedModule && resolvedModule !== filePath) {
269 const nestedExports = this.getSymbolsOf(resolvedModule);
270 nestedExports.forEach((targetSymbol) => {
271 const sourceSymbol = this.getStaticSymbol(filePath, targetSymbol.name);
272 resolvedSymbols.push(this.createExport(sourceSymbol, targetSymbol));
273 });
274 }
275 }
276 }
277 }
278 // handle the actual metadata. Has to be after the exports
279 // as there might be collisions in the names, and we want the symbols
280 // of the current module to win ofter reexports.
281 if (metadata['metadata']) {
282 // handle direct declarations of the symbol
283 const topLevelSymbolNames = new Set(Object.keys(metadata['metadata']).map(unescapeIdentifier));
284 const origins = metadata['origins'] || {};
285 Object.keys(metadata['metadata']).forEach((metadataKey) => {
286 const symbolMeta = metadata['metadata'][metadataKey];
287 const name = unescapeIdentifier(metadataKey);
288 const symbol = this.getStaticSymbol(filePath, name);
289 const origin = origins.hasOwnProperty(metadataKey) && origins[metadataKey];
290 if (origin) {
291 // If the symbol is from a bundled index, use the declaration location of the
292 // symbol so relative references (such as './my.html') will be calculated
293 // correctly.
294 const originFilePath = this.resolveModule(origin, filePath);
295 if (!originFilePath) {
296 this.reportError(new Error(`Couldn't resolve original symbol for ${origin} from ${this.host.getOutputName(filePath)}`));
297 }
298 else {
299 this.symbolResourcePaths.set(symbol, originFilePath);
300 }
301 }
302 resolvedSymbols.push(this.createResolvedSymbol(symbol, filePath, topLevelSymbolNames, symbolMeta));
303 });
304 }
305 const uniqueSymbols = new Set();
306 for (const resolvedSymbol of resolvedSymbols) {
307 this.resolvedSymbols.set(resolvedSymbol.symbol, resolvedSymbol);
308 uniqueSymbols.add(resolvedSymbol.symbol);
309 }
310 this.symbolFromFile.set(filePath, Array.from(uniqueSymbols));
311 }
312 createResolvedSymbol(sourceSymbol, topLevelPath, topLevelSymbolNames, metadata) {
313 // For classes that don't have Angular summaries / metadata,
314 // we only keep their arity, but nothing else
315 // (e.g. their constructor parameters).
316 // We do this to prevent introducing deep imports
317 // as we didn't generate .ngfactory.ts files with proper reexports.
318 const isTsFile = TS.test(sourceSymbol.filePath);
319 if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath) && !isTsFile && metadata &&
320 metadata['__symbolic'] === 'class') {
321 const transformedMeta = { __symbolic: 'class', arity: metadata.arity };
322 return new ResolvedStaticSymbol(sourceSymbol, transformedMeta);
323 }
324 let _originalFileMemo;
325 const getOriginalName = () => {
326 if (!_originalFileMemo) {
327 // Guess what the original file name is from the reference. If it has a `.d.ts` extension
328 // replace it with `.ts`. If it already has `.ts` just leave it in place. If it doesn't have
329 // .ts or .d.ts, append `.ts'. Also, if it is in `node_modules`, trim the `node_module`
330 // location as it is not important to finding the file.
331 _originalFileMemo =
332 this.host.getOutputName(topLevelPath.replace(/((\.ts)|(\.d\.ts)|)$/, '.ts')
333 .replace(/^.*node_modules[/\\]/, ''));
334 }
335 return _originalFileMemo;
336 };
337 const self = this;
338 class ReferenceTransformer extends ValueTransformer {
339 visitStringMap(map, functionParams) {
340 const symbolic = map['__symbolic'];
341 if (symbolic === 'function') {
342 const oldLen = functionParams.length;
343 functionParams.push(...(map['parameters'] || []));
344 const result = super.visitStringMap(map, functionParams);
345 functionParams.length = oldLen;
346 return result;
347 }
348 else if (symbolic === 'reference') {
349 const module = map['module'];
350 const name = map['name'] ? unescapeIdentifier(map['name']) : map['name'];
351 if (!name) {
352 return null;
353 }
354 let filePath;
355 if (module) {
356 filePath = self.resolveModule(module, sourceSymbol.filePath);
357 if (!filePath) {
358 return {
359 __symbolic: 'error',
360 message: `Could not resolve ${module} relative to ${self.host.getMetadataFor(sourceSymbol.filePath)}.`,
361 line: map['line'],
362 character: map['character'],
363 fileName: getOriginalName()
364 };
365 }
366 return {
367 __symbolic: 'resolved',
368 symbol: self.getStaticSymbol(filePath, name),
369 line: map['line'],
370 character: map['character'],
371 fileName: getOriginalName()
372 };
373 }
374 else if (functionParams.indexOf(name) >= 0) {
375 // reference to a function parameter
376 return { __symbolic: 'reference', name: name };
377 }
378 else {
379 if (topLevelSymbolNames.has(name)) {
380 return self.getStaticSymbol(topLevelPath, name);
381 }
382 // ambient value
383 null;
384 }
385 }
386 else if (symbolic === 'error') {
387 return Object.assign(Object.assign({}, map), { fileName: getOriginalName() });
388 }
389 else {
390 return super.visitStringMap(map, functionParams);
391 }
392 }
393 }
394 const transformedMeta = visitValue(metadata, new ReferenceTransformer(), []);
395 let unwrappedTransformedMeta = unwrapResolvedMetadata(transformedMeta);
396 if (unwrappedTransformedMeta instanceof StaticSymbol) {
397 return this.createExport(sourceSymbol, unwrappedTransformedMeta);
398 }
399 return new ResolvedStaticSymbol(sourceSymbol, transformedMeta);
400 }
401 createExport(sourceSymbol, targetSymbol) {
402 sourceSymbol.assertNoMembers();
403 targetSymbol.assertNoMembers();
404 if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath) &&
405 this.summaryResolver.isLibraryFile(targetSymbol.filePath)) {
406 // This case is for an ng library importing symbols from a plain ts library
407 // transitively.
408 // Note: We rely on the fact that we discover symbols in the direction
409 // from source files to library files
410 this.importAs.set(targetSymbol, this.getImportAs(sourceSymbol) || sourceSymbol);
411 }
412 return new ResolvedStaticSymbol(sourceSymbol, targetSymbol);
413 }
414 reportError(error, context, path) {
415 if (this.errorRecorder) {
416 this.errorRecorder(error, (context && context.filePath) || path);
417 }
418 else {
419 throw error;
420 }
421 }
422 /**
423 * @param module an absolute path to a module file.
424 */
425 getModuleMetadata(module) {
426 let moduleMetadata = this.metadataCache.get(module);
427 if (!moduleMetadata) {
428 const moduleMetadatas = this.host.getMetadataFor(module);
429 if (moduleMetadatas) {
430 let maxVersion = -1;
431 moduleMetadatas.forEach((md) => {
432 if (md && md['version'] > maxVersion) {
433 maxVersion = md['version'];
434 moduleMetadata = md;
435 }
436 });
437 }
438 if (!moduleMetadata) {
439 moduleMetadata =
440 { __symbolic: 'module', version: SUPPORTED_SCHEMA_VERSION, module: module, metadata: {} };
441 }
442 if (moduleMetadata['version'] != SUPPORTED_SCHEMA_VERSION) {
443 const errorMessage = moduleMetadata['version'] == 2 ?
444 `Unsupported metadata version ${moduleMetadata['version']} for module ${module}. This module should be compiled with a newer version of ngc` :
445 `Metadata version mismatch for module ${this.host.getOutputName(module)}, found version ${moduleMetadata['version']}, expected ${SUPPORTED_SCHEMA_VERSION}`;
446 this.reportError(new Error(errorMessage));
447 }
448 this.metadataCache.set(module, moduleMetadata);
449 }
450 return moduleMetadata;
451 }
452 getSymbolByModule(module, symbolName, containingFile) {
453 const filePath = this.resolveModule(module, containingFile);
454 if (!filePath) {
455 this.reportError(new Error(`Could not resolve module ${module}${containingFile ? ' relative to ' + this.host.getOutputName(containingFile) : ''}`));
456 return this.getStaticSymbol(`ERROR:${module}`, symbolName);
457 }
458 return this.getStaticSymbol(filePath, symbolName);
459 }
460 resolveModule(module, containingFile) {
461 try {
462 return this.host.moduleNameToFileName(module, containingFile);
463 }
464 catch (e) {
465 console.error(`Could not resolve module '${module}' relative to file ${containingFile}`);
466 this.reportError(e, undefined, containingFile);
467 }
468 return null;
469 }
470}
471// Remove extra underscore from escaped identifier.
472// See https://github.com/Microsoft/TypeScript/blob/master/src/compiler/utilities.ts
473export function unescapeIdentifier(identifier) {
474 return identifier.startsWith('___') ? identifier.substr(1) : identifier;
475}
476export function unwrapResolvedMetadata(metadata) {
477 if (metadata && metadata.__symbolic === 'resolved') {
478 return metadata.symbol;
479 }
480 return metadata;
481}
482//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"static_symbol_resolver.js","sourceRoot":"","sources":["../../../../../../../packages/compiler/src/aot/static_symbol_resolver.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 {SummaryResolver} from '../summary_resolver';\nimport {ValueTransformer, visitValue} from '../util';\n\nimport {StaticSymbol, StaticSymbolCache} from './static_symbol';\nimport {isGeneratedFile, stripSummaryForJitFileSuffix, stripSummaryForJitNameSuffix, summaryForJitFileName, summaryForJitName} from './util';\n\nconst TS = /^(?!.*\\.d\\.ts$).*\\.ts$/;\n\nexport class ResolvedStaticSymbol {\n  constructor(public symbol: StaticSymbol, public metadata: any) {}\n}\n\n/**\n * The host of the SymbolResolverHost disconnects the implementation from TypeScript / other\n * language\n * services and from underlying file systems.\n */\nexport interface StaticSymbolResolverHost {\n  /**\n   * Return a ModuleMetadata for the given module.\n   * Angular CLI will produce this metadata for a module whenever a .d.ts files is\n   * produced and the module has exported variables or classes with decorators. Module metadata can\n   * also be produced directly from TypeScript sources by using MetadataCollector in tools/metadata.\n   *\n   * @param modulePath is a string identifier for a module as an absolute path.\n   * @returns the metadata for the given module.\n   */\n  getMetadataFor(modulePath: string): {[key: string]: any}[]|undefined;\n\n  /**\n   * Converts a module name that is used in an `import` to a file path.\n   * I.e.\n   * `path/to/containingFile.ts` containing `import {...} from 'module-name'`.\n   */\n  moduleNameToFileName(moduleName: string, containingFile?: string): string|null;\n\n  /**\n   * Get a file suitable for display to the user that should be relative to the project directory\n   * or the current directory.\n   */\n  getOutputName(filePath: string): string;\n}\n\nconst SUPPORTED_SCHEMA_VERSION = 4;\n\n/**\n * This class is responsible for loading metadata per symbol,\n * and normalizing references between symbols.\n *\n * Internally, it only uses symbols without members,\n * and deduces the values for symbols with members based\n * on these symbols.\n */\nexport class StaticSymbolResolver {\n  private metadataCache = new Map<string, {[key: string]: any}>();\n  // Note: this will only contain StaticSymbols without members!\n  private resolvedSymbols = new Map<StaticSymbol, ResolvedStaticSymbol>();\n  // Note: this will only contain StaticSymbols without members!\n  private importAs = new Map<StaticSymbol, StaticSymbol>();\n  private symbolResourcePaths = new Map<StaticSymbol, string>();\n  private symbolFromFile = new Map<string, StaticSymbol[]>();\n  private knownFileNameToModuleNames = new Map<string, string>();\n\n  constructor(\n      private host: StaticSymbolResolverHost, private staticSymbolCache: StaticSymbolCache,\n      private summaryResolver: SummaryResolver<StaticSymbol>,\n      private errorRecorder?: (error: any, fileName?: string) => void) {}\n\n  resolveSymbol(staticSymbol: StaticSymbol): ResolvedStaticSymbol {\n    if (staticSymbol.members.length > 0) {\n      return this._resolveSymbolMembers(staticSymbol)!;\n    }\n    // Note: always ask for a summary first,\n    // as we might have read shallow metadata via a .d.ts file\n    // for the symbol.\n    const resultFromSummary = this._resolveSymbolFromSummary(staticSymbol)!;\n    if (resultFromSummary) {\n      return resultFromSummary;\n    }\n    const resultFromCache = this.resolvedSymbols.get(staticSymbol);\n    if (resultFromCache) {\n      return resultFromCache;\n    }\n    // Note: Some users use libraries that were not compiled with ngc, i.e. they don't\n    // have summaries, only .d.ts files. So we always need to check both, the summary\n    // and metadata.\n    this._createSymbolsOf(staticSymbol.filePath);\n    return this.resolvedSymbols.get(staticSymbol)!;\n  }\n\n  /**\n   * getImportAs produces a symbol that can be used to import the given symbol.\n   * The import might be different than the symbol if the symbol is exported from\n   * a library with a summary; in which case we want to import the symbol from the\n   * ngfactory re-export instead of directly to avoid introducing a direct dependency\n   * on an otherwise indirect dependency.\n   *\n   * @param staticSymbol the symbol for which to generate a import symbol\n   */\n  getImportAs(staticSymbol: StaticSymbol, useSummaries: boolean = true): StaticSymbol|null {\n    if (staticSymbol.members.length) {\n      const baseSymbol = this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name);\n      const baseImportAs = this.getImportAs(baseSymbol, useSummaries);\n      return baseImportAs ?\n          this.getStaticSymbol(baseImportAs.filePath, baseImportAs.name, staticSymbol.members) :\n          null;\n    }\n    const summarizedFileName = stripSummaryForJitFileSuffix(staticSymbol.filePath);\n    if (summarizedFileName !== staticSymbol.filePath) {\n      const summarizedName = stripSummaryForJitNameSuffix(staticSymbol.name);\n      const baseSymbol =\n          this.getStaticSymbol(summarizedFileName, summarizedName, staticSymbol.members);\n      const baseImportAs = this.getImportAs(baseSymbol, useSummaries);\n      return baseImportAs ? this.getStaticSymbol(\n                                summaryForJitFileName(baseImportAs.filePath),\n                                summaryForJitName(baseImportAs.name), baseSymbol.members) :\n                            null;\n    }\n    let result = (useSummaries && this.summaryResolver.getImportAs(staticSymbol)) || null;\n    if (!result) {\n      result = this.importAs.get(staticSymbol)!;\n    }\n    return result;\n  }\n\n  /**\n   * getResourcePath produces the path to the original location of the symbol and should\n   * be used to determine the relative location of resource references recorded in\n   * symbol metadata.\n   */\n  getResourcePath(staticSymbol: StaticSymbol): string {\n    return this.symbolResourcePaths.get(staticSymbol) || staticSymbol.filePath;\n  }\n\n  /**\n   * getTypeArity returns the number of generic type parameters the given symbol\n   * has. If the symbol is not a type the result is null.\n   */\n  getTypeArity(staticSymbol: StaticSymbol): number|null {\n    // If the file is a factory/ngsummary file, don't resolve the symbol as doing so would\n    // cause the metadata for an factory/ngsummary file to be loaded which doesn't exist.\n    // All references to generated classes must include the correct arity whenever\n    // generating code.\n    if (isGeneratedFile(staticSymbol.filePath)) {\n      return null;\n    }\n    let resolvedSymbol = unwrapResolvedMetadata(this.resolveSymbol(staticSymbol));\n    while (resolvedSymbol && resolvedSymbol.metadata instanceof StaticSymbol) {\n      resolvedSymbol = unwrapResolvedMetadata(this.resolveSymbol(resolvedSymbol.metadata));\n    }\n    return (resolvedSymbol && resolvedSymbol.metadata && resolvedSymbol.metadata.arity) || null;\n  }\n\n  getKnownModuleName(filePath: string): string|null {\n    return this.knownFileNameToModuleNames.get(filePath) || null;\n  }\n\n  recordImportAs(sourceSymbol: StaticSymbol, targetSymbol: StaticSymbol) {\n    sourceSymbol.assertNoMembers();\n    targetSymbol.assertNoMembers();\n    this.importAs.set(sourceSymbol, targetSymbol);\n  }\n\n  recordModuleNameForFileName(fileName: string, moduleName: string) {\n    this.knownFileNameToModuleNames.set(fileName, moduleName);\n  }\n\n  /**\n   * Invalidate all information derived from the given file and return the\n   * static symbols contained in the file.\n   *\n   * @param fileName the file to invalidate\n   */\n  invalidateFile(fileName: string): StaticSymbol[] {\n    this.metadataCache.delete(fileName);\n    const symbols = this.symbolFromFile.get(fileName);\n    if (!symbols) {\n      return [];\n    }\n    this.symbolFromFile.delete(fileName);\n    for (const symbol of symbols) {\n      this.resolvedSymbols.delete(symbol);\n      this.importAs.delete(symbol);\n      this.symbolResourcePaths.delete(symbol);\n    }\n    return symbols;\n  }\n\n  /** @internal */\n  ignoreErrorsFor<T>(cb: () => T) {\n    const recorder = this.errorRecorder;\n    this.errorRecorder = () => {};\n    try {\n      return cb();\n    } finally {\n      this.errorRecorder = recorder;\n    }\n  }\n\n  private _resolveSymbolMembers(staticSymbol: StaticSymbol): ResolvedStaticSymbol|null {\n    const members = staticSymbol.members;\n    const baseResolvedSymbol =\n        this.resolveSymbol(this.getStaticSymbol(staticSymbol.filePath, staticSymbol.name));\n    if (!baseResolvedSymbol) {\n      return null;\n    }\n    let baseMetadata = unwrapResolvedMetadata(baseResolvedSymbol.metadata);\n    if (baseMetadata instanceof StaticSymbol) {\n      return new ResolvedStaticSymbol(\n          staticSymbol, this.getStaticSymbol(baseMetadata.filePath, baseMetadata.name, members));\n    } else if (baseMetadata && baseMetadata.__symbolic === 'class') {\n      if (baseMetadata.statics && members.length === 1) {\n        return new ResolvedStaticSymbol(staticSymbol, baseMetadata.statics[members[0]]);\n      }\n    } else {\n      let value = baseMetadata;\n      for (let i = 0; i < members.length && value; i++) {\n        value = value[members[i]];\n      }\n      return new ResolvedStaticSymbol(staticSymbol, value);\n    }\n    return null;\n  }\n\n  private _resolveSymbolFromSummary(staticSymbol: StaticSymbol): ResolvedStaticSymbol|null {\n    const summary = this.summaryResolver.resolveSummary(staticSymbol);\n    return summary ? new ResolvedStaticSymbol(staticSymbol, summary.metadata) : null;\n  }\n\n  /**\n   * getStaticSymbol produces a Type whose metadata is known but whose implementation is not loaded.\n   * All types passed to the StaticResolver should be pseudo-types returned by this method.\n   *\n   * @param declarationFile the absolute path of the file where the symbol is declared\n   * @param name the name of the type.\n   * @param members a symbol for a static member of the named type\n   */\n  getStaticSymbol(declarationFile: string, name: string, members?: string[]): StaticSymbol {\n    return this.staticSymbolCache.get(declarationFile, name, members);\n  }\n\n  /**\n   * hasDecorators checks a file's metadata for the presence of decorators without evaluating the\n   * metadata.\n   *\n   * @param filePath the absolute path to examine for decorators.\n   * @returns true if any class in the file has a decorator.\n   */\n  hasDecorators(filePath: string): boolean {\n    const metadata = this.getModuleMetadata(filePath);\n    if (metadata['metadata']) {\n      return Object.keys(metadata['metadata']).some((metadataKey) => {\n        const entry = metadata['metadata'][metadataKey];\n        return entry && entry.__symbolic === 'class' && entry.decorators;\n      });\n    }\n    return false;\n  }\n\n  getSymbolsOf(filePath: string): StaticSymbol[] {\n    const summarySymbols = this.summaryResolver.getSymbolsOf(filePath);\n    if (summarySymbols) {\n      return summarySymbols;\n    }\n    // Note: Some users use libraries that were not compiled with ngc, i.e. they don't\n    // have summaries, only .d.ts files, but `summaryResolver.isLibraryFile` returns true.\n    this._createSymbolsOf(filePath);\n    return this.symbolFromFile.get(filePath) || [];\n  }\n\n  private _createSymbolsOf(filePath: string) {\n    if (this.symbolFromFile.has(filePath)) {\n      return;\n    }\n    const resolvedSymbols: ResolvedStaticSymbol[] = [];\n    const metadata = this.getModuleMetadata(filePath);\n    if (metadata['importAs']) {\n      // Index bundle indices should use the importAs module name defined\n      // in the bundle.\n      this.knownFileNameToModuleNames.set(filePath, metadata['importAs']);\n    }\n    // handle the symbols in one of the re-export location\n    if (metadata['exports']) {\n      for (const moduleExport of metadata['exports']) {\n        // handle the symbols in the list of explicitly re-exported symbols.\n        if (moduleExport.export) {\n          moduleExport.export.forEach((exportSymbol: any) => {\n            let symbolName: string;\n            if (typeof exportSymbol === 'string') {\n              symbolName = exportSymbol;\n            } else {\n              symbolName = exportSymbol.as;\n            }\n            symbolName = unescapeIdentifier(symbolName);\n            let symName = symbolName;\n            if (typeof exportSymbol !== 'string') {\n              symName = unescapeIdentifier(exportSymbol.name);\n            }\n            const resolvedModule = this.resolveModule(moduleExport.from, filePath);\n            if (resolvedModule) {\n              const targetSymbol = this.getStaticSymbol(resolvedModule, symName);\n              const sourceSymbol = this.getStaticSymbol(filePath, symbolName);\n              resolvedSymbols.push(this.createExport(sourceSymbol, targetSymbol));\n            }\n          });\n        } else {\n          // Handle the symbols loaded by 'export *' directives.\n          const resolvedModule = this.resolveModule(moduleExport.from, filePath);\n          if (resolvedModule && resolvedModule !== filePath) {\n            const nestedExports = this.getSymbolsOf(resolvedModule);\n            nestedExports.forEach((targetSymbol) => {\n              const sourceSymbol = this.getStaticSymbol(filePath, targetSymbol.name);\n              resolvedSymbols.push(this.createExport(sourceSymbol, targetSymbol));\n            });\n          }\n        }\n      }\n    }\n\n    // handle the actual metadata. Has to be after the exports\n    // as there might be collisions in the names, and we want the symbols\n    // of the current module to win ofter reexports.\n    if (metadata['metadata']) {\n      // handle direct declarations of the symbol\n      const topLevelSymbolNames =\n          new Set<string>(Object.keys(metadata['metadata']).map(unescapeIdentifier));\n      const origins: {[index: string]: string} = metadata['origins'] || {};\n      Object.keys(metadata['metadata']).forEach((metadataKey) => {\n        const symbolMeta = metadata['metadata'][metadataKey];\n        const name = unescapeIdentifier(metadataKey);\n\n        const symbol = this.getStaticSymbol(filePath, name);\n\n        const origin = origins.hasOwnProperty(metadataKey) && origins[metadataKey];\n        if (origin) {\n          // If the symbol is from a bundled index, use the declaration location of the\n          // symbol so relative references (such as './my.html') will be calculated\n          // correctly.\n          const originFilePath = this.resolveModule(origin, filePath);\n          if (!originFilePath) {\n            this.reportError(new Error(`Couldn't resolve original symbol for ${origin} from ${\n                this.host.getOutputName(filePath)}`));\n          } else {\n            this.symbolResourcePaths.set(symbol, originFilePath);\n          }\n        }\n        resolvedSymbols.push(\n            this.createResolvedSymbol(symbol, filePath, topLevelSymbolNames, symbolMeta));\n      });\n    }\n    const uniqueSymbols = new Set<StaticSymbol>();\n    for (const resolvedSymbol of resolvedSymbols) {\n      this.resolvedSymbols.set(resolvedSymbol.symbol, resolvedSymbol);\n      uniqueSymbols.add(resolvedSymbol.symbol);\n    }\n    this.symbolFromFile.set(filePath, Array.from(uniqueSymbols));\n  }\n\n  private createResolvedSymbol(\n      sourceSymbol: StaticSymbol, topLevelPath: string, topLevelSymbolNames: Set<string>,\n      metadata: any): ResolvedStaticSymbol {\n    // For classes that don't have Angular summaries / metadata,\n    // we only keep their arity, but nothing else\n    // (e.g. their constructor parameters).\n    // We do this to prevent introducing deep imports\n    // as we didn't generate .ngfactory.ts files with proper reexports.\n    const isTsFile = TS.test(sourceSymbol.filePath);\n    if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath) && !isTsFile && metadata &&\n        metadata['__symbolic'] === 'class') {\n      const transformedMeta = {__symbolic: 'class', arity: metadata.arity};\n      return new ResolvedStaticSymbol(sourceSymbol, transformedMeta);\n    }\n\n    let _originalFileMemo: string|undefined;\n    const getOriginalName: () => string = () => {\n      if (!_originalFileMemo) {\n        // Guess what the original file name is from the reference. If it has a `.d.ts` extension\n        // replace it with `.ts`. If it already has `.ts` just leave it in place. If it doesn't have\n        // .ts or .d.ts, append `.ts'. Also, if it is in `node_modules`, trim the `node_module`\n        // location as it is not important to finding the file.\n        _originalFileMemo =\n            this.host.getOutputName(topLevelPath.replace(/((\\.ts)|(\\.d\\.ts)|)$/, '.ts')\n                                        .replace(/^.*node_modules[/\\\\]/, ''));\n      }\n      return _originalFileMemo;\n    };\n\n    const self = this;\n\n    class ReferenceTransformer extends ValueTransformer {\n      override visitStringMap(map: {[key: string]: any}, functionParams: string[]): any {\n        const symbolic = map['__symbolic'];\n        if (symbolic === 'function') {\n          const oldLen = functionParams.length;\n          functionParams.push(...(map['parameters'] || []));\n          const result = super.visitStringMap(map, functionParams);\n          functionParams.length = oldLen;\n          return result;\n        } else if (symbolic === 'reference') {\n          const module = map['module'];\n          const name = map['name'] ? unescapeIdentifier(map['name']) : map['name'];\n          if (!name) {\n            return null;\n          }\n          let filePath: string;\n          if (module) {\n            filePath = self.resolveModule(module, sourceSymbol.filePath)!;\n            if (!filePath) {\n              return {\n                __symbolic: 'error',\n                message: `Could not resolve ${module} relative to ${\n                    self.host.getMetadataFor(sourceSymbol.filePath)}.`,\n                line: map['line'],\n                character: map['character'],\n                fileName: getOriginalName()\n              };\n            }\n            return {\n              __symbolic: 'resolved',\n              symbol: self.getStaticSymbol(filePath, name),\n              line: map['line'],\n              character: map['character'],\n              fileName: getOriginalName()\n            };\n          } else if (functionParams.indexOf(name) >= 0) {\n            // reference to a function parameter\n            return {__symbolic: 'reference', name: name};\n          } else {\n            if (topLevelSymbolNames.has(name)) {\n              return self.getStaticSymbol(topLevelPath, name);\n            }\n            // ambient value\n            null;\n          }\n        } else if (symbolic === 'error') {\n          return {...map, fileName: getOriginalName()};\n        } else {\n          return super.visitStringMap(map, functionParams);\n        }\n      }\n    }\n    const transformedMeta = visitValue(metadata, new ReferenceTransformer(), []);\n    let unwrappedTransformedMeta = unwrapResolvedMetadata(transformedMeta);\n    if (unwrappedTransformedMeta instanceof StaticSymbol) {\n      return this.createExport(sourceSymbol, unwrappedTransformedMeta);\n    }\n    return new ResolvedStaticSymbol(sourceSymbol, transformedMeta);\n  }\n\n  private createExport(sourceSymbol: StaticSymbol, targetSymbol: StaticSymbol):\n      ResolvedStaticSymbol {\n    sourceSymbol.assertNoMembers();\n    targetSymbol.assertNoMembers();\n    if (this.summaryResolver.isLibraryFile(sourceSymbol.filePath) &&\n        this.summaryResolver.isLibraryFile(targetSymbol.filePath)) {\n      // This case is for an ng library importing symbols from a plain ts library\n      // transitively.\n      // Note: We rely on the fact that we discover symbols in the direction\n      // from source files to library files\n      this.importAs.set(targetSymbol, this.getImportAs(sourceSymbol) || sourceSymbol);\n    }\n    return new ResolvedStaticSymbol(sourceSymbol, targetSymbol);\n  }\n\n  private reportError(error: Error, context?: StaticSymbol, path?: string) {\n    if (this.errorRecorder) {\n      this.errorRecorder(error, (context && context.filePath) || path);\n    } else {\n      throw error;\n    }\n  }\n\n  /**\n   * @param module an absolute path to a module file.\n   */\n  private getModuleMetadata(module: string): {[key: string]: any} {\n    let moduleMetadata = this.metadataCache.get(module);\n    if (!moduleMetadata) {\n      const moduleMetadatas = this.host.getMetadataFor(module);\n      if (moduleMetadatas) {\n        let maxVersion = -1;\n        moduleMetadatas.forEach((md) => {\n          if (md && md['version'] > maxVersion) {\n            maxVersion = md['version'];\n            moduleMetadata = md;\n          }\n        });\n      }\n      if (!moduleMetadata) {\n        moduleMetadata =\n            {__symbolic: 'module', version: SUPPORTED_SCHEMA_VERSION, module: module, metadata: {}};\n      }\n      if (moduleMetadata['version'] != SUPPORTED_SCHEMA_VERSION) {\n        const errorMessage = moduleMetadata['version'] == 2 ?\n            `Unsupported metadata version ${moduleMetadata['version']} for module ${\n                module}. This module should be compiled with a newer version of ngc` :\n            `Metadata version mismatch for module ${\n                this.host.getOutputName(module)}, found version ${\n                moduleMetadata['version']}, expected ${SUPPORTED_SCHEMA_VERSION}`;\n        this.reportError(new Error(errorMessage));\n      }\n      this.metadataCache.set(module, moduleMetadata);\n    }\n    return moduleMetadata;\n  }\n\n\n  getSymbolByModule(module: string, symbolName: string, containingFile?: string): StaticSymbol {\n    const filePath = this.resolveModule(module, containingFile);\n    if (!filePath) {\n      this.reportError(new Error(`Could not resolve module ${module}${\n          containingFile ? ' relative to ' + this.host.getOutputName(containingFile) : ''}`));\n      return this.getStaticSymbol(`ERROR:${module}`, symbolName);\n    }\n    return this.getStaticSymbol(filePath, symbolName);\n  }\n\n  private resolveModule(module: string, containingFile?: string): string|null {\n    try {\n      return this.host.moduleNameToFileName(module, containingFile);\n    } catch (e) {\n      console.error(`Could not resolve module '${module}' relative to file ${containingFile}`);\n      this.reportError(e, undefined, containingFile);\n    }\n    return null;\n  }\n}\n\n// Remove extra underscore from escaped identifier.\n// See https://github.com/Microsoft/TypeScript/blob/master/src/compiler/utilities.ts\nexport function unescapeIdentifier(identifier: string): string {\n  return identifier.startsWith('___') ? identifier.substr(1) : identifier;\n}\n\nexport function unwrapResolvedMetadata(metadata: any): any {\n  if (metadata && metadata.__symbolic === 'resolved') {\n    return metadata.symbol;\n  }\n  return metadata;\n}\n"]}
Note: See TracBrowser for help on using the repository browser.