Strict null checks!

.gitignore

@@ -4,6 +4,7 @@
 .baseDir.js
 .baseDir.ts
 yarn.lock
+yarn-error.log
 
 /src/typings/typescript/typescript.js
 

.vscode/launch.json

@@ -7,17 +7,19 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Launch Program",
+            "name": "Debug Tests",
             "program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
             "cwd": "${workspaceRoot}",
             "args": [
-                "--no-timeouts"
+                "--no-timeouts",
+                "dist/test/**/*.js"
             ],
             "outFiles": [
                 "${workspaceRoot}/lib/**/*.js",
                 "${workspaceRoot}/test/**/*.js"
             ],
+            "preLaunchTask": "build",
             "sourceMaps": true
         }
     ]
-}
+}

.vscode/tasks.json

@@ -1,11 +1,23 @@
 {
-    // See https://go.microsoft.com/fwlink/?LinkId=733558
-    // for the documentation about the tasks.json format
-    "version": "0.1.0",
-    "command": "tsc",
-    "isShellCommand": true,
-    "args": ["-w", "-p", "."],
-    "showOutput": "silent",
-    "isWatching": true,
-    "problemMatcher": "$tsc-watch"
-}
+  // See https://go.microsoft.com/fwlink/?LinkId=733558
+  // for the documentation about the tasks.json format
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "identifier": "build",
+      "type": "grunt",
+      "task": "default",
+      "problemMatcher": [
+        "$tsc"
+      ]
+    },
+    {
+      "identifier": "build_and_test",
+      "type": "grunt",
+      "task": "build_and_test",
+      "problemMatcher": [
+        "$tsc"
+      ]
+    }
+  ]
+}

src/lib/application.ts

@@ -17,7 +17,7 @@ import { Serializer } from './serialization';
 import { ProjectReflection } from './models/index';
 import { Logger, ConsoleLogger, CallbackLogger, PluginHost, writeFile } from './utils/index';
 
-import { AbstractComponent, ChildableComponent, Component, Option } from './utils/component';
+import { AbstractComponent, ChildableComponent, Component, Option, DUMMY_APPLICATION_OWNER } from './utils/component';
 import { Options, OptionsReadMode, OptionsReadResult } from './utils/options/index';
 import { ParameterType } from './utils/options/declaration';
 
@@ -67,21 +67,21 @@ export class Application extends ChildableComponent<Application, AbstractCompone
         defaultValue: 'console',
         type: ParameterType.Mixed
     })
-    loggerType: string|Function;
+    readonly loggerType!: string|Function;
 
     @Option({
         name: 'ignoreCompilerErrors',
         help: 'Should TypeDoc generate documentation pages even after the compiler has returned errors?',
         type: ParameterType.Boolean
     })
-    ignoreCompilerErrors: boolean;
+    readonly ignoreCompilerErrors!: boolean;
 
     @Option({
         name: 'exclude',
         help: 'Define patterns for excluded files when specifying paths.',
         type: ParameterType.Array
     })
