Improve strict null checks compliance

devversion · devversion · commit 85ded36d0fbb · 2018-09-06T12:36:22.000+02:00
diff --git a/src/lib/schematics/install/fonts/head-element.ts b/src/lib/schematics/install/fonts/head-element.ts
@@ -33,6 +33,8 @@ export function appendElementToHead(host: Tree, project: WorkspaceProject, eleme
     throw `Could not find '<head>' element in HTML file: ${indexPath}`;
   }
 
+  // We always have access to the source code location here because the `getHeadTagElement`
+  // function explicitly has the `sourceCodeLocationInfo` option enabled.
   const endTagOffset = headTag.sourceCodeLocation!.endTag.startOffset;
   const indentationOffset = getChildElementIndentation(headTag);
   const insertion = `${' '.repeat(indentationOffset)}${elementHtml}`;
diff --git a/src/lib/schematics/install/fonts/project-index-html.ts b/src/lib/schematics/install/fonts/project-index-html.ts
@@ -8,14 +8,15 @@
 
 import {SchematicsException} from '@angular-devkit/schematics';
 import {WorkspaceProject} from '@schematics/angular/utility/config';
+import {getArchitectOptions} from '../../utils/architect-options';
 
 /** Looks for the index HTML file in the given project and returns its path. */
 export function getIndexHtmlPath(project: WorkspaceProject): string {
-  const buildTarget = project.architect!.build.options;
+  const buildOptions = getArchitectOptions(project, 'build');
 
-  if (buildTarget.index && buildTarget.index.endsWith('index.html')) {
-    return buildTarget.index;
+  if (!buildOptions.index) {
+    throw new SchematicsException('No project "index.html" file could be found.');
   }
 
-  throw new SchematicsException('No project "index.html" file could be found.');
+  return buildOptions.index;
 }
diff --git a/src/lib/schematics/install/gestures/hammerjs-import.ts b/src/lib/schematics/install/gestures/hammerjs-import.ts
@@ -10,7 +10,7 @@ import {Rule, Tree} from '@angular-devkit/schematics';
 import {getWorkspace} from '@schematics/angular/utility/config';
 import {getProjectFromWorkspace} from '../../utils/get-project';
 import {Schema} from '../schema';
-import {getProjectMainFile} from './project-main-file';
+import {getProjectMainFile} from '../../utils/project-main-file';
 
 const hammerjsImportStatement = `import 'hammerjs';`;
 
diff --git a/src/lib/schematics/install/theming/theming.ts b/src/lib/schematics/install/theming/theming.ts
@@ -59,8 +59,10 @@ function insertCustomTheme(project: WorkspaceProject, projectName: string, host:
     const customThemePath = normalize(join(project.sourceRoot, 'custom-theme.scss'));
 
     host.create(customThemePath, themeContent);
-    addStyleToTarget(project.architect!['build'], host, customThemePath, workspace);
-    return;
+
+    // Architect is always defined because we initially asserted if the default builder
+    // configuration is set up or not.
+    return addStyleToTarget(project.architect!['build'], host, customThemePath, workspace);
   }
 
   const insertion = new InsertChange(stylesPath, 0, themeContent);
@@ -77,12 +79,10 @@ function insertPrebuiltTheme(project: WorkspaceProject, host: Tree, theme: strin
   // Path needs to be always relative to the `package.json` or workspace root.
   const themePath =  `./node_modules/@angular/material/prebuilt-themes/${theme}.css`;
 
-  if (project.architect) {
-    addStyleToTarget(project.architect['build'], host, themePath, workspace);
-    addStyleToTarget(project.architect['test'], host, themePath, workspace);
-  } else {
-    throw new SchematicsException(`${projectName} does not have an architect configuration`);
-  }
+  // Architect is always defined because we initially asserted if the default builder
+  // configuration is set up or not.
+  addStyleToTarget(project.architect!['build'], host, themePath, workspace);
+  addStyleToTarget(project.architect!['test'], host, themePath, workspace);
 }
 
 /** Adds a style entry to the given target. */
diff --git a/src/lib/schematics/update/rules/signature-check/constructorSignatureCheckRule.ts b/src/lib/schematics/update/rules/signature-check/constructorSignatureCheckRule.ts
@@ -40,7 +40,8 @@ export class Walker extends ProgramAwareRuleWalker {
     return signature.getParameters()
       .map(param => param.declarations[0] as ts.ParameterDeclaration)
       .map(node => node.type)
-      .map(node => this.getTypeChecker().getTypeFromTypeNode(node));
+      // TODO(devversion): handle non resolvable constructor types
+      .map(typeNode => this.getTypeChecker().getTypeFromTypeNode(typeNode!));
   }
 
   private checkExpressionSignature(node: ts.CallExpression | ts.NewExpression) {
@@ -50,7 +51,7 @@ export class Walker extends ProgramAwareRuleWalker {
 
     // TODO(devversion): Consider handling pass-through classes better.
     // TODO(devversion): e.g. `export class CustomCalendar extends MatCalendar {}`
-    if (!classType || !constructorChecks.includes(className)) {
+    if (!classType || !constructorChecks.includes(className) || !node.arguments) {
       return;
     }
 
@@ -62,6 +63,8 @@ export class Walker extends ProgramAwareRuleWalker {
     // TODO(devversion): we should check if the type is assignable to the signature
     // TODO(devversion): blocked on https://github.com/Microsoft/TypeScript/issues/9879
     const doesMatchSignature = classSignatures.some(signature => {
+      // TODO(devversion): better handling if signature item type is unresolved but assignable
+      // to everything.
       return signature.every((type, index) => callExpressionSignature[index] === type) &&
           signature.length === callExpressionSignature.length;
     });
diff --git a/src/lib/schematics/utils/architect-options.ts b/src/lib/schematics/utils/architect-options.ts
@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {WorkspaceProject} from '@schematics/angular/utility/config';
+
+/** Resolves the architect options for the build target of the given project. */
+export function getArchitectOptions(project: WorkspaceProject, buildTarget: string) {
+  if (project.architect &&
+      project.architect[buildTarget] &&
+      project.architect[buildTarget].options) {
+
+    return project.architect[buildTarget].options;
+  }
+
+  throw new Error(`Cannot determine architect configuration for target: ${buildTarget}.`);
+}
diff --git a/src/lib/schematics/utils/ast.ts b/src/lib/schematics/utils/ast.ts
@@ -7,13 +7,14 @@
  */
 
 import {SchematicsException, Tree} from '@angular-devkit/schematics';
+import {Schema as ComponentOptions} from '@schematics/angular/component/schema';
 import {addImportToModule} from '@schematics/angular/utility/ast-utils';
 import {InsertChange} from '@schematics/angular/utility/change';
 import {getWorkspace, WorkspaceProject} from '@schematics/angular/utility/config';
 import {findModuleFromOptions as internalFindModule} from '@schematics/angular/utility/find-module';
 import {getAppModulePath} from '@schematics/angular/utility/ng-ast-utils';
-import {Schema as ComponentOptions} from '@schematics/angular/component/schema';
 import * as ts from 'typescript';
+import {getProjectMainFile} from './project-main-file';
 
 
 /** Reads file given path and returns TypeScript source file. */
@@ -29,8 +30,7 @@ export function getSourceFile(host: Tree, path: string): ts.SourceFile {
 /** Import and add module to root app module. */
 export function addModuleImportToRootModule(host: Tree, moduleName: string, src: string,
                                             project: WorkspaceProject) {
-
-  const modulePath = getAppModulePath(host, project.architect!.build.options.main);
+  const modulePath = getAppModulePath(host, getProjectMainFile(project));
   addModuleImportToModule(host, modulePath, moduleName, src);
 }
 
diff --git a/src/lib/schematics/utils/parse5-element.ts b/src/lib/schematics/utils/parse5-element.ts
@@ -13,6 +13,11 @@ export function getChildElementIndentation(element: DefaultTreeElement) {
   const childElement = element.childNodes
     .find(node => node['tagName']) as DefaultTreeElement | null;
 
+  if ((childElement && !childElement.sourceCodeLocation) || !element.sourceCodeLocation) {
+    throw new Error('Cannot determine child element indentation because the specified Parse5 ' +
+        'element does not have any source code location metadata.');
+  }
+
   const startColumns = childElement ?
     // In case there are child elements inside of the element, we assume that their
     // indentation is also applicable for other child elements.
diff --git a/src/lib/schematics/utils/project-main-file.ts b/src/lib/schematics/utils/project-main-file.ts
@@ -8,15 +8,16 @@
 
 import {SchematicsException} from '@angular-devkit/schematics';
 import {WorkspaceProject} from '@schematics/angular/utility/config';
+import {getArchitectOptions} from './architect-options';
 
 /** Looks for the main TypeScript file in the given project and returns its path. */
 export function getProjectMainFile(project: WorkspaceProject): string {
-  const buildTarget = project.architect!.build.options;
+  const buildOptions = getArchitectOptions(project, 'build');
 
-  if (buildTarget.main) {
-    return buildTarget.main;
+  if (!buildOptions.main) {
+    throw new SchematicsException(`Could not find the project main file inside of the ` +
+        `workspace config (${project.sourceRoot})`);
   }
 
-  throw new SchematicsException(
-    'Could not find the project main file inside of the workspace config.');
+  return buildOptions.main;
 }
diff --git a/src/lib/schematics/utils/project-style-file.ts b/src/lib/schematics/utils/project-style-file.ts
@@ -8,6 +8,7 @@
 
 import {normalize} from '@angular-devkit/core';
 import {WorkspaceProject} from '@schematics/angular/utility/config';
+import {getArchitectOptions} from './architect-options';
 
 /** Regular expression that matches all possible Angular CLI default style files. */
 const defaultStyleFileRegex = /styles\.(c|le|sc)ss/;
@@ -20,14 +21,10 @@ const validStyleFileRegex = /\.(c|le|sc)ss/;
  * extension is specified, any style file with a valid extension will be returned.
  */
 export function getProjectStyleFile(project: WorkspaceProject, extension?: string): string | null {
-  if (!project.architect || !project.architect['build']) {
-    return null;
-  }
-
-  const target = project.architect['build'];
+  const buildOptions = getArchitectOptions(project, 'build');
 
-  if (target.options && target.options.styles && target.options.styles.length) {
-    const styles = target.options.styles.map(s => typeof s === 'string' ? s : s.input);
+  if (buildOptions.styles && buildOptions.styles.length) {
+    const styles = buildOptions.styles.map(s => typeof s === 'string' ? s : s.input);
 
     // Look for the default style file that is generated for new projects by the Angular CLI. This
     // default style file is usually called `styles.ext` unless it has been changed explicitly.

Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,8 @@ export function appendElementToHead(host: Tree, project: WorkspaceProject, eleme`
`33`	`33`	throw `Could not find '<head>' element in HTML file: ${indexPath}`;
`34`	`34`	`}`
`35`	`35`
	`36`	+ // We always have access to the source code location here because the `getHeadTagElement`
	`37`	+ // function explicitly has the `sourceCodeLocationInfo` option enabled.
`36`	`38`	`const endTagOffset = headTag.sourceCodeLocation!.endTag.startOffset;`
`37`	`39`	`const indentationOffset = getChildElementIndentation(headTag);`
`38`	`40`	const insertion = `${' '.repeat(indentationOffset)}${elementHtml}`;