Static types for dynamically named properties

src/compiler/binder.ts

@@ -1209,9 +1209,9 @@ namespace ts {
  }
  else {
  forEachChild(node, bind);
- if (operator === SyntaxKind.EqualsToken && !isAssignmentTarget(node)) {
+ if (isAssignmentOperator(operator) && !isAssignmentTarget(node)) {
  bindAssignmentTargetFlow(node.left);
- if (node.left.kind === SyntaxKind.ElementAccessExpression) {
+ if (operator === SyntaxKind.EqualsToken && node.left.kind === SyntaxKind.ElementAccessExpression) {
  const elementAccess = <ElementAccessExpression>node.left;
  if (isNarrowableOperand(elementAccess.expression)) {
  currentFlow = createFlowArrayMutation(currentFlow, node);
@@ -3097,6 +3097,8 @@ namespace ts {
  case SyntaxKind.InterfaceDeclaration:
  case SyntaxKind.TypeAliasDeclaration:
  case SyntaxKind.ThisType:
+ case SyntaxKind.TypeOperator:
+ case SyntaxKind.IndexedAccessType:
  case SyntaxKind.LiteralType:
  // Types and signatures are TypeScript syntax, and exclude all other facts.
  transformFlags = TransformFlags.AssertTypeScript;

src/compiler/declarationEmitter.ts

@@ -413,6 +413,10 @@ namespace ts {
  return emitIntersectionType(<IntersectionTypeNode>type);
  case SyntaxKind.ParenthesizedType:
  return emitParenType(<ParenthesizedTypeNode>type);
+ case SyntaxKind.TypeOperator:
+ return emitTypeOperator(<TypeOperatorNode>type);
+ case SyntaxKind.IndexedAccessType:
+ return emitPropertyAccessType(<IndexedAccessTypeNode>type);
  case SyntaxKind.FunctionType:
  case SyntaxKind.ConstructorType:
  return emitSignatureDeclarationWithJsDocComments(<FunctionOrConstructorTypeNode>type);
@@ -506,6 +510,19 @@ namespace ts {
  write(")");
  }
 
+ function emitTypeOperator(type: TypeOperatorNode) {
+ write(tokenToString(type.operator));
+ write(" ");
+ emitType(type.type);
+ }
+
+ function emitPropertyAccessType(node: IndexedAccessTypeNode) {
+ emitType(node.objectType);
+ write("[");
+ emitType(node.indexType);
+ write("]");
+ }
+
  function emitTypeLiteral(type: TypeLiteralNode) {
  write("{");
  if (type.members.length) {

src/compiler/diagnosticMessages.json

@@ -1071,7 +1071,7 @@
  "category": "Error",
  "code": 2356
  },
- "The operand of an increment or decrement operator must be a variable, property or indexer.": {
+ "The operand of an increment or decrement operator must be a variable or a property access.": {
  "category": "Error",
  "code": 2357
  },
@@ -1099,7 +1099,7 @@
  "category": "Error",
  "code": 2363
  },
- "Invalid left-hand side of assignment expression.": {
+ "The left-hand side of an assignment expression must be a variable or a property access.": {
  "category": "Error",
  "code": 2364
  },
@@ -1259,7 +1259,7 @@
  "category": "Error",
  "code": 2405
  },
- "Invalid left-hand side in 'for...in' statement.": {
+ "The left-hand side of a 'for...in' statement must be a variable or a property access.": {
  "category": "Error",
  "code": 2406
  },
@@ -1411,14 +1411,6 @@
  "category": "Error",
  "code": 2448
  },
- "The operand of an increment or decrement operator cannot be a constant or a read-only property.": {
- "category": "Error",
- "code": 2449
- },
- "Left-hand side of assignment expression cannot be a constant or a read-only property.": {
- "category": "Error",
- "code": 2450
- },
  "Cannot redeclare block-scoped variable '{0}'.": {
  "category": "Error",
  "code": 2451
@@ -1551,15 +1543,7 @@
  "category": "Error",
  "code": 2484
  },
- "The left-hand side of a 'for...of' statement cannot be a constant or a read-only property.": {
- "category": "Error",
- "code": 2485
- },
- "The left-hand side of a 'for...in' statement cannot be a constant or a read-only property.": {
- "category": "Error",
- "code": 2486
- },
- "Invalid left-hand side in 'for...of' statement.": {
+ "The left-hand side of a 'for...of' statement must be a variable or a property access.": {
  "category": "Error",
  "code": 2487
  },
@@ -1747,6 +1731,34 @@
  "category": "Error",
  "code": 2535
  },
+ "Type '{0}' is not constrained to 'keyof {1}'.": {
+ "category": "Error",
+ "code": 2536
+ },
+ "Type '{0}' has no matching index signature for type '{1}'.": {
+ "category": "Error",
+ "code": 2537
+ },
+ "Type '{0}' cannot be used as an index type.": {
+ "category": "Error",
+ "code": 2538
+ },
+ "Cannot assign to '{0}' because it is not a variable.": {
+ "category": "Error",
+ "code": 2539
+ },
+ "Cannot assign to '{0}' because it is a constant or a read-only property.": {
+ "category": "Error",
+ "code": 2540
+ },
+ "The target of an assignment must be a variable or a property access.": {
+ "category": "Error",
+ "code": 2541
+ },
+ "Index signature in type '{0}' only permits reading.": {
+ "category": "Error",
+ "code": 2542
+ },
  "JSX element attributes type '{0}' may not be a union type.": {
  "category": "Error",
  "code": 2600
@@ -2909,7 +2921,7 @@
  "category": "Error",
  "code": 7016
  },
- "Index signature of object type implicitly has an 'any' type.": {
+ "Element implicitly has an 'any' type because type '{0}' has no index signature.": {
  "category": "Error",
  "code": 7017
  },

src/compiler/emitter.ts

@@ -594,6 +594,10 @@ const _super = (function (geti, seti) {
  return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);
  case SyntaxKind.ThisType:
  return emitThisType();
+ case SyntaxKind.TypeOperator:
+ return emitTypeOperator(<TypeOperatorNode>node);
+ case SyntaxKind.IndexedAccessType:
+ return emitPropertyAccessType(<IndexedAccessTypeNode>node);
  case SyntaxKind.LiteralType:
  return emitLiteralType(<LiteralTypeNode>node);
 
@@ -1088,6 +1092,19 @@ const _super = (function (geti, seti) {
  write("this");
  }
 
+ function emitTypeOperator(node: TypeOperatorNode) {
+ writeTokenText(node.operator);
+ write(" ");
+ emit(node.type);
+ }
+
+ function emitPropertyAccessType(node: IndexedAccessTypeNode) {
+ emit(node.objectType);
+ write("[");
+ emit(node.indexType);
+ write("]");
+ }
+
  function emitLiteralType(node: LiteralTypeNode) {
  emitExpression(node.literal);
  }

src/compiler/parser.ts

@@ -134,7 +134,11 @@ namespace ts {
  case SyntaxKind.IntersectionType:
  return visitNodes(cbNodes, (<UnionOrIntersectionTypeNode>node).types);
  case SyntaxKind.ParenthesizedType:
- return visitNode(cbNode, (<ParenthesizedTypeNode>node).type);
+ case SyntaxKind.TypeOperator:
+ return visitNode(cbNode, (<ParenthesizedTypeNode | TypeOperatorNode>node).type);
+ case SyntaxKind.IndexedAccessType:
+ return visitNode(cbNode, (<IndexedAccessTypeNode>node).objectType) ||
+ visitNode(cbNode, (<IndexedAccessTypeNode>node).indexType);
  case SyntaxKind.LiteralType:
  return visitNode(cbNode, (<LiteralTypeNode>node).literal);
  case SyntaxKind.ObjectBindingPattern:
@@ -2519,14 +2523,39 @@ namespace ts {
  function parseArrayTypeOrHigher(): TypeNode {
  let type = parseNonArrayType();
  while (!scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind.OpenBracketToken)) {
- parseExpected(SyntaxKind.CloseBracketToken);
- const node = <ArrayTypeNode>createNode(SyntaxKind.ArrayType, type.pos);
- node.elementType = type;
- type = finishNode(node);
+ if (isStartOfType()) {
+ const node = <IndexedAccessTypeNode>createNode(SyntaxKind.IndexedAccessType, type.pos);
+ node.objectType = type;
+ node.indexType = parseType();
+ parseExpected(SyntaxKind.CloseBracketToken);
+ type = finishNode(node);
+ }
+ else {
+ const node = <ArrayTypeNode>createNode(SyntaxKind.ArrayType, type.pos);
+ node.elementType = type;
+ parseExpected(SyntaxKind.CloseBracketToken);
+ type = finishNode(node);
+ }
  }
  return type;
  }
 
+ function parseTypeOperator(operator: SyntaxKind.KeyOfKeyword) {
+ const node = <TypeOperatorNode>createNode(SyntaxKind.TypeOperator);
+ parseExpected(operator);
+ node.operator = operator;
+ node.type = parseTypeOperatorOrHigher();
+ return finishNode(node);
+ }
+
+ function parseTypeOperatorOrHigher(): TypeNode {
+ switch (token()) {
+ case SyntaxKind.KeyOfKeyword:
+ return parseTypeOperator(SyntaxKind.KeyOfKeyword);
+ }
+ return parseArrayTypeOrHigher();
+ }
+
  function parseUnionOrIntersectionType(kind: SyntaxKind, parseConstituentType: () => TypeNode, operator: SyntaxKind): TypeNode {
  let type = parseConstituentType();
  if (token() === operator) {
@@ -2543,7 +2572,7 @@ namespace ts {
  }
 
  function parseIntersectionTypeOrHigher(): TypeNode {
- return parseUnionOrIntersectionType(SyntaxKind.IntersectionType, parseArrayTypeOrHigher, SyntaxKind.AmpersandToken);
+ return parseUnionOrIntersectionType(SyntaxKind.IntersectionType, parseTypeOperatorOrHigher, SyntaxKind.AmpersandToken);
  }
 
  function parseUnionTypeOrHigher(): TypeNode {

src/compiler/scanner.ts

@@ -90,6 +90,7 @@ namespace ts {
  "instanceof": SyntaxKind.InstanceOfKeyword,
  "interface": SyntaxKind.InterfaceKeyword,
  "is": SyntaxKind.IsKeyword,
+ "keyof": SyntaxKind.KeyOfKeyword,
  "let": SyntaxKind.LetKeyword,
  "module": SyntaxKind.ModuleKeyword,
  "namespace": SyntaxKind.NamespaceKeyword,

src/compiler/transformers/ts.ts

@@ -300,6 +300,8 @@ namespace ts {
  case SyntaxKind.IntersectionType:
  case SyntaxKind.ParenthesizedType:
  case SyntaxKind.ThisType:
+ case SyntaxKind.TypeOperator:
+ case SyntaxKind.IndexedAccessType:
  case SyntaxKind.LiteralType:
  // TypeScript type nodes are elided.
 
@@ -1783,6 +1785,8 @@ namespace ts {
  }
  // Fallthrough
  case SyntaxKind.TypeQuery:
+ case SyntaxKind.TypeOperator:
+ case SyntaxKind.IndexedAccessType:
  case SyntaxKind.TypeLiteral:
  case SyntaxKind.AnyKeyword:
  case SyntaxKind.ThisType:

src/compiler/types.ts

@@ -168,6 +168,7 @@ namespace ts {
  DeclareKeyword,
  GetKeyword,
  IsKeyword,
+ KeyOfKeyword,
  ModuleKeyword,
  NamespaceKeyword,
  NeverKeyword,
@@ -216,6 +217,8 @@ namespace ts {
  IntersectionType,
  ParenthesizedType,
  ThisType,
+ TypeOperator,
+ IndexedAccessType,
  LiteralType,
  // Binding patterns
  ObjectBindingPattern,
@@ -882,6 +885,18 @@ namespace ts {
  type: TypeNode;
  }
 
+ export interface TypeOperatorNode extends TypeNode {
+ kind: SyntaxKind.TypeOperator;
+ operator: SyntaxKind.KeyOfKeyword;
+ type: TypeNode;
+ }
+
+ export interface IndexedAccessTypeNode extends TypeNode {
+ kind: SyntaxKind.IndexedAccessType;
+ objectType: TypeNode;
+ indexType: TypeNode;
+ }
+
  export interface LiteralTypeNode extends TypeNode {
  kind: SyntaxKind.LiteralType;
  literal: Expression;
@@ -953,10 +968,6 @@ namespace ts {
  operator: PostfixUnaryOperator;
  }
 
- export interface PostfixExpression extends UnaryExpression {
- _postfixExpressionBrand: any;
- }
-
  export interface LeftHandSideExpression extends IncrementExpression {
  _leftHandSideExpressionBrand: any;
  }
@@ -2667,14 +2678,16 @@ namespace ts {
  Object = 1 << 15, // Object type
  Union = 1 << 16, // Union (T | U)
  Intersection = 1 << 17, // Intersection (T & U)
+ Index = 1 << 18, // keyof T
+ IndexedAccess = 1 << 19, // T[K]
  /* @internal */
- FreshLiteral = 1 << 18, // Fresh literal type
+ FreshLiteral = 1 << 20, // Fresh literal type
  /* @internal */
- ContainsWideningType = 1 << 19, // Type is or contains undefined or null widening type
+ ContainsWideningType = 1 << 21, // Type is or contains undefined or null widening type
  /* @internal */
- ContainsObjectLiteral = 1 << 20, // Type is or contains object literal type
+ ContainsObjectLiteral = 1 << 22, // Type is or contains object literal type
  /* @internal */
- ContainsAnyFunctionType = 1 << 21, // Type is or contains object literal type
+ ContainsAnyFunctionType = 1 << 23, // Type is or contains object literal type
 
  /* @internal */
  Nullable = Undefined | Null,
@@ -2697,7 +2710,7 @@ namespace ts {
 
  // 'Narrowable' types are types where narrowing actually narrows.
  // This *should* be every type other than null, undefined, void, and never
- Narrowable = Any | StructuredType | TypeParameter | StringLike | NumberLike | BooleanLike | ESSymbol,
+ Narrowable = Any | StructuredType | TypeParameter | Index | IndexedAccess | StringLike | NumberLike | BooleanLike | ESSymbol,
  NotUnionOrUnit = Any | ESSymbol | Object,
  /* @internal */
  RequiresWidening = ContainsWideningType | ContainsObjectLiteral,
@@ -2860,9 +2873,22 @@ namespace ts {
  /* @internal */
  resolvedApparentType: Type;
  /* @internal */
+ resolvedIndexType: IndexType;
+ /* @internal */
+ resolvedIndexedAccessTypes: IndexedAccessType[];
+ /* @internal */
  isThisType?: boolean;
  }
 
+ export interface IndexType extends Type {
+ type: TypeParameter;
+ }
+
+ export interface IndexedAccessType extends Type {
+ objectType: Type;
+ indexType: TypeParameter;
+ }
+
  export const enum SignatureKind {
  Call,
  Construct,