Support for multidimensional arrays (TypeStrong#491)

Author: rklfss

package.json

@@ -45,7 +45,7 @@
     "minimatch": "^3.0.0",
     "progress": "^2.0.0",
     "shelljs": "^0.7.0",
-    "typedoc-default-themes": "^0.4.2",
+    "typedoc-default-themes": "^0.4.4",
     "typescript": "2.3.2"
   },
   "devDependencies": {

src/lib/converter/plugins/TypePlugin.ts

@@ -1,5 +1,5 @@
 import {Reflection, ReflectionKind, Decorator, DeclarationReflection, DeclarationHierarchy} from '../../models/reflections/index';
-import {Type, ReferenceType, TupleType, UnionType, IntersectionType} from '../../models/types/index';
+import {Type, ReferenceType, TupleType, UnionType, IntersectionType, ArrayType} from '../../models/types/index';
 import {Component, ConverterComponent} from '../components';
 import {Converter} from '../converter';
 import {Context} from '../context';
@@ -113,6 +113,8 @@ export class TypePlugin extends ConverterComponent {
                 for (let index = 0, count = unionOrIntersectionType.types.length; index < count; index++) {
                     resolveType(reflection, unionOrIntersectionType.types[index]);
                 }
+            } else if (type instanceof ArrayType) {
+                resolveType(reflection, type.elementType);
             }
         }
     }

src/lib/converter/types/array.ts

@@ -1,18 +1,26 @@
 import * as ts from 'typescript';
 
-import {Type, IntrinsicType} from '../../models/index';
-import {Component, ConverterTypeComponent, TypeNodeConverter} from '../components';
+import {Type, ArrayType} from '../../models/index';
+import {Component, ConverterTypeComponent, TypeConverter} from '../components';
 import {Context} from '../context';
 
 @Component({name: 'type:array'})