-    exclude: Array<string>;
+    readonly exclude!: Array<string>;
 
     /**
      * The version number of TypeDoc.
@@ -94,7 +94,7 @@ export class Application extends ChildableComponent<Application, AbstractCompone
      * @param options An object containing the options that should be used.
      */
     constructor(options?: Object) {
-        super(null);
+        super(DUMMY_APPLICATION_OWNER);
 
         this.logger    = new ConsoleLogger();
         this.converter = this.addComponent<Converter>('converter', Converter);
@@ -153,9 +153,9 @@ export class Application extends ChildableComponent<Application, AbstractCompone
      * Run the converter for the given set of files and return the generated reflections.
      *
      * @param src  A list of source that should be compiled and converted.
-     * @returns An instance of ProjectReflection on success, NULL otherwise.
+     * @returns An instance of ProjectReflection on success, undefined otherwise.
      */
-    public convert(src: string[]): ProjectReflection {
+    public convert(src: string[]): ProjectReflection | undefined {
         this.logger.writeln('Using TypeScript %s from %s', this.getTypeScriptVersion(), this.getTypeScriptPath());
 
         const result = this.converter.convert(src);
@@ -165,7 +165,7 @@ export class Application extends ChildableComponent<Application, AbstractCompone
                 this.logger.resetErrors();
                 return result.project;
             } else {
-                return null;
+                return;
             }
         } else {
             return result.project;
@@ -188,7 +188,7 @@ export class Application extends ChildableComponent<Application, AbstractCompone
      * @param out  The path the documentation should be written to.
      * @returns TRUE if the documentation could be generated successfully, otherwise FALSE.
      */
-    public generateDocs(input: any, out: string): boolean {
+    public generateDocs(input: ProjectReflection | string[], out: string): boolean {
         const project = input instanceof ProjectReflection ? input : this.convert(input);
         if (!project) {
             return false;
@@ -246,7 +246,7 @@ export class Application extends ChildableComponent<Application, AbstractCompone
      * @param inputFiles  The list of files that should be expanded.
      * @returns  The list of input files with expanded directories.
      */
-    public expandInputFiles(inputFiles?: string[]): string[] {
+    public expandInputFiles(inputFiles: string[] = []): string[] {
         let files: string[] = [];
         const exclude: Array<IMinimatch> = this.exclude ? this.exclude.map(pattern => new Minimatch(pattern, {dot: true})) : [];
 

src/lib/cli.ts

@@ -20,39 +20,38 @@ export class CliApplication extends Application {
         help:  'Specifies the location the documentation should be written to.',
         hint:  ParameterHint.Directory
     })
-    out: string;
+    out!: string;
 
     @Option({
         name:  'json',
         help:  'Specifies the location and file name a json file describing the project is written to.',
         hint:  ParameterHint.File
     })
-    json: string;
+    json!: string;
 
     @Option({
         name:  'version',
         short: 'v',
         help:  'Print the TypeDoc\'s version.',
         type:  ParameterType.Boolean
     })
-    version: boolean;
+    version!: boolean;
 
     @Option({
         name:  'help',
         short: 'h',
         help:  'Print this message.',
         type:  ParameterType.Boolean
     })
-    help: boolean;
+    help!: boolean;
 
     /**
      * Run TypeDoc from the command line.
      */
     protected bootstrap(options?: Object): OptionsReadResult {
         const result = super.bootstrap(options);
         if (result.hasErrors) {
-            process.exit(ExitCode.OptionError);
-            return;
+            return process.exit(ExitCode.OptionError);
         }
 
         if (this.version) {

src/lib/converter/components.ts

@@ -14,9 +14,9 @@ export abstract class ConverterNodeComponent<T extends ts.Node> extends Converte
     /**
      * List of supported TypeScript syntax kinds.
      */
-    supports: ts.SyntaxKind[];
+    abstract supports: ts.SyntaxKind[];
 
-    abstract convert(context: Context, node: T): Reflection;
+    abstract convert(context: Context, node: T): Reflection | undefined;
 }
 
 export abstract class ConverterTypeComponent extends ConverterComponent {
@@ -39,17 +39,17 @@ export interface TypeTypeConverter<T extends ts.Type> extends ConverterTypeCompo
     /**
      * Convert the given type to its type reflection.
      */
-    convertType(context: Context, type: T): Type;
+    convertType(context: Context, type: T): Type | undefined;
 }
 
 export interface TypeNodeConverter<T extends ts.Type, N extends ts.Node> extends ConverterTypeComponent {
     /**
      * Test whether this converter can handle the given TypeScript node.
      */
-    supportsNode(context: Context, node: N, type: T): boolean;
+    supportsNode(context: Context, node: N, type: T | undefined): boolean;
 
     /**
      * Convert the given type node to its type reflection.
      */
-    convertNode(context: Context, node: N, type: T): Type;
+    convertNode(context: Context, node: N, type: T | undefined): Type | undefined;
 }