fix(compiler): Update types for TypeScript nullability support

Author: mhevery

packages/compiler-cli/src/compiler_host.ts

@@ -33,7 +33,7 @@ export class CompilerHost implements AotCompilerHost {
   private resolverCache = new Map<string, ModuleMetadata[]>();
   private bundleIndexCache = new Map<string, boolean>();
   private bundleIndexNames = new Set<string>();
-  private moduleFileNames = new Map<string, string>();
+  private moduleFileNames = new Map<string, string|null>();
   protected resolveModuleNameHost: CompilerHostContext;
 
   constructor(
@@ -71,7 +71,7 @@ export class CompilerHost implements AotCompilerHost {
 
   moduleNameToFileName(m: string, containingFile: string): string|null {
     const key = m + ':' + (containingFile || '');
-    let result = this.moduleFileNames.get(key);
+    let result: string|null = this.moduleFileNames.get(key) || null;
     if (!result) {
       if (!containingFile || !containingFile.length) {
         if (m.indexOf('.') === 0) {
@@ -183,7 +183,7 @@ export class CompilerHost implements AotCompilerHost {
     return sf;
   }
 
-  getMetadataFor(filePath: string): ModuleMetadata[] {
+  getMetadataFor(filePath: string): ModuleMetadata[]|undefined {
     if (!this.context.fileExists(filePath)) {
       // If the file doesn't exists then we cannot return metadata for the file.
       // This will occur if the user refernced a declared module for which no file
@@ -263,6 +263,7 @@ export class CompilerHost implements AotCompilerHost {
     if (this.context.fileExists(filePath)) {
       return this.context.readFile(filePath);
     }
+    return null;
   }
 
   getOutputFileName(sourceFilePath: string): string {
@@ -287,7 +288,7 @@ export class CompilerHost implements AotCompilerHost {
 
   calculateEmitPath(filePath: string): string {
     // Write codegen in a directory structure matching the sources.
-    let root = this.options.basePath;
+    let root = this.options.basePath !;
     for (const eachRootDir of this.options.rootDirs || []) {
       if (this.options.trace) {
         console.error(`Check if ${filePath} is under rootDirs element ${eachRootDir}`);
@@ -373,7 +374,7 @@ export class ModuleResolutionHostAdapter extends CompilerHostContextAdapter impl
   constructor(private host: ts.ModuleResolutionHost) {
     super();
     if (host.directoryExists) {
-      this.directoryExists = (directoryName: string) => host.directoryExists(directoryName);
+      this.directoryExists = (directoryName: string) => host.directoryExists !(directoryName);
     }
   }
 

packages/compiler-cli/src/extract_i18n.ts

@@ -23,7 +23,7 @@ function extract(
     ngOptions: tsc.AngularCompilerOptions, cliOptions: tsc.I18nExtractionCliOptions,
     program: ts.Program, host: ts.CompilerHost): Promise<void> {
   return Extractor.create(ngOptions, program, host, cliOptions.locale)
-      .extract(cliOptions.i18nFormat, cliOptions.outFile);
+      .extract(cliOptions.i18nFormat !, cliOptions.outFile);
 }
 
 // Entry point

packages/compiler-cli/src/ngtools_api.ts

@@ -92,9 +92,9 @@ export class NgTools_InternalApi_NG_2 {
     const hostContext: CompilerHostContext =
         new CustomLoaderModuleResolutionHostAdapter(options.readResource, options.host);
     const cliOptions: NgcCliOptions = {
-      i18nFormat: options.i18nFormat,
-      i18nFile: options.i18nFile,
-      locale: options.locale,
+      i18nFormat: options.i18nFormat !,
+      i18nFile: options.i18nFile !,
+      locale: options.locale !,
       basePath: options.basePath
     };
 
@@ -148,6 +148,6 @@ export class NgTools_InternalApi_NG_2 {
     const extractor = Extractor.create(
         options.angularCompilerOptions, options.program, options.host, locale, hostContext);
 
-    return extractor.extract(options.i18nFormat, options.outFile || null);
+    return extractor.extract(options.i18nFormat !, options.outFile || null);
   }
 }

packages/compiler-cli/src/ngtools_impl.ts

@@ -33,7 +33,8 @@ export type LazyRouteMap = {
 // A route definition. Normally the short form 'path/to/module#ModuleClassName' is used by
 // the user, and this is a helper class to extract information from it.
 export class RouteDef {
-  private constructor(public readonly path: string, public readonly className: string = null) {}
+  private constructor(public readonly path: string, public readonly className: string|null = null) {
+  }
 
   toString() {
     return (this.className === null || this.className == 'default') ?
@@ -58,7 +59,7 @@ export function listLazyRoutesOfModule(
   const entryRouteDef = RouteDef.fromString(entryModule);
   const containingFile = _resolveModule(entryRouteDef.path, entryRouteDef.path, host);
   const modulePath = `./${containingFile.replace(/^(.*)\//, '')}`;
-  const className = entryRouteDef.className;
+  const className = entryRouteDef.className !;
 
   // List loadChildren of this single module.
   const appStaticSymbol = reflector.findDeclaration(modulePath, className, containingFile);

packages/compiler-cli/src/path_mapped_compiler_host.ts

@@ -40,7 +40,7 @@ export class PathMappedCompilerHost extends CompilerHost {
     return fileName;
   }
 
-  moduleNameToFileName(m: string, containingFile: string) {
+  moduleNameToFileName(m: string, containingFile: string): string|null {
     if (!containingFile || !containingFile.length) {
       if (m.indexOf('.') === 0) {
         throw new Error('Resolution of relative paths requires a containing file.');
@@ -59,6 +59,7 @@ export class PathMappedCompilerHost extends CompilerHost {
         return this.getCanonicalFileName(resolved.resolvedFileName);
       }
     }
+    return null;
   }
 
   /**
@@ -90,7 +91,7 @@ export class PathMappedCompilerHost extends CompilerHost {
 
     const importModuleName = importedFile.replace(EXT, '');
     const parts = importModuleName.split(path.sep).filter(p => !!p);
-    let foundRelativeImport: string;
+    let foundRelativeImport: string = undefined !;
     for (let index = parts.length - 1; index >= 0; index--) {
       let candidate = parts.slice(index, parts.length).join(path.sep);
       if (resolvable(candidate)) {
@@ -135,5 +136,6 @@ export class PathMappedCompilerHost extends CompilerHost {
         return metadata ? [metadata] : [];
       }
     }
+    return null !;
   }
 }

packages/compiler-cli/tsconfig-build.json

@@ -4,6 +4,7 @@
     "declaration": true,
     "experimentalDecorators": true,
     "noImplicitAny": true,
+    "strictNullChecks": true,
     "module": "commonjs",
     "outDir": "../../dist/packages/compiler-cli",
     "paths": {

packages/compiler/src/aot/compiler.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileProviderMetadata, componentFactoryName, createHostComponentMeta, flatten, identifierName, sourceUrl, templateSourceUrl} from '../compile_metadata';
+import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompileProviderMetadata, CompileTypeSummary, componentFactoryName, createHostComponentMeta, flatten, identifierName, sourceUrl, templateSourceUrl} from '../compile_metadata';
 import {CompilerConfig} from '../config';
 import {Identifiers, createIdentifier, createIdentifierToken} from '../identifiers';
 import {CompileMetadataResolver} from '../metadata_resolver';
@@ -32,8 +32,8 @@ export class AotCompiler {
       private _metadataResolver: CompileMetadataResolver, private _templateParser: TemplateParser,
       private _styleCompiler: StyleCompiler, private _viewCompiler: ViewCompiler,
       private _ngModuleCompiler: NgModuleCompiler, private _outputEmitter: OutputEmitter,
-      private _summaryResolver: SummaryResolver<StaticSymbol>, private _localeId: string,
-      private _translationFormat: string, private _genFilePreamble: string,
+      private _summaryResolver: SummaryResolver<StaticSymbol>, private _localeId: string|null,
+      private _translationFormat: string|null, private _genFilePreamble: string|null,
       private _symbolResolver: StaticSymbolResolver) {}
 
   clearCache() { this._metadataResolver.clearCache(); }
@@ -113,11 +113,11 @@ export class AotCompiler {
       targetExportedVars: string[]): GeneratedFile {
     const symbolSummaries = this._symbolResolver.getSymbolsOf(srcFileUrl)
                                 .map(symbol => this._symbolResolver.resolveSymbol(symbol));
-    const typeSummaries = [
-      ...ngModules.map(ref => this._metadataResolver.getNgModuleSummary(ref)),
-      ...directives.map(ref => this._metadataResolver.getDirectiveSummary(ref)),
-      ...pipes.map(ref => this._metadataResolver.getPipeSummary(ref)),
-      ...injectables.map(ref => this._metadataResolver.getInjectableSummary(ref))
+    const typeSummaries: CompileTypeSummary[] = [
+      ...ngModules.map(ref => this._metadataResolver.getNgModuleSummary(ref) !),
+      ...directives.map(ref => this._metadataResolver.getDirectiveSummary(ref) !),
+      ...pipes.map(ref => this._metadataResolver.getPipeSummary(ref) !),
+      ...injectables.map(ref => this._metadataResolver.getInjectableSummary(ref) !)
     ];
     const {json, exportAs} = serializeSummaries(
         this._summaryResolver, this._symbolResolver, symbolSummaries, typeSummaries);
@@ -130,7 +130,7 @@ export class AotCompiler {
   }
 
   private _compileModule(ngModuleType: StaticSymbol, targetStatements: o.Statement[]): string {
-    const ngModule = this._metadataResolver.getNgModuleMetadata(ngModuleType);
+    const ngModule = this._metadataResolver.getNgModuleMetadata(ngModuleType) !;
     const providers: CompileProviderMetadata[] = [];
 
     if (this._localeId) {
@@ -183,19 +183,19 @@ export class AotCompiler {
               o.variable(hostViewFactoryVar), new o.LiteralMapExpr(inputsExprs),
               new o.LiteralMapExpr(outputsExprs),
               o.literalArr(
-                  compMeta.template.ngContentSelectors.map(selector => o.literal(selector)))
+                  compMeta.template !.ngContentSelectors.map(selector => o.literal(selector)))
             ]))
             .toDeclStmt(
                 o.importType(
-                    createIdentifier(Identifiers.ComponentFactory), [o.importType(compMeta.type)],
+                    createIdentifier(Identifiers.ComponentFactory), [o.importType(compMeta.type) !],
                     [o.TypeModifier.Const]),
                 [o.StmtModifier.Final]));
     return compFactoryVar;
   }
 
   private _compileComponent(
       compMeta: CompileDirectiveMetadata, ngModule: CompileNgModuleMetadata,
-      directiveIdentifiers: CompileIdentifierMetadata[], componentStyles: CompiledStylesheet,
+      directiveIdentifiers: CompileIdentifierMetadata[], componentStyles: CompiledStylesheet|null,
       fileSuffix: string,
       targetStatements: o.Statement[]): {viewClassVar: string, compRenderTypeVar: string} {
     const directives =
@@ -204,8 +204,8 @@ export class AotCompiler {
         pipe => this._metadataResolver.getPipeSummary(pipe.reference));
 
     const {template: parsedTemplate, pipes: usedPipes} = this._templateParser.parse(
-        compMeta, compMeta.template.template, directives, pipes, ngModule.schemas,
-        templateSourceUrl(ngModule.type, compMeta, compMeta.template));
+        compMeta, compMeta.template !.template !, directives, pipes, ngModule.schemas,
+        templateSourceUrl(ngModule.type, compMeta, compMeta.template !));
     const stylesExpr = componentStyles ? o.variable(componentStyles.stylesVar) : o.literalArr([]);
     const viewResult =
         this._viewCompiler.compileComponent(compMeta, parsedTemplate, stylesExpr, usedPipes);
@@ -221,8 +221,9 @@ export class AotCompiler {
       fileUrl: string, stylesCompileResult: CompiledStylesheet, fileSuffix: string): GeneratedFile {
     _resolveStyleStatements(this._symbolResolver, stylesCompileResult, fileSuffix);
     return this._codegenSourceModule(
-        fileUrl, _stylesModuleUrl(
-                     stylesCompileResult.meta.moduleUrl, stylesCompileResult.isShimmed, fileSuffix),
+        fileUrl,
+        _stylesModuleUrl(
+            stylesCompileResult.meta.moduleUrl !, stylesCompileResult.isShimmed, fileSuffix),
         stylesCompileResult.statements, [stylesCompileResult.stylesVar]);
   }
 

packages/compiler/src/aot/compiler_factory.ts

@@ -70,15 +70,16 @@ export function createAotCompiler(compilerHost: AotCompilerHost, options: AotCom
       console, symbolCache, staticReflector);
   // TODO(vicb): do not pass options.i18nFormat here
   const importResolver = {
-    getImportAs: (symbol: StaticSymbol) => symbolResolver.getImportAs(symbol),
+    getImportAs: (symbol: StaticSymbol) => symbolResolver.getImportAs(symbol) !,
     fileNameToModuleName: (fileName: string, containingFilePath: string) =>
                               compilerHost.fileNameToModuleName(fileName, containingFilePath),
-    getTypeArity: (symbol: StaticSymbol) => symbolResolver.getTypeArity(symbol)
+    getTypeArity: (symbol: StaticSymbol) => symbolResolver.getTypeArity(symbol) !
   };
   const viewCompiler = new ViewCompiler(config, elementSchemaRegistry);
   const compiler = new AotCompiler(
       config, compilerHost, resolver, tmplParser, new StyleCompiler(urlResolver), viewCompiler,
       new NgModuleCompiler(), new TypeScriptEmitter(importResolver), summaryResolver,
-      options.locale, options.i18nFormat, options.genFilePreamble, symbolResolver);
+      options.locale || null, options.i18nFormat || null, options.genFilePreamble || null,
+      symbolResolver);
   return {compiler, reflector: staticReflector};
 }

packages/compiler/src/aot/compiler_host.ts

@@ -20,8 +20,7 @@ export interface AotCompilerHost extends StaticSymbolResolverHost, AotSummaryRes
    *
    * See ImportResolver.
    */
-  fileNameToModuleName(importedFilePath: string, containingFilePath: string): string
-      /*|null*/;
+  fileNameToModuleName(importedFilePath: string, containingFilePath: string): string|null;
 
   /**
    * Loads a resource (e.g. html / css)

packages/compiler/src/aot/static_reflection_capabilities.ts

@@ -41,7 +41,7 @@ export class StaticAndDynamicReflectionCapabilities {
   getter(name: string): ɵGetterFn { return this.dynamicDelegate.getter(name); }
   setter(name: string): ɵSetterFn { return this.dynamicDelegate.setter(name); }
   method(name: string): ɵMethodFn { return this.dynamicDelegate.method(name); }
-  importUri(type: any): string { return this.staticDelegate.importUri(type); }
+  importUri(type: any): string { return this.staticDelegate.importUri(type) !; }
   resourceUri(type: any): string { return this.staticDelegate.resourceUri(type); }
   resolveIdentifier(name: string, moduleUrl: string, members: string[], runtime: any) {
     return this.staticDelegate.resolveIdentifier(name, moduleUrl, members);

packages/compiler/src/aot/static_reflector.ts

@@ -47,7 +47,7 @@ export class StaticReflector implements ɵReflectorReader {
       private symbolResolver: StaticSymbolResolver,
       knownMetadataClasses: {name: string, filePath: string, ctor: any}[] = [],
       knownMetadataFunctions: {name: string, filePath: string, fn: any}[] = [],
-      private errorRecorder?: (error: any, fileName: string) => void) {
+      private errorRecorder?: (error: any, fileName?: string) => void) {
     this.initializeConversionMap();
     knownMetadataClasses.forEach(
         (kc) => this._registerDecoratorOrConstructor(
@@ -67,7 +67,7 @@ export class StaticReflector implements ɵReflectorReader {
     this.annotationNames.set(Injectable, 'Injectable');
   }
 
-  importUri(typeOrFunc: StaticSymbol): string {
+  importUri(typeOrFunc: StaticSymbol): string|null {
     const staticSymbol = this.findSymbolDeclaration(typeOrFunc);
     return staticSymbol ? staticSymbol.filePath : null;
   }
@@ -129,14 +129,14 @@ export class StaticReflector implements ɵReflectorReader {
         const summary = this.summaryResolver.resolveSummary(parentType);
         if (summary && summary.type) {
           const requiredAnnotationTypes =
-              this.annotationForParentClassWithSummaryKind.get(summary.type.summaryKind);
+              this.annotationForParentClassWithSummaryKind.get(summary.type.summaryKind !) !;
           const typeHasRequiredAnnotation = requiredAnnotationTypes.some(
-              requiredType => ownAnnotations.some(ann => ann instanceof requiredType));
+              (requiredType: any) => ownAnnotations.some(ann => ann instanceof requiredType));
           if (!typeHasRequiredAnnotation) {
             this.reportError(
                 syntaxError(
-                    `Class ${type.name} in ${type.filePath} extends from a ${CompileSummaryKind[summary.type.summaryKind]} in another compilation unit without duplicating the decorator. ` +
-                    `Please add a ${requiredAnnotationTypes.map(type => this.annotationNames.get(type)).join(' or ')} decorator to the class.`),
+                    `Class ${type.name} in ${type.filePath} extends from a ${CompileSummaryKind[summary.type.summaryKind!]} in another compilation unit without duplicating the decorator. ` +
+                    `Please add a ${requiredAnnotationTypes.map((type: any) => this.annotationNames.get(type)).join(' or ')} decorator to the class.`),
                 type);
           }
         }
@@ -155,7 +155,7 @@ export class StaticReflector implements ɵReflectorReader {
       if (parentType) {
         const parentPropMetadata = this.propMetadata(parentType);
         Object.keys(parentPropMetadata).forEach((parentProp) => {
-          propMetadata[parentProp] = parentPropMetadata[parentProp];
+          propMetadata ![parentProp] = parentPropMetadata[parentProp];
         });
       }
 
@@ -165,10 +165,10 @@ export class StaticReflector implements ɵReflectorReader {
         const prop = (<any[]>propData)
                          .find(a => a['__symbolic'] == 'property' || a['__symbolic'] == 'method');
         const decorators: any[] = [];
-        if (propMetadata[propName]) {
-          decorators.push(...propMetadata[propName]);
+        if (propMetadata ![propName]) {
+          decorators.push(...propMetadata ![propName]);
         }
-        propMetadata[propName] = decorators;
+        propMetadata ![propName] = decorators;
         if (prop && prop['decorators']) {
           decorators.push(...this.simplify(type, prop['decorators']));
         }
@@ -206,7 +206,7 @@ export class StaticReflector implements ɵReflectorReader {
             if (decorators) {
               nestedResult.push(...decorators);
             }
-            parameters.push(nestedResult);
+            parameters !.push(nestedResult);
           });
         } else if (parentType) {
           parameters = this.parameters(parentType);
@@ -232,22 +232,22 @@ export class StaticReflector implements ɵReflectorReader {
       if (parentType) {
         const parentMethodNames = this._methodNames(parentType);
         Object.keys(parentMethodNames).forEach((parentProp) => {
-          methodNames[parentProp] = parentMethodNames[parentProp];
+          methodNames ![parentProp] = parentMethodNames[parentProp];
         });
       }
 
       const members = classMetadata['members'] || {};
       Object.keys(members).forEach((propName) => {
         const propData = members[propName];
         const isMethod = (<any[]>propData).some(a => a['__symbolic'] == 'method');
-        methodNames[propName] = methodNames[propName] || isMethod;
+        methodNames ![propName] = methodNames ![propName] || isMethod;
       });
       this.methodCache.set(type, methodNames);
     }
     return methodNames;
   }
 
-  private findParentType(type: StaticSymbol, classMetadata: any): StaticSymbol|null {
+  private findParentType(type: StaticSymbol, classMetadata: any): StaticSymbol|undefined {
     const parentType = this.trySimplify(type, classMetadata['extends']);
     if (parentType instanceof StaticSymbol) {
       return parentType;