Intersection types

src/compiler/declarationEmitter.ts

@@ -340,6 +340,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:
@@ -416,6 +418,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:
@@ -2401,22 +2402,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

@@ -191,6 +191,7 @@ namespace ts {
  ArrayType,
  TupleType,
  UnionType,
+ IntersectionType,
  ParenthesizedType,
  // Binding patterns
  ObjectBindingPattern,
@@ -667,10 +668,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;
  }
@@ -1573,7 +1578,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
 
@@ -1652,7 +1657,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
@@ -1721,17 +1726,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,
@@ -1740,6 +1746,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
  }
@@ -1799,17 +1807,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 objector 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

@@ -3689,7 +3689,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();
@@ -5159,7 +5159,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 195 /* ForStatement */:
- case 196 /* ForInStatement */:
- case 194 /* WhileStatement */:
- case 193 /* DoStatement */:
- if (node.statement.kind !== 188 /* Block */) {
+ case 196 /* ForStatement */:
+ case 197 /* ForInStatement */:
+ case 195 /* WhileStatement */:
+ case 194 /* DoStatement */:
+ if (node.statement.kind !== 189 /* Block */) {
  report(node, "A looping statement's contents should be wrapped in a block body.");
  }
  break;
- case 192 /* IfStatement */:
+ case 193 /* IfStatement */:
  var ifStatement = node;
- if (ifStatement.thenStatement.kind !== 188 /* Block */) {
+ if (ifStatement.thenStatement.kind !== 189 /* Block */) {
  report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
  }
  if (ifStatement.elseStatement &&
- ifStatement.elseStatement.kind !== 188 /* Block */ &&
- ifStatement.elseStatement.kind !== 192 /* IfStatement */) {
+ ifStatement.elseStatement.kind !== 189 /* Block */ &&
+ ifStatement.elseStatement.kind !== 193 /* IfStatement */) {
  report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
  }
  break;
- case 177 /* BinaryExpression */:
+ case 178 /* BinaryExpression */:
  var op = node.operatorToken.kind;
  if (op === 29 /* EqualsEqualsToken */ || op == 30 /* ExclamationEqualsToken */) {
  report(node, "Use '===' and '!=='.");

tests/baselines/reference/contextualIntersectionType.js

@@ -0,0 +1,14 @@
+//// [contextualIntersectionType.ts]
+var x: { a: (s: string) => string } & { b: (n: number) => number };
+x = {
+ a: s => s,
+ b: n => n
+};
+
+
+//// [contextualIntersectionType.js]
+var x;
+x = {
+ a: function (s) { return s; },
+ b: function (n) { return n; }
+};

tests/baselines/reference/contextualIntersectionType.symbols

@@ -0,0 +1,23 @@
+=== tests/cases/conformance/types/intersection/contextualIntersectionType.ts ===
+var x: { a: (s: string) => string } & { b: (n: number) => number };
+>x : Symbol(x, Decl(contextualIntersectionType.ts, 0, 3))
+>a : Symbol(a, Decl(contextualIntersectionType.ts, 0, 8))
+>s : Symbol(s, Decl(contextualIntersectionType.ts, 0, 13))
+>b : Symbol(b, Decl(contextualIntersectionType.ts, 0, 39))
+>n : Symbol(n, Decl(contextualIntersectionType.ts, 0, 44))
+
+x = {
+>x : Symbol(x, Decl(contextualIntersectionType.ts, 0, 3))
+
+ a: s => s,
+>a : Symbol(a, Decl(contextualIntersectionType.ts, 1, 5))
+>s : Symbol(s, Decl(contextualIntersectionType.ts, 2, 6))
+>s : Symbol(s, Decl(contextualIntersectionType.ts, 2, 6))
+
+ b: n => n
+>b : Symbol(b, Decl(contextualIntersectionType.ts, 2, 14))
+>n : Symbol(n, Decl(contextualIntersectionType.ts, 3, 6))
+>n : Symbol(n, Decl(contextualIntersectionType.ts, 3, 6))
+
+};
+

tests/baselines/reference/contextualIntersectionType.types

@@ -0,0 +1,27 @@
+=== tests/cases/conformance/types/intersection/contextualIntersectionType.ts ===
+var x: { a: (s: string) => string } & { b: (n: number) => number };
+>x : { a: (s: string) => string; } & { b: (n: number) => number; }
+>a : (s: string) => string
+>s : string
+>b : (n: number) => number
+>n : number
+
+x = {
+>x = { a: s => s, b: n => n} : { a: (s: string) => string; b: (n: number) => number; }
+>x : { a: (s: string) => string; } & { b: (n: number) => number; }
+>{ a: s => s, b: n => n} : { a: (s: string) => string; b: (n: number) => number; }
+
+ a: s => s,
+>a : (s: string) => string
+>s => s : (s: string) => string
+>s : string
+>s : string
+
+ b: n => n
+>b : (n: number) => number
+>n => n : (n: number) => number
+>n : number
+>n : number
+
+};
+