Add ability to easily get diagnostics.

.gitignore

@@ -4,6 +4,7 @@
 /obj
 /temp
 /bin
+/dist-cg
 *.suo
 *.csproj
 *.csproj.user

.npmignore

@@ -2,6 +2,7 @@
 /node_modules
 /coverage
 /.vscode
+/code-generation
 /src
 *.js.map
 /obj

docs/_layouts/default.html

@@ -40,12 +40,13 @@ <h1 onclick="document.location.href = '{{ "/" | prepend: site.baseurl }}'" class
                                 <ul>
                                     <li class="{% if page.path == 'setup/index.md' %}active{% endif %}"><a href="{{ "/setup/index" | prepend: site.baseurl }}">Instantiating</a></li>
                                     <li class="{% if page.path == 'setup/adding-sourcefiles.md' %}active{% endif %}"><a href="{{ "/setup/adding-sourcefiles" | prepend: site.baseurl }}">Adding SourceFiles</a></li>
+                                    <li class="{% if page.path == 'setup/diagnostics.md' %}active{% endif %}"><a href="{{ "/setup/diagnostics" | prepend: site.baseurl }}">Diagnostics</a></li>
                                 </ul>
                                 {% endif %}
                             </li>
                             <li class="nav-item{% if page.dir == '/navigation/' %} active{% endif %}">
                                 <a class="nav-link" href="{{ "/navigation" | prepend: site.baseurl }}">Navigation</a>
-                                {% if page.dir == '/navigation/' or page.dir == '/navigation/details/' %}
+                                {% if page.dir == '/navigation/' %}
                                 <ul>
                                     <li class="{% if page.path == 'navigation/getting-sourcefiles.md' %}active{% endif %}"><a href="{{ "/navigation/getting-sourcefiles" | prepend: site.baseurl }}">Getting SourceFiles</a></li>
                                     <li class="{% if page.path == 'navigation/example.md' %}active{% endif %}"><a href="{{ "/navigation/example" | prepend: site.baseurl }}">Example</a></li>

docs/details/expressions.md

@@ -0,0 +1,20 @@
+---
+title: Expressions
+---
+
+## Expression With Type Arguments
+
+These are found in certain areas. For example `extends` and `implements` expressions.
+
+### Getting expression
+
+```typescript
+// returns: ts.LeftHandSideExpression
+const expression = expressionWithTypeArgs.getExpression(); // returns: Node
+```
+
+### Getting type arguments
+
+```typescript
+const typeArgs = expressionWithTypeArgs.getTypeArguments(); // returns: TypeNode[]
+```

docs/setup/adding-sourcefiles.md

@@ -11,7 +11,7 @@ You will need to populate the `ast` object with source files.
 Specify as many file globs or file paths as you wish:
 
 ```typescript
-ast.addSourceFiles("folder/**/*.ts");
+ast.addSourceFiles("folder/**/*{.d.ts,.ts}");
 ast.addSourceFiles("otherFolder/file.ts", "specifyAnotherFile.ts", "orAnotherGlob/**/*.ts");
 ```
 
