Intersection types

src/compiler/declarationEmitter.ts

@@ -341,6 +341,8 @@ namespace ts {
                     return emitTupleType(<TupleTypeNode>type);
                 case SyntaxKind.UnionType:
                     return emitUnionType(<UnionTypeNode>type);
+                case SyntaxKind.IntersectionType:
+                    return emitIntersectionType(<IntersectionTypeNode>type);
                 case SyntaxKind.ParenthesizedType:
                     return emitParenType(<ParenthesizedTypeNode>type);
                 case SyntaxKind.FunctionType:
@@ -417,6 +419,10 @@ namespace ts {
                 emitSeparatedList(type.types, " | ", emitType);
             }
 
+            function emitIntersectionType(type: IntersectionTypeNode) {
+                emitSeparatedList(type.types, " & ", emitType);
+            }
+
             function emitParenType(type: ParenthesizedTypeNode) {
                 write("(");
                 emitType(type.type);

src/compiler/parser.ts

@@ -115,7 +115,8 @@ namespace ts {
             case SyntaxKind.TupleType:
                 return visitNodes(cbNodes, (<TupleTypeNode>node).elementTypes);
             case SyntaxKind.UnionType:
-                return visitNodes(cbNodes, (<UnionTypeNode>node).types);
+            case SyntaxKind.IntersectionType:
+                return visitNodes(cbNodes, (<UnionOrIntersectionTypeNode>node).types);
             case SyntaxKind.ParenthesizedType:
                 return visitNode(cbNode, (<ParenthesizedTypeNode>node).type);
             case SyntaxKind.ObjectBindingPattern:
@@ -2353,22 +2354,30 @@ namespace ts {
             return type;
         }
 
-        function parseUnionTypeOrHigher(): TypeNode {
-            let type = parseArrayTypeOrHigher();
-            if (token === SyntaxKind.BarToken) {
+        function parseUnionOrIntersectionType(kind: SyntaxKind, parseConstituentType: () => TypeNode, operator: SyntaxKind): TypeNode {
+            let type = parseConstituentType();
+            if (token === operator) {
                 let types = <NodeArray<TypeNode>>[type];
                 types.pos = type.pos;
-                while (parseOptional(SyntaxKind.BarToken)) {
-                    types.push(parseArrayTypeOrHigher());
+                while (parseOptional(operator)) {
+                    types.push(parseConstituentType());
                 }
                 types.end = getNodeEnd();
-                let node = <UnionTypeNode>createNode(SyntaxKind.UnionType, type.pos);
+                let node = <UnionOrIntersectionTypeNode>createNode(kind, type.pos);
                 node.types = types;
                 type = finishNode(node);
             }
             return type;
         }
 
+        function parseIntersectionTypeOrHigher(): TypeNode {
+            return parseUnionOrIntersectionType(SyntaxKind.IntersectionType, parseArrayTypeOrHigher, SyntaxKind.AmpersandToken);
+        }
+
+        function parseUnionTypeOrHigher(): TypeNode {
+            return parseUnionOrIntersectionType(SyntaxKind.UnionType, parseIntersectionTypeOrHigher, SyntaxKind.BarToken);
+        }
+
         function isStartOfFunctionType(): boolean {
             if (token === SyntaxKind.LessThanToken) {
                 return true;

src/compiler/types.ts

@@ -187,6 +187,7 @@ namespace ts {
         ArrayType,
         TupleType,
         UnionType,
+        IntersectionType,
         ParenthesizedType,
         // Binding patterns
         ObjectBindingPattern,
@@ -634,10 +635,14 @@ namespace ts {
         elementTypes: NodeArray<TypeNode>;
     }
 
-    export interface UnionTypeNode extends TypeNode {
+    export interface UnionOrIntersectionTypeNode extends TypeNode {
         types: NodeArray<TypeNode>;
     }
 
+    export interface UnionTypeNode extends UnionOrIntersectionTypeNode { }
+
+    export interface IntersectionTypeNode extends UnionOrIntersectionTypeNode { }
+
     export interface ParenthesizedTypeNode extends TypeNode {
         type: TypeNode;
     }
@@ -1479,7 +1484,7 @@ namespace ts {
         Merged                  = 0x02000000,  // Merged symbol (created during program binding)
         Transient               = 0x04000000,  // Transient symbol (created during type check)
         Prototype               = 0x08000000,  // Prototype property (no source representation)
-        UnionProperty           = 0x10000000,  // Property in union type
+        SyntheticProperty       = 0x10000000,  // Property in union or intersection type
         Optional                = 0x20000000,  // Optional property
         ExportStar              = 0x40000000,  // Export * declaration
 
@@ -1558,7 +1563,7 @@ namespace ts {
         instantiations?: Map<Type>;         // Instantiations of generic type alias (undefined if non-generic)
         mapper?: TypeMapper;                // Type mapper for instantiation alias
         referenced?: boolean;               // True if alias symbol has been referenced as a value
-        unionType?: UnionType;              // Containing union type for union property
+        containingType?: UnionOrIntersectionType; // Containing union or intersection type for synthetic property
         resolvedExports?: SymbolTable;      // Resolved exports of module
         exportsChecked?: boolean;           // True if exports of external module have been checked
         isNestedRedeclaration?: boolean;    // True if symbol is block scoped redeclaration
@@ -1620,17 +1625,18 @@ namespace ts {
         Interface               = 0x00000800,  // Interface
         Reference               = 0x00001000,  // Generic type reference
         Tuple                   = 0x00002000,  // Tuple
-        Union                   = 0x00004000,  // Union
-        Anonymous               = 0x00008000,  // Anonymous
-        Instantiated            = 0x00010000,  // Instantiated anonymous type
+        Union                   = 0x00004000,  // Union (T | U)
+        Intersection            = 0x00008000,  // Intersection (T & U)
+        Anonymous               = 0x00010000,  // Anonymous
+        Instantiated            = 0x00020000,  // Instantiated anonymous type
         /* @internal */
-        FromSignature           = 0x00020000,  // Created for signature assignment check
-        ObjectLiteral           = 0x00040000,  // Originates in an object literal
+        FromSignature           = 0x00040000,  // Created for signature assignment check
+        ObjectLiteral           = 0x00080000,  // Originates in an object literal
         /* @internal */
-        ContainsUndefinedOrNull = 0x00080000,  // Type is or contains Undefined or Null type
+        ContainsUndefinedOrNull = 0x00100000,  // Type is or contains Undefined or Null type
         /* @internal */
-        ContainsObjectLiteral   = 0x00100000,  // Type is or contains object literal type
-        ESSymbol                = 0x00200000,  // Type of symbol primitive introduced in ES6
+        ContainsObjectLiteral   = 0x00200000,  // Type is or contains object literal type
+        ESSymbol                = 0x00400000,  // Type of symbol primitive introduced in ES6
 
         /* @internal */ 
         Intrinsic = Any | String | Number | Boolean | ESSymbol | Void | Undefined | Null,
@@ -1639,6 +1645,8 @@ namespace ts {
         StringLike = String | StringLiteral,
         NumberLike = Number | Enum,
         ObjectType = Class | Interface | Reference | Tuple | Anonymous,
+        UnionOrIntersection = Union | Intersection,
+        StructuredType = ObjectType | Union | Intersection,
         /* @internal */ 
         RequiresWidening = ContainsUndefinedOrNull | ContainsObjectLiteral
     }
@@ -1698,17 +1706,21 @@ namespace ts {
         baseArrayType: TypeReference;  // Array<T> where T is best common type of element types
     }
 
-    export interface UnionType extends Type {
+    export interface UnionOrIntersectionType extends Type {
         types: Type[];                    // Constituent types
         /* @internal */
         reducedType: Type;                // Reduced union type (all subtypes removed)
         /* @internal */
         resolvedProperties: SymbolTable;  // Cache of resolved properties
     }
 
+    export interface UnionType extends UnionOrIntersectionType { }
+
+    export interface IntersectionType extends UnionOrIntersectionType { }
+
     /* @internal */
-    // Resolved object or union type
-    export interface ResolvedType extends ObjectType, UnionType {
+    // Resolved object, union, or intersection type
+    export interface ResolvedType extends ObjectType, UnionOrIntersectionType {
         members: SymbolTable;              // Properties by name
         properties: Symbol[];              // Properties
         callSignatures: Signature[];       // Call signatures of type

src/services/services.ts

@@ -3576,7 +3576,7 @@ namespace ts {
             if (flags & SymbolFlags.Constructor) return ScriptElementKind.constructorImplementationElement;
 
             if (flags & SymbolFlags.Property) {
-                if (flags & SymbolFlags.UnionProperty) {
+                if (flags & SymbolFlags.SyntheticProperty) {
                     // If union property is result of union of non method (property/accessors/variables), it is labeled as property
                     let unionPropertyKind = forEach(typeChecker.getRootSymbols(symbol), rootSymbol => {
                         let rootSymbolFlags = rootSymbol.getFlags();
@@ -5078,7 +5078,7 @@ namespace ts {
 
                 // if this symbol is visible from its parent container, e.g. exported, then bail out
                 // if symbol correspond to the union property - bail out
-                if (symbol.parent || (symbol.flags & SymbolFlags.UnionProperty)) {
+                if (symbol.parent || (symbol.flags & SymbolFlags.SyntheticProperty)) {
                     return undefined;
                 }
 

tests/baselines/reference/APISample_linter.js

@@ -75,26 +75,26 @@ function delint(sourceFile) {
     delintNode(sourceFile);
     function delintNode(node) {
         switch (node.kind) {
-            case 189 /* ForStatement */:
-            case 190 /* ForInStatement */:
-            case 188 /* WhileStatement */:
-            case 187 /* DoStatement */:
-                if (node.statement.kind !== 182 /* Block */) {
+            case 190 /* ForStatement */:
+            case 191 /* ForInStatement */:
+            case 189 /* WhileStatement */:
+            case 188 /* DoStatement */:
+                if (node.statement.kind !== 183 /* Block */) {
                     report(node, "A looping statement's contents should be wrapped in a block body.");
                 }
                 break;
-            case 186 /* IfStatement */:
+            case 187 /* IfStatement */:
                 var ifStatement = node;
-                if (ifStatement.thenStatement.kind !== 182 /* Block */) {
+                if (ifStatement.thenStatement.kind !== 183 /* Block */) {
                     report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
                 }
                 if (ifStatement.elseStatement &&
-                    ifStatement.elseStatement.kind !== 182 /* Block */ &&
-                    ifStatement.elseStatement.kind !== 186 /* IfStatement */) {
+                    ifStatement.elseStatement.kind !== 183 /* Block */ &&
+                    ifStatement.elseStatement.kind !== 187 /* IfStatement */) {
                     report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
                 }
                 break;
-            case 172 /* BinaryExpression */:
+            case 173 /* BinaryExpression */:
                 var op = node.operatorToken.kind;
                 if (op === 28 /* EqualsEqualsToken */ || op == 29 /* ExclamationEqualsToken */) {
                     report(node, "Use '===' and '!=='.");