Rename HeritageClauseElement to ExpressionWithTypeArguments + related methods.

Author: Paul van Brenk

src/compiler/checker.ts

@@ -2473,7 +2473,7 @@ module ts {
  let declaration = <ClassDeclaration>getDeclarationOfKind(type.symbol, SyntaxKind.ClassDeclaration);
  let baseTypeNode = getClassExtendsHeritageClauseElement(declaration);
  if (baseTypeNode) {
- let baseType = getTypeFromHeritageClauseElement(baseTypeNode);
+ let baseType = getTypeFromExpressionWithTypeArguments(baseTypeNode);
  if (baseType !== unknownType) {
  if (getTargetType(baseType).flags & TypeFlags.Class) {
  if (type !== baseType && !hasBaseType(<InterfaceType>baseType, type)) {
@@ -2495,7 +2495,7 @@ module ts {
  for (let declaration of type.symbol.declarations) {
  if (declaration.kind === SyntaxKind.InterfaceDeclaration && getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
  for (let node of getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
- let baseType = getTypeFromHeritageClauseElement(node);
+ let baseType = getTypeFromExpressionWithTypeArguments(node);
 
  if (baseType !== unknownType) {
  if (getTargetType(baseType).flags & (TypeFlags.Class | TypeFlags.Interface)) {
@@ -3310,7 +3310,7 @@ module ts {
  return type;
  }
 
- function isTypeParameterReferenceIllegalInConstraint(typeReferenceNode: TypeReferenceNode | HeritageClauseElement, typeParameterSymbol: Symbol): boolean {
+ function isTypeParameterReferenceIllegalInConstraint(typeReferenceNode: TypeReferenceNode | ExpressionWithTypeArguments, typeParameterSymbol: Symbol): boolean {
  let links = getNodeLinks(typeReferenceNode);
  if (links.isIllegalTypeReferenceInConstraint !== undefined) {
  return links.isIllegalTypeReferenceInConstraint;
@@ -3360,24 +3360,24 @@ module ts {
  }
 
  function getTypeFromTypeReference(node: TypeReferenceNode): Type {
- return getTypeFromTypeReferenceOrHeritageClauseElement(node);
+ return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node);
  }
 
- function getTypeFromHeritageClauseElement(node: HeritageClauseElement): Type {
- return getTypeFromTypeReferenceOrHeritageClauseElement(node);
+ function getTypeFromExpressionWithTypeArguments(node: ExpressionWithTypeArguments): Type {
+ return getTypeFromTypeReferenceOrExpressionWithTypeArguments(node);
  }
 
- function getTypeFromTypeReferenceOrHeritageClauseElement(node: TypeReferenceNode | HeritageClauseElement): Type {
+ function getTypeFromTypeReferenceOrExpressionWithTypeArguments(node: TypeReferenceNode | ExpressionWithTypeArguments): Type {
  let links = getNodeLinks(node);
  if (!links.resolvedType) {
  let type: Type;
 
  // We don't currently support heritage clauses with complex expressions in them.
  // For these cases, we just set the type to be the unknownType.
- if (node.kind !== SyntaxKind.HeritageClauseElement || isSupportedHeritageClauseElement(<HeritageClauseElement>node)) {
+ if (node.kind !== SyntaxKind.ExpressionWithTypeArguments || isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node)) {
  let typeNameOrExpression = node.kind === SyntaxKind.TypeReference
  ? (<TypeReferenceNode>node).typeName
- : (<HeritageClauseElement>node).expression;
+ : (<ExpressionWithTypeArguments>node).expression;
 
  let symbol = resolveEntityName(typeNameOrExpression, SymbolFlags.Type);
  if (symbol) {
@@ -3668,8 +3668,8 @@ module ts {
  return getTypeFromStringLiteral(<StringLiteral>node);
  case SyntaxKind.TypeReference:
  return getTypeFromTypeReference(<TypeReferenceNode>node);
- case SyntaxKind.HeritageClauseElement:
- return getTypeFromHeritageClauseElement(<HeritageClauseElement>node);
+ case SyntaxKind.ExpressionWithTypeArguments:
+ return getTypeFromExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);
  case SyntaxKind.TypeQuery:
  return getTypeFromTypeQueryNode(<TypeQueryNode>node);
  case SyntaxKind.ArrayType:
@@ -8380,20 +8380,20 @@ module ts {
 
  function checkTypeReferenceNode(node: TypeReferenceNode) {
  checkGrammarTypeReferenceInStrictMode(node.typeName);
- return checkTypeReferenceOrHeritageClauseElement(node);
+ return checkTypeReferenceOrExpressionWithTypeArguments(node);
  }
 
- function checkHeritageClauseElement(node: HeritageClauseElement) {
- checkGrammarHeritageClauseElementInStrictMode(<PropertyAccessExpression>node.expression);
+ function checkExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
+ checkGrammarExpressionWithTypeArgumentsInStrictMode(<PropertyAccessExpression>node.expression);
 
- return checkTypeReferenceOrHeritageClauseElement(node);
+ return checkTypeReferenceOrExpressionWithTypeArguments(node);
  }
 
- function checkTypeReferenceOrHeritageClauseElement(node: TypeReferenceNode | HeritageClauseElement) {
+ function checkTypeReferenceOrExpressionWithTypeArguments(node: TypeReferenceNode | ExpressionWithTypeArguments) {
  // Grammar checking
  checkGrammarTypeArguments(node, node.typeArguments);
 
- let type = getTypeFromTypeReferenceOrHeritageClauseElement(node);
+ let type = getTypeFromTypeReferenceOrExpressionWithTypeArguments(node);
  if (type !== unknownType && node.typeArguments) {
  // Do type argument local checks only if referenced type is successfully resolved
  let len = node.typeArguments.length;
@@ -9959,12 +9959,12 @@ module ts {
  let staticType = <ObjectType>getTypeOfSymbol(symbol);
  let baseTypeNode = getClassExtendsHeritageClauseElement(node);
  if (baseTypeNode) {
- if (!isSupportedHeritageClauseElement(baseTypeNode)) {
+ if (!isSupportedExpressionWithTypeArguments(baseTypeNode)) {
  error(baseTypeNode.expression, Diagnostics.Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses);
  }
 
  emitExtends = emitExtends || !isInAmbientContext(node);
- checkHeritageClauseElement(baseTypeNode);
+ checkExpressionWithTypeArguments(baseTypeNode);
  }
  let baseTypes = getBaseTypes(type);
  if (baseTypes.length) {
@@ -9991,13 +9991,13 @@ module ts {
  let implementedTypeNodes = getClassImplementsHeritageClauseElements(node);
  if (implementedTypeNodes) {
  forEach(implementedTypeNodes, typeRefNode => {
- if (!isSupportedHeritageClauseElement(typeRefNode)) {
+ if (!isSupportedExpressionWithTypeArguments(typeRefNode)) {
  error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
  }
 
- checkHeritageClauseElement(typeRefNode);
+ checkExpressionWithTypeArguments(typeRefNode);
  if (produceDiagnostics) {
- let t = getTypeFromHeritageClauseElement(typeRefNode);
+ let t = getTypeFromExpressionWithTypeArguments(typeRefNode);
  if (t !== unknownType) {
  let declaredType = (t.flags & TypeFlags.Reference) ? (<TypeReference>t).target : t;
  if (declaredType.flags & (TypeFlags.Class | TypeFlags.Interface)) {
@@ -10192,11 +10192,11 @@ module ts {
  }
  }
  forEach(getInterfaceBaseTypeNodes(node), heritageElement => {
- if (!isSupportedHeritageClauseElement(heritageElement)) {
+ if (!isSupportedExpressionWithTypeArguments(heritageElement)) {
  error(heritageElement.expression, Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
  }
 
- checkHeritageClauseElement(heritageElement);
+ checkExpressionWithTypeArguments(heritageElement);
  });
  forEach(node.members, checkSourceElement);
 
@@ -11154,7 +11154,7 @@ module ts {
  node = node.parent;
  }
 
- return node.parent && node.parent.kind === SyntaxKind.HeritageClauseElement;
+ return node.parent && node.parent.kind === SyntaxKind.ExpressionWithTypeArguments;
  }
 
  function isTypeNode(node: Node): boolean {
@@ -11174,7 +11174,7 @@ module ts {
  case SyntaxKind.StringLiteral:
  // Specialized signatures can have string literals as their parameters' type names
  return node.parent.kind === SyntaxKind.Parameter;
- case SyntaxKind.HeritageClauseElement:
+ case SyntaxKind.ExpressionWithTypeArguments:
  return true;
 
  // Identifiers and qualified names may be type nodes, depending on their context. Climb
@@ -11208,7 +11208,7 @@ module ts {
  return true;
  }
  switch (parent.kind) {
- case SyntaxKind.HeritageClauseElement:
+ case SyntaxKind.ExpressionWithTypeArguments:
  return true;
  case SyntaxKind.TypeParameter:
  return node === (<TypeParameterDeclaration>parent).constraint;
@@ -11286,7 +11286,7 @@ module ts {
  }
 
  if (isHeritageClauseElementIdentifier(<EntityName>entityName)) {
- let meaning = entityName.parent.kind === SyntaxKind.HeritageClauseElement ? SymbolFlags.Type : SymbolFlags.Namespace;
+ let meaning = entityName.parent.kind === SyntaxKind.ExpressionWithTypeArguments ? SymbolFlags.Type : SymbolFlags.Namespace;
  meaning |= SymbolFlags.Alias;
  return resolveEntityName(<EntityName>entityName, meaning);
  }
@@ -12117,7 +12117,7 @@ module ts {
  // public // error at public
  // public.private.package // error at public
  // B.private.B // no error
- function checkGrammarHeritageClauseElementInStrictMode(expression: Expression) {
+ function checkGrammarExpressionWithTypeArgumentsInStrictMode(expression: Expression) {
  // Example:
  // class C extends public // error at public
  if (expression && expression.kind === SyntaxKind.Identifier) {
@@ -12128,7 +12128,7 @@ module ts {
  // in PropertyAccessExpression. According to grammar production of MemberExpression,
  // the left component expression is a PrimaryExpression (i.e. Identifier) while the other
  // component after dots can be IdentifierName.
- checkGrammarHeritageClauseElementInStrictMode((<PropertyAccessExpression>expression).expression);
+ checkGrammarExpressionWithTypeArgumentsInStrictMode((<PropertyAccessExpression>expression).expression);
  }
 
  }

src/compiler/declarationEmitter.ts

@@ -329,8 +329,8 @@ module ts {
  case SyntaxKind.VoidKeyword:
  case SyntaxKind.StringLiteral:
  return writeTextOfNode(currentSourceFile, type);
- case SyntaxKind.HeritageClauseElement:
- return emitHeritageClauseElement(<HeritageClauseElement>type);
+ case SyntaxKind.ExpressionWithTypeArguments:
+ return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>type);
  case SyntaxKind.TypeReference:
  return emitTypeReference(<TypeReferenceNode>type);
  case SyntaxKind.TypeQuery:
@@ -376,8 +376,8 @@ module ts {
  }
  }
 
- function emitHeritageClauseElement(node: HeritageClauseElement) {
- if (isSupportedHeritageClauseElement(node)) {
+ function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
+ if (isSupportedExpressionWithTypeArguments(node)) {
  Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
  emitEntityName(<Identifier | PropertyAccessExpression>node.expression);
  if (node.typeArguments) {
@@ -861,14 +861,14 @@ module ts {
  }
  }
 
- function emitHeritageClause(typeReferences: HeritageClauseElement[], isImplementsList: boolean) {
+ function emitHeritageClause(typeReferences: ExpressionWithTypeArguments[], isImplementsList: boolean) {
  if (typeReferences) {
  write(isImplementsList ? " implements " : " extends ");
  emitCommaList(typeReferences, emitTypeOfTypeReference);
  }
 
- function emitTypeOfTypeReference(node: HeritageClauseElement) {
- if (isSupportedHeritageClauseElement(node)) {
+ function emitTypeOfTypeReference(node: ExpressionWithTypeArguments) {
+ if (isSupportedExpressionWithTypeArguments(node)) {
  emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
  }
 

src/compiler/emitter.ts

@@ -3641,7 +3641,7 @@ if (typeof __param !== "function") __param = function (paramIndex, decorator) {
  }
  }
 
- function emitConstructor(node: ClassLikeDeclaration, baseTypeElement: HeritageClauseElement) {
+ function emitConstructor(node: ClassLikeDeclaration, baseTypeElement: ExpressionWithTypeArguments) {
  let saveTempFlags = tempFlags;
  let saveTempVariables = tempVariables;
  let saveTempParameters = tempParameters;
@@ -3656,7 +3656,7 @@ if (typeof __param !== "function") __param = function (paramIndex, decorator) {
  tempParameters = saveTempParameters;
  }
 
- function emitConstructorWorker(node: ClassLikeDeclaration, baseTypeElement: HeritageClauseElement) {
+ function emitConstructorWorker(node: ClassLikeDeclaration, baseTypeElement: ExpressionWithTypeArguments) {
  // Check if we have property assignment inside class declaration.
  // If there is property assignment, we need to emit constructor whether users define it or not
  // If there is no property assignment, we can omit constructor if users do not define it

src/compiler/parser.ts

@@ -308,9 +308,9 @@ module ts {
  return visitNode(cbNode, (<ComputedPropertyName>node).expression);
  case SyntaxKind.HeritageClause:
  return visitNodes(cbNodes, (<HeritageClause>node).types);
- case SyntaxKind.HeritageClauseElement:
- return visitNode(cbNode, (<HeritageClauseElement>node).expression) ||
- visitNodes(cbNodes, (<HeritageClauseElement>node).typeArguments);
+ case SyntaxKind.ExpressionWithTypeArguments:
+ return visitNode(cbNode, (<ExpressionWithTypeArguments>node).expression) ||
+ visitNodes(cbNodes, (<ExpressionWithTypeArguments>node).typeArguments);
  case SyntaxKind.ExternalModuleReference:
  return visitNode(cbNode, (<ExternalModuleReference>node).expression);
  case SyntaxKind.MissingDeclaration:
@@ -4284,15 +4284,15 @@ module ts {
  let node = <HeritageClause>createNode(SyntaxKind.HeritageClause);
  node.token = token;
  nextToken();
- node.types = parseDelimitedList(ParsingContext.HeritageClauseElement, parseHeritageClauseElement);
+ node.types = parseDelimitedList(ParsingContext.HeritageClauseElement, parseExpressionWithTypeArguments);
  return finishNode(node);
  }
 
  return undefined;
  }
 
- function parseHeritageClauseElement(): HeritageClauseElement {
- let node = <HeritageClauseElement>createNode(SyntaxKind.HeritageClauseElement);
+ function parseExpressionWithTypeArguments(): ExpressionWithTypeArguments {
+ let node = <ExpressionWithTypeArguments>createNode(SyntaxKind.ExpressionWithTypeArguments);
  node.expression = parseLeftHandSideExpressionOrHigher();
  if (token === SyntaxKind.LessThanToken) {
  node.typeArguments = parseBracketedList(ParsingContext.TypeArguments, parseType, SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken);

src/compiler/types.ts

@@ -206,9 +206,9 @@ module ts {
  SpreadElementExpression,
  ClassExpression,
  OmittedExpression,
+ ExpressionWithTypeArguments,
  // Misc
  TemplateSpan,
- HeritageClauseElement,
  SemicolonClassElement,
  // Element
  Block,
@@ -741,7 +741,7 @@ module ts {
  arguments: NodeArray<Expression>;
  }
 
- export interface HeritageClauseElement extends TypeNode {
+ export interface ExpressionWithTypeArguments extends TypeNode {
  expression: LeftHandSideExpression;
  typeArguments?: NodeArray<TypeNode>;
  }
@@ -893,7 +893,7 @@ module ts {
 
  export interface HeritageClause extends Node {
  token: SyntaxKind;
- types?: NodeArray<HeritageClauseElement>;
+ types?: NodeArray<ExpressionWithTypeArguments>;
  }
 
  export interface TypeAliasDeclaration extends Declaration, ModuleElement {

src/compiler/utilities.ts

@@ -1671,16 +1671,16 @@ module ts {
 
  // Returns false if this heritage clause element's expression contains something unsupported
  // (i.e. not a name or dotted name).
- export function isSupportedHeritageClauseElement(node: HeritageClauseElement): boolean {
- return isSupportedHeritageClauseElementExpression(node.expression);
+ export function isSupportedExpressionWithTypeArguments(node: ExpressionWithTypeArguments): boolean {
+ return isSupportedExpressionWithTypeArgumentsRest(node.expression);
  }
 
- function isSupportedHeritageClauseElementExpression(node: Expression): boolean {
+ function isSupportedExpressionWithTypeArgumentsRest(node: Expression): boolean {
  if (node.kind === SyntaxKind.Identifier) {
  return true;
  }
  else if (node.kind === SyntaxKind.PropertyAccessExpression) {
- return isSupportedHeritageClauseElementExpression((<PropertyAccessExpression>node).expression);
+ return isSupportedExpressionWithTypeArgumentsRest((<PropertyAccessExpression>node).expression);
  }
  else {
  return false;