@@ -33,4 +33,4 @@ const sourceFile = ast.addSourceFileFromText("path/for/myNewFile.ts", fileText);
 sourceFile.save(); // or saveSync();
 ```
 
-**Next step:** [Navigating the AST](../navigation/index)
+**Next step:** [Diagnostics](diagnostics)

docs/setup/diagnostics.md

@@ -0,0 +1,95 @@
+---
+title: Diagnostics
+---
+
+## Diagnostics
+
+Diagnostics (compile errors) can be retrieved on the AST or on source files by using the `.getDiagnostics()` method:
+
+```typescript
+const diagnostics = ast.getDiagnostics();
+```
+
+Calling it on a source file will only give you the diagnostics for that source file.
+
+### Diagnostic
+
+#### Message text
+
+Returned message text could be a `string` or a `DiagnosticMessageChain`:
+
+```typescript
+const message = diagnostic.getMessageText();
+```
+
+#### Source file
+
+Source file the diagnostic occurs in:
+
+```typescript
+const sourceFile = diagnostic.getSourceFile();
+```
+
+#### Start & length
+
+Position in the file and length of the diagnostic:
+
+```typescript
+const start = diagnostic.getStart();   // returns: number
+const length = diagnostic.getLength(); // returns: number
+```
+
+#### Category
+
+Categories can be warnings, errors, or just messages.
+
+```typescript
+const category = diagnostic.getCategory(); // returns: ts.DiagnosticCategory
+```
+
+#### Code
+
+This is the error code number:
+
+```typescript
+const code = diagnostic.getCode(); // returns: number
+```
+
+#### Source
+
+```typescript
+const source = diagnostic.getSource(); // returns: string | undefined
+```
+
+### DiagnosticMessageChain
+
+A diagnostic message chain (DMC) will be returned by `diagnostic.getMessageText()` in certain scenarios.
+
+According to the typescript compiler:
+
+```
+/**
+* A linked list of formatted diagnostic messages to be used as part of a multiline message.
+* It is built from the bottom up, leaving the head to be the "main" diagnostic.
+* While it seems that DiagnosticMessageChain is structurally similar to DiagnosticMessage,
+* the difference is that messages are all preformatted in DMC.
+*/
+```
+
+The properties of a DMC are similar to a Diagnostic:
+
+```typescript
+const messageText = dmc.getMessageText(); // returns: string
+const category = dmc.getCategory();       // returns: ts.DiagnosticCategory
+const code = dmc.getCode();               // returns: number
+```
+
+#### Next DMC in linked list
+
+Call `.getNext()`:
+
+```typescript
+const next = dmc.getNext(); // returns: DiagnosticMessageChain | undefined
+```
+
+**Next step:** [Navigating the AST](../navigation/index)

gulpfile.js

@@ -48,7 +48,7 @@ gulp.task("test", ["pre-test"], function() {
 });
 
 gulp.task("tslint", function() {
-    return gulp.src(["./src/**/*.ts", "!./src/typings/**/*.d.ts"])
+    return gulp.src(["./src/**/*.ts", "!./src/typings/**/*.d.ts", "./code-generation/**/*.ts"])
         .pipe(tslint({ formatter: "verbose" }))
         .pipe(tslint.report());
 });

src/TsSimpleAst.ts

@@ -100,9 +100,19 @@ export class TsSimpleAst {
     }
 
     /**
-     * Gets a type checker.
+     * Gets the compiler diagnostics.
+     * @param program - Optional program.
      */
-    getTypeChecker(): compiler.TypeChecker {
-        return this.compilerFactory.getTypeChecker();
+    getDiagnostics(program: compiler.Program = this.compilerFactory.getLanguageService().getProgram()): compiler.Diagnostic[] {
+        // todo: implement cancellation token
+        const compilerDiagnostics = ts.getPreEmitDiagnostics(program.getCompilerProgram());
+        return compilerDiagnostics.map(d => this.compilerFactory.getDiagnostic(d));
+    }
+
+    /**
+     * Gets a language service.
+     */
+    getLanguageService(): compiler.LanguageService {
+        return this.compilerFactory.getLanguageService();
     }
 }

src/compiler/base/ExportableNode.ts

@@ -65,7 +65,7 @@ export function ExportableNode<T extends Constructor<ExportableNodeExtensionType
             if (thisSymbol.equals(defaultExportSymbol))
                 return true;
 
-            const aliasedSymbol = typeChecker.getAliasedSymbol(defaultExportSymbol);
+            const aliasedSymbol = defaultExportSymbol.getAliasedSymbol(typeChecker);
             return thisSymbol.equals(aliasedSymbol);
         }
 

src/compiler/common/Symbol.ts

@@ -35,6 +35,14 @@ export class Symbol {
         return this.symbol.getName();
     }
 
+    /**
+     * Gets the aliased symbol.
+     * @param typeChecker - Optional type checker.
+     */
+    getAliasedSymbol(typeChecker: TypeChecker = this.factory.getTypeChecker()): Symbol | undefined {
+        return typeChecker.getAliasedSymbol(this);
+    }
+
     /**
      * Gets the symbol flags.
      */

src/compiler/file/SourceFile.ts

@@ -1,7 +1,7 @@
 import * as ts from "typescript";
 import {Node, Symbol} from "./../common";
 import {StatementedNode} from "./../statement";
-import {TypeChecker} from "./../tools";
+import {TypeChecker, Program, Diagnostic} from "./../tools";
 import {FileUtils} from "./../../utils";
 
 export const SourceFileBase = StatementedNode(Node);
@@ -66,6 +66,16 @@ export class SourceFile extends SourceFileBase<ts.SourceFile> {
         return sourceFileSymbol.getExportByName("default");
     }
 
+    /**
+     * Gets the compiler diagnostics.
+     * @param program - Optional program.
+     */
+    getDiagnostics(program: Program = this.factory.getLanguageService().getProgram()): Diagnostic[] {
+        // todo: implement cancellation token
+        const compilerDiagnostics = ts.getPreEmitDiagnostics(program.getCompilerProgram(), this.getCompilerNode());
+        return compilerDiagnostics.map(d => this.factory.getDiagnostic(d));
+    }
+
     /**
      * Removes any "export default";
      */

src/compiler/tools.ts

@@ -1,3 +1,5 @@
-export * from "./tools/LanguageService";
+export * from "./tools/Diagnostic";
+export * from "./tools/DiagnosticMessageChain";
+export * from "./tools/LanguageService";
 export * from "./tools/Program";
 export * from "./tools/TypeChecker";

src/compiler/tools/Diagnostic.ts

@@ -0,0 +1,82 @@
+import * as ts from "typescript";
+import {CompilerFactory} from "./../../factories";
+import {SourceFile} from "./../file";
+import {DiagnosticMessageChain} from "./DiagnosticMessageChain";
+
+/**
+ * Diagnostic.
+ */
+export class Diagnostic {
+    /** @internal */
+    readonly factory: CompilerFactory;
+    /** @internal */
+    diagnostic: ts.Diagnostic;
+
+    constructor(
+        factory: CompilerFactory,
+        diagnostic: ts.Diagnostic
+    ) {
+        this.factory = factory;
+        this.diagnostic = diagnostic;
+    }
+
+    /**
+     * Gets the source file.
+     */
+    getSourceFile() {
+        return this.factory.getSourceFile(this.diagnostic.file);
+    }
+
+    /**
+     * Gets the message text.
+     */
+    getMessageText(): string | DiagnosticMessageChain {
+        const messageText = this.diagnostic.messageText;
+        if (typeof messageText === "string")
+            return messageText;
+
+        return this.factory.getDiagnosticMessageChain(messageText);
+    }
+
+    /**
+     * Gets the start.
+     */
+    getStart() {
+        return this.diagnostic.start;
+    }
+
+    /**
+     * Gets the length.
+     */
+    getLength() {
+        return this.diagnostic.length;
+    }
+
+    /**
+     * Gets the diagnostic category.
+     */
+    getCategory(): ts.DiagnosticCategory {
+        return this.diagnostic.category;
+    }
+
+    /**
+     * Gets the code of the diagnostic.
+     */
+    getCode() {
+        return this.diagnostic.code;
+    }
+
+    /**
+     * Gets the source.
+     */
+    getSource() {
+        return this.diagnostic.source;
+    }
+
+    /**
+     * Gets the underlying compiler diagnostic.
+     */
+    getCompilerDiagnostic(): ts.Diagnostic {
+        return this.diagnostic;
+    }
+}

src/compiler/tools/DiagnosticMessageChain.ts

@@ -0,0 +1,59 @@
+import * as ts from "typescript";
+import {CompilerFactory} from "./../../factories";
+
+/**
+ * Diagnostic message chain.
+ */
+export class DiagnosticMessageChain {
+    /** @internal */
+    readonly factory: CompilerFactory;
+    /** @internal */
+    diagnosticMessageChain: ts.DiagnosticMessageChain;
+
+    constructor(
+        factory: CompilerFactory,
+        diagnosticMessageChain: ts.DiagnosticMessageChain
+    ) {
+        this.factory = factory;
+        this.diagnosticMessageChain = diagnosticMessageChain;
+    }
+
+    /**
+     * Gets the message text.
+     */
+    getMessageText() {
+        return this.diagnosticMessageChain.messageText;
+    }
+
+    /**
+     * Gets th enext diagnostic message chain in the chain.
+     */
+    getNext(): DiagnosticMessageChain | undefined {
+        const next = this.diagnosticMessageChain.next;
+        if (next == null)
+            return undefined;
+
+        return this.factory.getDiagnosticMessageChain(next);
+    }
+
+    /**
+     * Gets the code of the diagnostic message chain.
+     */
+    getCode() {
+        return this.diagnosticMessageChain.code;
+    }
+
+    /**
+     * Gets the category of the diagnostic message chain.
+     */
+    getCategory(): ts.DiagnosticCategory {
+        return this.diagnosticMessageChain.category;
+    }
+
+    /**
+     * Gets the underlying compiler object.
+     */
+    getCompilerDiagnosticMessageChain(): ts.DiagnosticMessageChain {
+        return this.diagnosticMessageChain;
+    }
+}