Template literal types and mapped type 'as' clauses

src/compiler/diagnosticMessages.json

@@ -3028,6 +3028,10 @@
  "category": "Error",
  "code": 2792
  },
+ "Template literal type argument '{0}' is not literal type or a generic type.": {
+ "category": "Error",
+ "code": 2793
+ },
 
  "Import declaration '{0}' is using private name '{1}'.": {
  "category": "Error",

src/compiler/emitter.ts

@@ -1313,6 +1313,8 @@ namespace ts {
  return emitConstructSignature(<ConstructSignatureDeclaration>node);
  case SyntaxKind.IndexSignature:
  return emitIndexSignature(<IndexSignatureDeclaration>node);
+ case SyntaxKind.TemplateLiteralTypeSpan:
+ return emitTemplateTypeSpan(<TemplateLiteralTypeSpan>node);
 
  // Types
  case SyntaxKind.TypePredicate:
@@ -1357,6 +1359,8 @@ namespace ts {
  return emitMappedType(<MappedTypeNode>node);
  case SyntaxKind.LiteralType:
  return emitLiteralType(<LiteralTypeNode>node);
+ case SyntaxKind.TemplateLiteralType:
+ return emitTemplateType(<TemplateLiteralTypeNode>node);
  case SyntaxKind.ImportType:
  return emitImportTypeNode(<ImportTypeNode>node);
  case SyntaxKind.JSDocAllType:
@@ -2010,6 +2014,20 @@ namespace ts {
  writeTrailingSemicolon();
  }
 
+ function emitTemplateTypeSpan(node: TemplateLiteralTypeSpan) {
+ const keyword = node.casing === TemplateCasing.Uppercase ? "uppercase" :
+ node.casing === TemplateCasing.Lowercase ? "lowercase" :
+ node.casing === TemplateCasing.Capitalize ? "capitalize" :
+ node.casing === TemplateCasing.Uncapitalize ? "uncapitalize" :
+ undefined;
+ if (keyword) {
+ writeKeyword(keyword);
+ writeSpace();
+ }
+ emit(node.type);
+ emit(node.literal);
+ }
+
  function emitSemicolonClassElement() {
  writeTrailingSemicolon();
  }
@@ -2202,6 +2220,12 @@ namespace ts {
  writePunctuation("[");
 
  pipelineEmit(EmitHint.MappedTypeParameter, node.typeParameter);
+ if (node.nameType) {
+ writeSpace();
+ writeKeyword("as");
+ writeSpace();
+ emit(node.nameType);
+ }
 
  writePunctuation("]");
  if (node.questionToken) {
@@ -2228,6 +2252,11 @@ namespace ts {
  emitExpression(node.literal);
  }
 
+ function emitTemplateType(node: TemplateLiteralTypeNode) {
+ emit(node.head);
+ emitList(node, node.templateSpans, ListFormat.TemplateExpressionSpans);
+ }
+
  function emitImportTypeNode(node: ImportTypeNode) {
  if (node.isTypeOf) {
  writeKeyword("typeof");

src/compiler/factory/nodeFactory.ts

@@ -94,6 +94,8 @@ namespace ts {
  updateConstructSignature,
  createIndexSignature,
  updateIndexSignature,
+ createTemplateLiteralTypeSpan,
+ updateTemplateLiteralTypeSpan,
  createKeywordTypeNode,
  createTypePredicateNode,
  updateTypePredicateNode,
@@ -138,6 +140,8 @@ namespace ts {
  updateMappedTypeNode,
  createLiteralTypeNode,
  updateLiteralTypeNode,
+ createTemplateLiteralType,
+ updateTemplateLiteralType,
  createObjectBindingPattern,
  updateObjectBindingPattern,
  createArrayBindingPattern,
@@ -1600,6 +1604,25 @@ namespace ts {
  : node;
  }
 
+ // @api
+ function createTemplateLiteralTypeSpan(casing: TemplateCasing, type: TypeNode, literal: TemplateMiddle | TemplateTail) {
+ const node = createBaseNode<TemplateLiteralTypeSpan>(SyntaxKind.TemplateLiteralTypeSpan);
+ node.casing = casing;
+ node.type = type;
+ node.literal = literal;
+ node.transformFlags = TransformFlags.ContainsTypeScript;
+ return node;
+ }
+
+ // @api
+ function updateTemplateLiteralTypeSpan(casing: TemplateCasing, node: TemplateLiteralTypeSpan, type: TypeNode, literal: TemplateMiddle | TemplateTail) {
+ return node.casing !== casing
+ || node.type !== type
+ || node.literal !== literal
+ ? update(createTemplateLiteralTypeSpan(casing, type, literal), node)
+ : node;
+ }
+
  //
  // Types
  //
@@ -1891,6 +1914,23 @@ namespace ts {
  : node;
  }
 
+ // @api
+ function createTemplateLiteralType(head: TemplateHead, templateSpans: readonly TemplateLiteralTypeSpan[]) {
+ const node = createBaseNode<TemplateLiteralTypeNode>(SyntaxKind.TemplateLiteralType);
+ node.head = head;
+ node.templateSpans = createNodeArray(templateSpans);
+ node.transformFlags = TransformFlags.ContainsTypeScript;
+ return node;
+ }
+
+ // @api
+ function updateTemplateLiteralType(node: TemplateLiteralTypeNode, head: TemplateHead, templateSpans: readonly TemplateLiteralTypeSpan[]) {
+ return node.head !== head
+ || node.templateSpans !== templateSpans
+ ? update(createTemplateLiteralType(head, templateSpans), node)
+ : node;
+ }
+
  // @api
  function createImportTypeNode(argument: TypeNode, qualifier?: EntityName, typeArguments?: readonly TypeNode[], isTypeOf = false) {
  const node = createBaseNode<ImportTypeNode>(SyntaxKind.ImportType);
@@ -1968,23 +2008,25 @@ namespace ts {
  }
 
  // @api
- function createMappedTypeNode(readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined): MappedTypeNode {
+ function createMappedTypeNode(readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined): MappedTypeNode {
  const node = createBaseNode<MappedTypeNode>(SyntaxKind.MappedType);
  node.readonlyToken = readonlyToken;
  node.typeParameter = typeParameter;
+ node.nameType = nameType;
  node.questionToken = questionToken;
  node.type = type;
  node.transformFlags = TransformFlags.ContainsTypeScript;
  return node;
  }
 
  // @api
- function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined): MappedTypeNode {
+ function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined): MappedTypeNode {
  return node.readonlyToken !== readonlyToken
  || node.typeParameter !== typeParameter
+ || node.nameType !== nameType
  || node.questionToken !== questionToken
  || node.type !== type
- ? update(createMappedTypeNode(readonlyToken, typeParameter, questionToken, type), node)
+ ? update(createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type), node)
  : node;
  }
 

src/compiler/parser.ts

@@ -206,6 +206,7 @@ namespace ts {
  case SyntaxKind.MappedType:
  return visitNode(cbNode, (<MappedTypeNode>node).readonlyToken) ||
  visitNode(cbNode, (<MappedTypeNode>node).typeParameter) ||
+ visitNode(cbNode, (<MappedTypeNode>node).nameType) ||
  visitNode(cbNode, (<MappedTypeNode>node).questionToken) ||
  visitNode(cbNode, (<MappedTypeNode>node).type);
  case SyntaxKind.LiteralType:
@@ -424,6 +425,10 @@ namespace ts {
  return visitNode(cbNode, (<TemplateExpression>node).head) || visitNodes(cbNode, cbNodes, (<TemplateExpression>node).templateSpans);
  case SyntaxKind.TemplateSpan:
  return visitNode(cbNode, (<TemplateSpan>node).expression) || visitNode(cbNode, (<TemplateSpan>node).literal);
+ case SyntaxKind.TemplateLiteralType:
+ return visitNode(cbNode, (<TemplateLiteralTypeNode>node).head) || visitNodes(cbNode, cbNodes, (<TemplateLiteralTypeNode>node).templateSpans);
+ case SyntaxKind.TemplateLiteralTypeSpan:
+ return visitNode(cbNode, (<TemplateLiteralTypeSpan>node).type) || visitNode(cbNode, (<TemplateLiteralTypeSpan>node).literal);
  case SyntaxKind.ComputedPropertyName:
  return visitNode(cbNode, (<ComputedPropertyName>node).expression);
  case SyntaxKind.HeritageClause:
@@ -2584,6 +2589,49 @@ namespace ts {
  );
  }
 
+ function parseTemplateType(): TemplateLiteralTypeNode {
+ const pos = getNodePos();
+ return finishNode(
+ factory.createTemplateLiteralType(
+ parseTemplateHead(/*isTaggedTemplate*/ false),
+ parseTemplateTypeSpans()
+ ),
+ pos
+ );
+ }
+
+ function parseTemplateTypeSpans() {
+ const pos = getNodePos();
+ const list = [];
+ let node: TemplateLiteralTypeSpan;
+ do {
+ node = parseTemplateTypeSpan();
+ list.push(node);
+ }
+ while (node.literal.kind === SyntaxKind.TemplateMiddle);
+ return createNodeArray(list, pos);
+ }
+
+ function parseTemplateTypeSpan(): TemplateLiteralTypeSpan {
+ const pos = getNodePos();
+ return finishNode(
+ factory.createTemplateLiteralTypeSpan(
+ parseTemplateCasing(),
+ parseType(),
+ parseLiteralOfTemplateSpan(/*isTaggedTemplate*/ false)
+ ),
+ pos
+ );
+ }
+
+ function parseTemplateCasing(): TemplateCasing {
+ return parseOptional(SyntaxKind.UppercaseKeyword) ? TemplateCasing.Uppercase :
+ parseOptional(SyntaxKind.LowercaseKeyword) ? TemplateCasing.Lowercase :
+ parseOptional(SyntaxKind.CapitalizeKeyword) ? TemplateCasing.Capitalize :
+ parseOptional(SyntaxKind.UncapitalizeKeyword) ? TemplateCasing.Uncapitalize :
+ TemplateCasing.None;
+ }
+
  function parseLiteralOfTemplateSpan(isTaggedTemplate: boolean) {
  if (token() === SyntaxKind.CloseBraceToken) {
  reScanTemplateToken(isTaggedTemplate);
@@ -3252,6 +3300,7 @@ namespace ts {
  }
  parseExpected(SyntaxKind.OpenBracketToken);
  const typeParameter = parseMappedTypeParameter();
+ const nameType = parseOptional(SyntaxKind.AsKeyword) ? parseType() : undefined;
  parseExpected(SyntaxKind.CloseBracketToken);
  let questionToken: QuestionToken | PlusToken | MinusToken | undefined;
  if (token() === SyntaxKind.QuestionToken || token() === SyntaxKind.PlusToken || token() === SyntaxKind.MinusToken) {
@@ -3263,7 +3312,7 @@ namespace ts {
  const type = parseTypeAnnotation();
  parseSemicolon();
  parseExpected(SyntaxKind.CloseBraceToken);
- return finishNode(factory.createMappedTypeNode(readonlyToken, typeParameter, questionToken, type), pos);
+ return finishNode(factory.createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type), pos);
  }
 
  function parseTupleElementType() {
@@ -3444,6 +3493,8 @@ namespace ts {
  return parseImportType();
  case SyntaxKind.AssertsKeyword:
  return lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? parseAssertsTypePredicate() : parseTypeReference();
+ case SyntaxKind.TemplateHead:
+ return parseTemplateType();
  default:
  return parseTypeReference();
  }
@@ -3485,6 +3536,8 @@ namespace ts {
  case SyntaxKind.InferKeyword:
  case SyntaxKind.ImportKeyword:
  case SyntaxKind.AssertsKeyword:
+ case SyntaxKind.NoSubstitutionTemplateLiteral:
+ case SyntaxKind.TemplateHead:
  return true;
  case SyntaxKind.FunctionKeyword:
  return !inStartOfParameter;

src/compiler/scanner.ts

@@ -151,6 +151,10 @@ namespace ts {
  yield: SyntaxKind.YieldKeyword,
  async: SyntaxKind.AsyncKeyword,
  await: SyntaxKind.AwaitKeyword,
+ uppercase: SyntaxKind.UppercaseKeyword,
+ lowercase: SyntaxKind.LowercaseKeyword,
+ capitalize: SyntaxKind.CapitalizeKeyword,
+ uncapitalize: SyntaxKind.UncapitalizeKeyword,
  of: SyntaxKind.OfKeyword,
  };
 
@@ -1508,9 +1512,9 @@ namespace ts {
  }
 
  function getIdentifierToken(): SyntaxKind.Identifier | KeywordSyntaxKind {
- // Reserved words are between 2 and 11 characters long and start with a lowercase letter
+ // Reserved words are between 2 and 12 characters long and start with a lowercase letter
  const len = tokenValue.length;
- if (len >= 2 && len <= 11) {
+ if (len >= 2 && len <= 12) {
  const ch = tokenValue.charCodeAt(0);
  if (ch >= CharacterCodes.a && ch <= CharacterCodes.z) {
  const keyword = textToKeyword.get(tokenValue);