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