-export class ArrayConverter extends ConverterTypeComponent implements TypeNodeConverter<ts.Type, ts.ArrayTypeNode> {
+export class ArrayConverter extends ConverterTypeComponent implements TypeConverter<ts.TypeReference, ts.ArrayTypeNode> {
     /**
      * Test whether this converter can handle the given TypeScript node.
      */
     supportsNode(context: Context, node: ts.ArrayTypeNode): boolean {
         return node.kind === ts.SyntaxKind.ArrayType;
     }
 
+    /**
+     * Test whether this converter can handle the given TypeScript type.
+     */
+    supportsType(context: Context, type: ts.TypeReference): boolean {
+        // Is there a better way to detect the {"type":"reference","name":"Array","typeArguments":{...}} types that are in fact arrays?
+        return !!(type.flags & ts.TypeFlags.Object) && !!type.symbol && type.symbol.name === 'Array' && !type.symbol.parent && !!type.typeArguments && type.typeArguments.length === 1;
+    }
+
     /**
      * Convert the given array type node to its type reflection.
      *
@@ -27,14 +35,28 @@ export class ArrayConverter extends ConverterTypeComponent implements TypeNodeCo
      * @returns The type reflection representing the given array type node.
      */
     convertNode(context: Context, node: ts.ArrayTypeNode): Type {
-        let result = this.owner.convertType(context, node.elementType);
+        const result = this.owner.convertType(context, node.elementType);
 
-        if (result) {
-            result.isArray = true;
-        } else {
-            result = new IntrinsicType('Array');
-        }
+        return new ArrayType(result);
+    }
+
+    /**
+     * Convert the given type reference to its type reflection.
+     *
+     * This is a type based converter, see [[convertTypeReference]] for the node equivalent.
+     *
+     * ```
+     * class SomeClass { }
+     * let someValue: SomeClass;
+     * ```
+     *
+     * @param context  The context object describing the current state the converter is in.
+     * @param type  The type reference that should be converted.
+     * @returns The type reflection representing the given type reference.
+     */
+    convertType(context: Context, type: ts.TypeReference): Type {
+        const result = this.owner.convertType(context, null, type.typeArguments[0]);
 
-        return result;
+        return new ArrayType(result);
     }
 }

src/lib/models/types/abstract.ts

@@ -4,10 +4,6 @@
  * Instances of this class are also used to represent the type `void`.
  */
 export abstract class Type {
-    /**
-     * Is this an array type?
-     */
-    isArray = false;
 
     /**
      * The type name identifier.
@@ -38,10 +34,6 @@ export abstract class Type {
         let result: any = {};
         result.type = this.type;
 
-        if (this.isArray) {
-            result.isArray = this.isArray;
-        }
-
         return result;
     }
 

src/lib/models/types/array.ts

@@ -0,0 +1,75 @@
+import {Type, UnionType, IntersectionType} from './index';
+
+/**
+ * Represents an array type.
+ *
+ * ~~~
+ * let value: string[];
+ * ~~~
+ */
+export class ArrayType extends Type {
+
+    /**
+     * The type of the array elements.
+     */
+    elementType: Type;
+
+    /**
+     * The type name identifier.
+     */
+    readonly type: string = 'array';
+
+    /**
+     * Create a new TupleType instance.
+     *
+     * @param elementType  The type of the array's elements.
+     */
+    constructor(elementType: Type) {
+        super();
+        this.elementType = elementType;
+    }
+
+    /**
+     * Clone this type.
+     *
+     * @return A clone of this type.
+     */
+    clone(): Type {
+        return new ArrayType(this.elementType);
+    }
+
+    /**
+     * 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: Type): boolean {
+        if (!(type instanceof ArrayType)) {
+            return false;
+        }
+        return type.elementType.equals(this.elementType);
+    }
+
+    /**
+     * Return a raw object representation of this type.
+     */
+    toObject(): any {
+        const result: any = super.toObject();
+        result.elementType = this.elementType.toObject();
+
+        return result;
+    }
+
+    /**
+     * Return a string representation of this type.
+     */
+    toString() {
+        const elementTypeStr = this.elementType.toString();
+        if (this.elementType instanceof UnionType || this.elementType instanceof IntersectionType) {
+            return '(' + elementTypeStr + ')[]';
+        } else {
+            return elementTypeStr + '[]';
+        }
+    }
+}

src/lib/models/types/index.ts

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

src/lib/models/types/intersection.ts

@@ -34,9 +34,7 @@ export class IntersectionType extends Type {
      * @return A clone of this type.
      */
     clone(): Type {
-        const clone = new IntersectionType(this.types);
-        clone.isArray = this.isArray;
-        return clone;
+        return new IntersectionType(this.types);
     }
 
     /**
@@ -49,9 +47,6 @@ export class IntersectionType extends Type {
         if (!(type instanceof IntersectionType)) {
             return false;
         }
-        if (type.isArray !== this.isArray) {
-            return false;
-        }
         return Type.isTypeListSimiliar(type.types, this.types);
     }
 

src/lib/models/types/intrinsic.ts

@@ -34,9 +34,7 @@ export class IntrinsicType extends Type {
      * @return A clone of this type.
      */
     clone(): Type {
-        const clone = new IntrinsicType(this.name);
-        clone.isArray = this.isArray;
-        return clone;
+        return new IntrinsicType(this.name);
     }
 
     /**
@@ -47,7 +45,6 @@ export class IntrinsicType extends Type {
      */
     equals(type: IntrinsicType): boolean {
         return type instanceof IntrinsicType &&
-            type.isArray === this.isArray &&
             type.name === this.name;
     }
 
@@ -64,6 +61,6 @@ export class IntrinsicType extends Type {
      * Return a string representation of this type.
      */
     toString() {
-        return this.name + (this.isArray ? '[]' : '');
+        return this.name;
     }
 }

src/lib/models/types/reference.ts

@@ -73,7 +73,6 @@ export class ReferenceType extends Type {
      */
     clone(): Type {
         const clone = new ReferenceType(this.name, this.symbolID, this.reflection);
-        clone.isArray = this.isArray;
         clone.typeArguments = this.typeArguments;
         return clone;
     }
@@ -86,7 +85,6 @@ export class ReferenceType extends Type {
      */
     equals(type: ReferenceType): boolean {
         return type instanceof ReferenceType &&
-            type.isArray === this.isArray &&
             (type.symbolID === this.symbolID || type.reflection === this.reflection);
     }
 
@@ -114,14 +112,13 @@ export class ReferenceType extends Type {
      */
     toString() {
         const name = this.reflection ? this.reflection.name : this.name;
-        const arraySuffix = this.isArray ? '[]' : '';
         let typeArgs = '';
         if (this.typeArguments) {
             typeArgs += '<';
             typeArgs += this.typeArguments.map(arg => arg.toString()).join(', ');
             typeArgs += '>';
         }
 
-        return name + typeArgs + arraySuffix;
+        return name + typeArgs;
     }
 }

src/lib/models/types/reflection.ts

@@ -35,9 +35,7 @@ export class ReflectionType extends Type {
      * @return A clone of this type.
      */
     clone(): Type {
-        const clone = new ReflectionType(this.declaration);
-        clone.isArray = this.isArray;
-        return clone;
+        return new ReflectionType(this.declaration);
     }
 
     /**