Added converter for intersection types

This is how the output json output has changed from

typecript line
  type IIntersectionFooBar = IFoo & IBar;

output json diff
 					"id": 6,
 					"name": "IIntersectionFooBar",
 					"kind": 4194304,
 					"kindString": "Type alias",
 					"flags": {},
 					"sources": [
 						{
 							"fileName": "test.ts",
 							"line": 9,
 							"character": 24
 						}
 					],
 					"type": {
-						"type": "unknown",
-						"name": "IIntersectionFooBar"
+						"type": "intersection",
+						"types": [
+							{
+								"type": "reference",
+								"name": "IFoo"
+							},
+							{
+								"type": "reference",
+								"name": "IBar"
+							}
+						]
					}

Author: nathan

src/lib/converter/types/index.ts

@@ -3,6 +3,7 @@ export {ArrayConverter} from './array';
 export {BindingArrayConverter} from './binding-array';
 export {BindingObjectConverter} from './binding-object';
 export {EnumConverter} from './enum';
+export {IntersectionConverter} from './intersection';
 export {IntrinsicConverter} from './intrinsic'
 export {StringLiteralConverter} from './string-literal';
 export {ReferenceConverter} from './reference';

src/lib/converter/types/intersection.ts

@@ -0,0 +1,70 @@
+import * as ts from 'typescript';
+
+import {Type, IntersectionType} from '../../models/types/index';
+import {Component, ConverterTypeComponent, TypeConverter} from '../components';
+import {Context} from '../context';
+
+@Component({name: 'type:intersection'})
+export class IntersectionConverter extends ConverterTypeComponent implements TypeConverter<ts.IntersectionType, ts.IntersectionTypeNode> {
+    /**
+     * Test whether this converter can handle the given TypeScript node.
+     */
+    supportsNode(context: Context, node: ts.IntersectionTypeNode): boolean {
+        return node.kind === ts.SyntaxKind.IntersectionType;
+    }
+
+    /**
+     * Test whether this converter can handle the given TypeScript type.
+     */
+    supportsType(context: Context, type: ts.IntersectionType): boolean {
+        return !!(type.flags & ts.TypeFlags.Intersection);
+    }
+
+    /**
+     * Convert the given intersection type node to its type reflection.
+     *
+     * This is a node based converter, see [[convertIntersectionType]] for the type equivalent.
+     *
+     * ```
+     * let someValue: string|number;
+     * ```
+     *
+     * @param context  The context object describing the current state the converter is in.
+     * @param node  The intersection type node that should be converted.
+     * @returns The type reflection representing the given intersection type node.
+     */
+    convertNode(context: Context, node: ts.IntersectionTypeNode): IntersectionType {
+        let types: Type[] = [];
+        if (node.types) {
+            types = node.types.map((n) => this.owner.convertType(context, n));
+        } else {
+            types = [];
+        }
+
+        return new IntersectionType(types);
+    }
+
+    /**
+     * Convert the given intersection type to its type reflection.
+     *
+     * This is a type based converter, see [[convertIntersectionTypeNode]] for the node equivalent.
+     *
+     * ```
+     * let someValue: string|number;
+     * ```
+     *
+     * @param context  The context object describing the current state the converter is in.
+     * @param type  The intersection type that should be converted.
+     * @returns The type reflection representing the given intersection type.
+     */
+    convertType(context: Context, type: ts.IntersectionType): IntersectionType {
+        let types: Type[];
+        if (type && type.types) {
+            types = type.types.map((t) => this.owner.convertType(context, null, t));
+        } else {
+            types = [];
+        }
+
+        return new IntersectionType(types);
+    }
+}

src/lib/models/types/index.ts

@@ -1,4 +1,5 @@
 export {Type} from './abstract';
+export {IntersectionType} from './intersection';
 export {IntrinsicType} from './intrinsic';
 export {ReferenceType} from './reference';
 export {ReflectionType} from './reflection';

src/lib/models/types/intersection.ts

@@ -0,0 +1,78 @@
+import {Type} from './abstract';
+
+/**
+ * Represents an intersection type.
+ *
+ * ~~~
+ * type t: string & string[];
+ * ~~~
+ */
+export class IntersectionType extends Type {
+    /**
+     * The types this intersection consists of.
+     */
+    types: Type[];
+
+    /**
+     * Create a new TupleType instance.
+     *
+     * @param types  The types this intersection consists of.
+     */
+    constructor(types: Type[]) {
+        super();
+        this.types = types;
+    }
+
+    /**
+     * Clone this type.
+     *
+     * @return A clone of this type.
+     */
+    clone(): Type {
+        const clone = new IntersectionType(this.types);
+        clone.isArray = this.isArray;
+        return clone;
+    }
+
+    /**
+     * Test whether this type equals the given type.
+     *
+     * @param type  The type that should be checked for equality.
+     * @returns TRUE if the given type equals this type, FALSE otherwise.
+     */
+    equals(type: IntersectionType): boolean {
+        if (!(type instanceof IntersectionType)) {
+            return false;
+        }
+        if (type.isArray !== this.isArray) {
+            return false;
+        }
+        return Type.isTypeListSimiliar(type.types, this.types);
+    }
+
+    /**
+     * Return a raw object representation of this type.
+     */
+    toObject(): any {
+        const result: any = super.toObject();
+        result.type = 'intersection';
+
+        if (this.types && this.types.length) {
+            result.types = this.types.map((e) => e.toObject());
+        }
+
+        return result;
+    }
+
+    /**
+     * Return a string representation of this type.
+     */
+    toString() {
+        const names: string[] = [];
+        this.types.forEach((element) => {
+            names.push(element.toString());
+        });
+
+        return names.join(' | ');
+    }
+}