Initial implementation of Union Types

Author: ahejlsberg

src/compiler/checker.ts

@@ -82,7 +82,7 @@ module ts {
         return array1.concat(array2);
     }
 
-    export function uniqueElements<T>(array: T[]): T[] {
+    export function deduplicate<T>(array: T[]): T[] {
         if (array) {
             var result: T[] = [];
             for (var i = 0, len = array.length; i < len; i++) {

src/compiler/core.ts

@@ -179,8 +179,6 @@ module ts {
         The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: { code: 2363, category: DiagnosticCategory.Error, key: "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type." },
         Invalid_left_hand_side_of_assignment_expression: { code: 2364, category: DiagnosticCategory.Error, key: "Invalid left-hand side of assignment expression." },
         Operator_0_cannot_be_applied_to_types_1_and_2: { code: 2365, category: DiagnosticCategory.Error, key: "Operator '{0}' cannot be applied to types '{1}' and '{2}'." },
-        No_best_common_type_exists_between_0_1_and_2: { code: 2366, category: DiagnosticCategory.Error, key: "No best common type exists between '{0}', '{1}', and '{2}'." },
-        No_best_common_type_exists_between_0_and_1: { code: 2367, category: DiagnosticCategory.Error, key: "No best common type exists between '{0}' and '{1}'." },
         Type_parameter_name_cannot_be_0: { code: 2368, category: DiagnosticCategory.Error, key: "Type parameter name cannot be '{0}'" },
         A_parameter_property_is_only_allowed_in_a_constructor_implementation: { code: 2369, category: DiagnosticCategory.Error, key: "A parameter property is only allowed in a constructor implementation." },
         A_rest_parameter_must_be_of_an_array_type: { code: 2370, category: DiagnosticCategory.Error, key: "A rest parameter must be of an array type." },

src/compiler/diagnosticInformationMap.generated.ts

@@ -708,14 +708,6 @@
         "category": "Error",
         "code": 2365
     },
-    "No best common type exists between '{0}', '{1}', and '{2}'.": {
-        "category": "Error",
-        "code": 2366
-    },
-    "No best common type exists between '{0}' and '{1}'.": {
-        "category": "Error",
-        "code": 2367
-    },
     "Type parameter name cannot be '{0}'": {
         "category": "Error",
         "code": 2368

src/compiler/diagnosticMessages.json

@@ -232,6 +232,8 @@ module ts {
                 return child((<ArrayTypeNode>node).elementType);
             case SyntaxKind.TupleType:
                 return children((<TupleTypeNode>node).elementTypes);
+            case SyntaxKind.UnionType:
+                return children((<UnionTypeNode>node).types);
             case SyntaxKind.ArrayLiteral:
                 return children((<ArrayLiteral>node).elements);
             case SyntaxKind.ObjectLiteral:
@@ -1728,9 +1730,9 @@ module ts {
             }
         }
 
-        function parseType(): TypeNode {
+        function parseNonUnionType(): TypeNode {
             var type = parseNonArrayType();
-            while (type && !scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind.OpenBracketToken)) {
+            while (!scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind.OpenBracketToken)) {
                 parseExpected(SyntaxKind.CloseBracketToken);
                 var node = <ArrayTypeNode>createNode(SyntaxKind.ArrayType, type.pos);
                 node.elementType = type;
@@ -1739,6 +1741,22 @@ module ts {
             return type;
         }
 
+        function parseType(): TypeNode {
+            var type = parseNonUnionType();
+            if (token === SyntaxKind.BarToken) {
+                var types = <NodeArray<TypeNode>>[type];
+                types.pos = type.pos;
+                while (parseOptional(SyntaxKind.BarToken)) {
+                    types.push(parseNonUnionType());
+                }
+                types.end = getNodeEnd();
+                var node = <UnionTypeNode>createNode(SyntaxKind.UnionType, type.pos);
+                node.types = types;
+                type = finishNode(node);
+            }
+            return type;
+        }
+
         function parseTypeAnnotation(): TypeNode {
             return parseOptional(SyntaxKind.ColonToken) ? parseType() : undefined;
         }

src/compiler/parser.ts

@@ -154,6 +154,7 @@ module ts {
         TypeLiteral,
         ArrayType,
         TupleType,
+        UnionType,
         // Expression
         ArrayLiteral,
         ObjectLiteral,
@@ -224,7 +225,7 @@ module ts {
         FirstFutureReservedWord = ImplementsKeyword,
         LastFutureReservedWord = YieldKeyword,
         FirstTypeNode = TypeReference,
-        LastTypeNode = TupleType,
+        LastTypeNode = UnionType,
         FirstPunctuation = OpenBraceToken,
         LastPunctuation = CaretEqualsToken,
         FirstToken = EndOfFileToken,
@@ -337,6 +338,10 @@ module ts {
         elementTypes: NodeArray<TypeNode>;
     }
 
+    export interface UnionTypeNode extends TypeNode {
+        types: NodeArray<TypeNode>;
+    }
+
     export interface StringLiteralTypeNode extends TypeNode {
         text: string;
     }
@@ -728,19 +733,20 @@ module ts {
         ConstructSignature = 0x00010000,  // Construct signature
         IndexSignature     = 0x00020000,  // Index signature
         TypeParameter      = 0x00040000,  // Type parameter
+        UnionProperty      = 0x00080000,  // Property in union type
 
         // Export markers (see comment in declareModuleMember in binder)
-        ExportValue        = 0x00080000,  // Exported value marker
-        ExportType         = 0x00100000,  // Exported type marker
-        ExportNamespace    = 0x00200000,  // Exported namespace marker
+        ExportValue        = 0x00100000,  // Exported value marker
+        ExportType         = 0x00200000,  // Exported type marker
+        ExportNamespace    = 0x00400000,  // Exported namespace marker
 
-        Import             = 0x00400000,  // Import
-        Instantiated       = 0x00800000,  // Instantiated symbol
-        Merged             = 0x01000000,  // Merged symbol (created during program binding)
-        Transient          = 0x02000000,  // Transient symbol (created during type check)
-        Prototype          = 0x04000000,  // Symbol for the prototype property (without source code representation)
+        Import             = 0x00800000,  // Import
+        Instantiated       = 0x01000000,  // Instantiated symbol
+        Merged             = 0x02000000,  // Merged symbol (created during program binding)
+        Transient          = 0x04000000,  // Transient symbol (created during type check)
+        Prototype          = 0x08000000,  // Prototype property (no source representation)
 
-        Value     = Variable | Property | EnumMember | Function | Class | Enum | ValueModule | Method | GetAccessor | SetAccessor,
+        Value     = Variable | Property | EnumMember | Function | Class | Enum | ValueModule | Method | GetAccessor | SetAccessor | UnionProperty,
         Type      = Class | Interface | Enum | TypeLiteral | ObjectLiteral | TypeParameter,
         Namespace = ValueModule | NamespaceModule,
         Module    = ValueModule | NamespaceModule,
@@ -798,6 +804,7 @@ module ts {
         mapper?: TypeMapper;           // Type mapper for instantiation alias
         referenced?: boolean;          // True if alias symbol has been referenced as a value
         exportAssignSymbol?: Symbol;   // Symbol exported from external module
+        unionType?: UnionType;         // Containing union type for union property
     }
 
     export interface TransientSymbol extends Symbol, SymbolLinks { }
@@ -845,13 +852,14 @@ module ts {
         Interface          = 0x00000800,  // Interface
         Reference          = 0x00001000,  // Generic type reference
         Tuple              = 0x00002000,  // Tuple
-        Anonymous          = 0x00004000,  // Anonymous
-        FromSignature      = 0x00008000,  // Created for signature assignment check
+        Union              = 0x00004000,  // Union
+        Anonymous          = 0x00008000,  // Anonymous
+        FromSignature      = 0x00010000,  // Created for signature assignment check
 
         Intrinsic = Any | String | Number | Boolean | Void | Undefined | Null,
         StringLike = String | StringLiteral,
         NumberLike = Number | Enum,
-        ObjectType = Class | Interface | Reference | Tuple | Anonymous
+        ObjectType = Class | Interface | Reference | Tuple | Union | Anonymous
     }
 
     // Properties common to all types
@@ -909,6 +917,10 @@ module ts {
         baseArrayType: TypeReference;  // Array<T> where T is best common type of element types
     }
 
+    export interface UnionType extends ObjectType {
+        types: Type[];  // Constituent types
+    }
+
     // Resolved object type
     export interface ResolvedObjectType extends ObjectType {
         members: SymbolTable;              // Properties by name
@@ -941,6 +953,7 @@ module ts {
         hasStringLiterals: boolean;         // True if specialized
         target?: Signature;                 // Instantiation target
         mapper?: TypeMapper;                // Instantiation mapper
+        unionSignatures?: Signature[];      // Underlying signatures of a union signature
         erasedSignatureCache?: Signature;   // Erased version of signature (deferred)
         isolatedSignatureType?: ObjectType; // A manufactured type that just contains the signature for purposes of signature comparison
     }