Added alias type support

Author: sebastian-lenz

examples/basic/src/typescript-1.4.ts

@@ -1,15 +1,59 @@
+/**
+ * Examples of features added in TypeScript 1.4.
+ *
+ * @see  http://blogs.msdn.com/b/typescript/archive/2014/11/18/what-s-new-in-the-typescript-type-system.aspx
+ */
+
+/**
+ * A simple interface holding a member with an union type.
+ */
 interface RunOptions {
     program: string;
     commandline: string[]|string;
 }
 
+
+/**
+ * A type alias describing an array.
+ */
 type PrimitiveArray = Array<string|number|boolean>;
+
+
+/**
+ * A type alias describing a primitive value.
+ */
 type MyNumber = number;
+
+
+/**
+ * A type alias describing a reference type.
+ */
 type MyRunOptions = RunOptions;
-type Callback = () => void;
 
+
+/**
+ * A type alias of for a callback function.
+ *
+ * @param Callback.parameters  The rest parameter.
+ */
+type Callback = (...parameters:string[]) => string;
+
+
+/**
+ * A variable defined using an union type.
+ */
+var interfaceOrString:RunOptions|string;
+
+
+/**
+ * A variable pointing to a type alias.
+ */
 var callback:Callback;
 
-function functionUsingTypes(data:PrimitiveArray, callback:Callback):MyNumber {
+
+/**
+ * A function that has parameters pointing to type aliases and returns a type alias.
+ */
+function functionUsingTypes(aliasData:PrimitiveArray, callback:Callback):MyNumber {
     return 10;
 }

src/td/converter/Converter.ts

@@ -276,7 +276,9 @@ module td
 
 
             function extractType(target:Reflection, node:ts.Node, type:ts.Type):Type {
-                if (type.flags & ts.TypeFlags.Intrinsic) {
+                if (node && node['typeName'] && node['typeName'].text && type && (!type.symbol || (node['typeName'].text != type.symbol.name))) {
+                    return new ReferenceType(node['typeName'].text, null, target.findReflectionByName(node['typeName'].text));
+                } else if (type.flags & ts.TypeFlags.Intrinsic) {
                     return extractIntrinsicType(<ts.IntrinsicType>type);
                 } else if (type.flags & ts.TypeFlags.Enum) {
                     return extractEnumType(type);
@@ -308,19 +310,31 @@ module td
 
             function extractTupleType(target:Reflection, node:ts.TupleTypeNode, type:ts.TupleType):Type {
                 var elements = [];
-                node.elementTypes.forEach((elementNode) => {
-                    elements.push(extractType(target, elementNode, checker.getTypeAtLocation(elementNode)));
-                });
+                if (node.elementTypes) {
+                    node.elementTypes.forEach((elementNode:ts.TypeNode) => {
+                        elements.push(extractType(target, elementNode, checker.getTypeAtLocation(elementNode)));
+                    });
+                } else {
+                    type.elementTypes.forEach((type:ts.Type) => {
+                        elements.push(extractType(target, null, type));
+                    });
+                }
 
                 return new TupleType(elements);
             }
 
 
             function extractUnionType(target:Reflection, node:ts.UnionTypeNode, type:ts.UnionType):Type {
                 var types = [];
-                node.types.forEach((typeNode:ts.TypeNode) => {
-                    types.push(extractType(target, typeNode, checker.getTypeAtLocation(typeNode)));
-                });
+                if (node.types) {
+                    node.types.forEach((typeNode:ts.TypeNode) => {
+                        types.push(extractType(target, typeNode, checker.getTypeAtLocation(typeNode)));
+                    });
+                } else {
+                    type.types.forEach((type:ts.Type) => {
+                        types.push(extractType(target, null, type));
+                    });
+                }
 
                 return new UnionType(types);
             }
@@ -521,6 +535,7 @@ module td
                     case ts.SyntaxKind.SetAccessor:
                         return visitSetAccessorDeclaration(<ts.SignatureDeclaration>node, scope);
                     case ts.SyntaxKind.CallSignature:
+                    case ts.SyntaxKind.FunctionType:
                         return visitCallSignatureDeclaration(<ts.SignatureDeclaration>node, <DeclarationReflection>scope);
                     case ts.SyntaxKind.IndexSignature:
                         return visitIndexSignatureDeclaration(<ts.SignatureDeclaration>node, <DeclarationReflection>scope);
@@ -533,8 +548,10 @@ module td
                         return visitTypeLiteral(<ts.TypeLiteralNode>node, scope);
                     case ts.SyntaxKind.ExportAssignment:
                         return visitExportAssignment(<ts.ExportAssignment>node, scope);
+                    case ts.SyntaxKind.TypeAliasDeclaration:
+                        return visitTypeAliasDeclaration(<ts.TypeAliasDeclaration>node, scope);
                     default:
-                        // console.log('Unhandeled: ' + ts.SyntaxKind[node.kind]);
+                        // console.log('Unhandeled: ' + node.kind);
                         return null;
                 }
             }
@@ -1009,6 +1026,23 @@ module td
             }
 
 
+            /**
+             * Analyze the given type alias declaration node and create a suitable reflection.
+             *
+             * @param node   The type alias declaration node that should be analyzed.
+             * @param scope  The reflection representing the current scope.
+             * @return The resulting reflection or NULL.
+             */
+            function visitTypeAliasDeclaration(node:ts.TypeAliasDeclaration, scope:ContainerReflection):Reflection {
+                var alias = createDeclaration(scope, node, ReflectionKind.TypeAlias);
+                alias.type = extractType(alias, node.type, checker.getTypeAtLocation(node.type));
+                if (alias.name == 'Callback') {
+                    // console.log(alias);
+                }
+                return alias;
+            }
+
+
             function visitExportAssignment(node:ts.ExportAssignment, scope:ContainerReflection):Reflection {
                 var type = checker.getTypeAtLocation(node.exportName);
                 if (type && type.symbol) {

src/td/converter/plugins/GroupPlugin.ts

@@ -18,6 +18,7 @@ module td
             ReflectionKind.EnumMember,
             ReflectionKind.Class,
             ReflectionKind.Interface,
+            ReflectionKind.TypeAlias,
 
             ReflectionKind.Constructor,
             ReflectionKind.Property,
@@ -56,6 +57,7 @@ module td
             plurals[ReflectionKind.Property]   = 'Properties';
             plurals[ReflectionKind.Enum]       = 'Enumerations';
             plurals[ReflectionKind.EnumMember] = 'Enumeration members';
+            plurals[ReflectionKind.TypeAlias]  = 'Type aliases';
             return plurals;
         })();
 

src/td/converter/plugins/TypePlugin.ts

@@ -78,6 +78,11 @@ module td
                     for (var index = 0, count = tupleType.elements.length; index < count; index++) {
                         resolveType(tupleType.elements[index]);
                     }
+                } else if (type instanceof UnionType) {
+                    var unionType:UnionType = <UnionType>type;
+                    for (var index = 0, count = unionType.types.length; index < count; index++) {
+                        resolveType(unionType.types[index]);
+                    }
                 }
             }
         }

src/td/models/Reflection.ts

@@ -52,6 +52,7 @@ module td
         GetSignature = 524288,
         SetSignature = 1048576,
         ObjectLiteral = 2097152,
+        TypeAlias = 4194304,
 
         ClassOrInterface = Class | Interface,
         VariableOrProperty = Variable | Property,