Merge pull request microsoft#8125 from Microsoft/fixDisplayForStringyMembers

Fix display for literal members

Author: DanielRosenwasser

src/compiler/checker.ts

@@ -1808,12 +1808,38 @@ namespace ts {
 
  /**
  * Writes only the name of the symbol out to the writer. Uses the original source text
- * for the name of the symbol if it is available to match how the user inputted the name.
+ * for the name of the symbol if it is available to match how the user wrote the name.
  */
  function appendSymbolNameOnly(symbol: Symbol, writer: SymbolWriter): void {
  writer.writeSymbol(getNameOfSymbol(symbol), symbol);
  }
 
+ /**
+ * Writes a property access or element access with the name of the symbol out to the writer.
+ * Uses the original source text for the name of the symbol if it is available to match how the user wrote the name,
+ * ensuring that any names written with literals use element accesses.
+ */
+ function appendPropertyOrElementAccessForSymbol(symbol: Symbol, writer: SymbolWriter): void {
+ const symbolName = getNameOfSymbol(symbol);
+ const firstChar = symbolName.charCodeAt(0);
+ const needsElementAccess = !isIdentifierStart(firstChar, languageVersion);
+
+ if (needsElementAccess) {
+ writePunctuation(writer, SyntaxKind.OpenBracketToken);
+ if (isSingleOrDoubleQuote(firstChar)) {
+ writer.writeStringLiteral(symbolName);
+ }
+ else {
+ writer.writeSymbol(symbolName, symbol);
+ }
+ writePunctuation(writer, SyntaxKind.CloseBracketToken);
+ }
+ else {
+ writePunctuation(writer, SyntaxKind.DotToken);
+ writer.writeSymbol(symbolName, symbol);
+ }
+ }
+
  /**
  * Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
  * Meaning needs to be specified if the enclosing declaration is given
@@ -1832,10 +1858,12 @@ namespace ts {
  buildTypeParameterDisplayFromSymbol(parentSymbol, writer, enclosingDeclaration);
  }
  }
- writePunctuation(writer, SyntaxKind.DotToken);
+ appendPropertyOrElementAccessForSymbol(symbol, writer);
+ }
+ else {
+ appendSymbolNameOnly(symbol, writer);
  }
  parentSymbol = symbol;
- appendSymbolNameOnly(symbol, writer);
  }
 
  // const the writer know we just wrote out a symbol. The declaration emitter writer uses
@@ -2030,10 +2058,10 @@ namespace ts {
  if (symbol) {
  // Always use 'typeof T' for type of class, enum, and module objects
  if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule)) {
- writeTypeofSymbol(type, flags);
+ writeTypeOfSymbol(type, flags);
  }
  else if (shouldWriteTypeOfFunctionSymbol()) {
- writeTypeofSymbol(type, flags);
+ writeTypeOfSymbol(type, flags);
  }
  else if (contains(symbolStack, symbol)) {
  // If type is an anonymous type literal in a type alias declaration, use type alias name
@@ -2078,7 +2106,7 @@ namespace ts {
  }
  }
 
- function writeTypeofSymbol(type: ObjectType, typeFormatFlags?: TypeFormatFlags) {
+ function writeTypeOfSymbol(type: ObjectType, typeFormatFlags?: TypeFormatFlags) {
  writeKeyword(writer, SyntaxKind.TypeOfKeyword);
  writeSpace(writer);
  buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Value, SymbolFormatFlags.None, typeFormatFlags);

src/compiler/utilities.ts

@@ -1196,6 +1196,10 @@ namespace ts {
  return isRequire && (!checkArgumentIsStringLiteral || (<CallExpression>expression).arguments[0].kind === SyntaxKind.StringLiteral);
  }
 
+ export function isSingleOrDoubleQuote(charCode: number) {
+ return charCode === CharacterCodes.singleQuote || charCode === CharacterCodes.doubleQuote;
+ }
+
  /// Given a BinaryExpression, returns SpecialPropertyAssignmentKind for the various kinds of property
  /// assignments we treat as special in the binder
  export function getSpecialPropertyAssignmentKind(expression: Node): SpecialPropertyAssignmentKind {

tests/baselines/reference/constIndexedAccess.symbols

@@ -24,12 +24,12 @@ let test: indexAccess;
 let s = test[0];
 >s : Symbol(s, Decl(constIndexedAccess.ts, 13, 3))
 >test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
->0 : Symbol(indexAccess.0, Decl(constIndexedAccess.ts, 6, 23))
+>0 : Symbol(indexAccess[0], Decl(constIndexedAccess.ts, 6, 23))
 
 let n = test[1];
 >n : Symbol(n, Decl(constIndexedAccess.ts, 14, 3))
 >test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3))
->1 : Symbol(indexAccess.1, Decl(constIndexedAccess.ts, 7, 14))
+>1 : Symbol(indexAccess[1], Decl(constIndexedAccess.ts, 7, 14))
 
 let s1 = test[numbers.zero];
 >s1 : Symbol(s1, Decl(constIndexedAccess.ts, 16, 3))

tests/baselines/reference/indexersInClassType.symbols

@@ -36,12 +36,12 @@ var r = c.fn();
 var r2 = r[1];
 >r2 : Symbol(r2, Decl(indexersInClassType.ts, 13, 3))
 >r : Symbol(r, Decl(indexersInClassType.ts, 12, 3))
->1 : Symbol(C.1, Decl(indexersInClassType.ts, 2, 24))
+>1 : Symbol(C[1], Decl(indexersInClassType.ts, 2, 24))
 
 var r3 = r.a
 >r3 : Symbol(r3, Decl(indexersInClassType.ts, 14, 3))
->r.a : Symbol(C.'a', Decl(indexersInClassType.ts, 3, 12))
+>r.a : Symbol(C['a'], Decl(indexersInClassType.ts, 3, 12))
 >r : Symbol(r, Decl(indexersInClassType.ts, 12, 3))
->a : Symbol(C.'a', Decl(indexersInClassType.ts, 3, 12))
+>a : Symbol(C['a'], Decl(indexersInClassType.ts, 3, 12))
 
 

tests/baselines/reference/negateOperatorWithEnumType.symbols

@@ -26,7 +26,7 @@ var ResultIsNumber3 = -(ENUM1.B + ENUM1[""]);
 >ENUM1 : Symbol(ENUM1, Decl(negateOperatorWithEnumType.ts, 2, 14))
 >B : Symbol(ENUM1.B, Decl(negateOperatorWithEnumType.ts, 3, 15))
 >ENUM1 : Symbol(ENUM1, Decl(negateOperatorWithEnumType.ts, 2, 14))
->"" : Symbol(ENUM1."", Decl(negateOperatorWithEnumType.ts, 3, 18))
+>"" : Symbol(ENUM1[""], Decl(negateOperatorWithEnumType.ts, 3, 18))
 
 // miss assignment operators
 -ENUM;

tests/baselines/reference/newWithSpreadES5.symbols

@@ -202,61 +202,61 @@ new B(1, 2, ...a, "string");
 // Property access expression
 new c["a-b"](1, 2, "string");
 >c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 
 new c["a-b"](1, 2, ...a);
 >c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 >a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3))
 
 new c["a-b"](1, 2, ...a, "string");
 >c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 >a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3))
 
 // Parenthesised expression
 new (c["a-b"])(1, 2, "string");
 >c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 
 new (c["a-b"])(1, 2, ...a);
 >c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 >a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3))
 
 new (c["a-b"])(1, 2, ...a, "string");
 >c : Symbol(c, Decl(newWithSpreadES5.ts, 26, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 >a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3))
 
 // Element access expression
 new g[1]["a-b"](1, 2, "string");
 >g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 
 new g[1]["a-b"](1, 2, ...a);
 >g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 >a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3))
 
 new g[1]["a-b"](1, 2, ...a, "string");
 >g : Symbol(g, Decl(newWithSpreadES5.ts, 29, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 >a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3))
 
 // Element access expression with a punctuated key
 new h["a-b"]["a-b"](1, 2, "string");
 >h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 
 new h["a-b"]["a-b"](1, 2, ...a);
 >h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 >a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3))
 
 new h["a-b"]["a-b"](1, 2, ...a, "string");
 >h : Symbol(h, Decl(newWithSpreadES5.ts, 30, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES5.ts, 16, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES5.ts, 16, 13))
 >a : Symbol(a, Decl(newWithSpreadES5.ts, 24, 3))
 
 // Element access expression with a number

tests/baselines/reference/newWithSpreadES6.symbols

@@ -203,61 +203,61 @@ new B(1, 2, ...a, "string");
 // Property access expression
 new c["a-b"](1, 2, "string");
 >c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 
 new c["a-b"](1, 2, ...a);
 >c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 >a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3))
 
 new c["a-b"](1, 2, ...a, "string");
 >c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 >a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3))
 
 // Parenthesised expression
 new (c["a-b"])(1, 2, "string");
 >c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 
 new (c["a-b"])(1, 2, ...a);
 >c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 >a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3))
 
 new (c["a-b"])(1, 2, ...a, "string");
 >c : Symbol(c, Decl(newWithSpreadES6.ts, 27, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 >a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3))
 
 // Element access expression
 new g[1]["a-b"](1, 2, "string");
 >g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 
 new g[1]["a-b"](1, 2, ...a);
 >g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 >a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3))
 
 new g[1]["a-b"](1, 2, ...a, "string");
 >g : Symbol(g, Decl(newWithSpreadES6.ts, 30, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 >a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3))
 
 // Element access expression with a punctuated key
 new h["a-b"]["a-b"](1, 2, "string");
 >h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 
 new h["a-b"]["a-b"](1, 2, ...a);
 >h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 >a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3))
 
 new h["a-b"]["a-b"](1, 2, ...a, "string");
 >h : Symbol(h, Decl(newWithSpreadES6.ts, 31, 3))
->"a-b" : Symbol(C."a-b", Decl(newWithSpreadES6.ts, 17, 13))
+>"a-b" : Symbol(C["a-b"], Decl(newWithSpreadES6.ts, 17, 13))
 >a : Symbol(a, Decl(newWithSpreadES6.ts, 25, 3))
 
 // Element access expression with a number

tests/baselines/reference/numericIndexingResults.symbols

@@ -16,12 +16,12 @@ var c: C;
 var r1 = c['1'];
 >r1 : Symbol(r1, Decl(numericIndexingResults.ts, 7, 3), Decl(numericIndexingResults.ts, 21, 3), Decl(numericIndexingResults.ts, 34, 3))
 >c : Symbol(c, Decl(numericIndexingResults.ts, 6, 3))
->'1' : Symbol(C.1, Decl(numericIndexingResults.ts, 1, 24))
+>'1' : Symbol(C[1], Decl(numericIndexingResults.ts, 1, 24))
 
 var r2 = c['2'];
 >r2 : Symbol(r2, Decl(numericIndexingResults.ts, 8, 3), Decl(numericIndexingResults.ts, 22, 3), Decl(numericIndexingResults.ts, 35, 3))
 >c : Symbol(c, Decl(numericIndexingResults.ts, 6, 3))
->'2' : Symbol(C."2", Decl(numericIndexingResults.ts, 2, 11))
+>'2' : Symbol(C["2"], Decl(numericIndexingResults.ts, 2, 11))
 
 var r3 = c['3'];
 >r3 : Symbol(r3, Decl(numericIndexingResults.ts, 9, 3), Decl(numericIndexingResults.ts, 23, 3), Decl(numericIndexingResults.ts, 36, 3), Decl(numericIndexingResults.ts, 44, 3), Decl(numericIndexingResults.ts, 52, 3))
@@ -30,12 +30,12 @@ var r3 = c['3'];
 var r4 = c[1];
 >r4 : Symbol(r4, Decl(numericIndexingResults.ts, 10, 3), Decl(numericIndexingResults.ts, 24, 3), Decl(numericIndexingResults.ts, 37, 3), Decl(numericIndexingResults.ts, 45, 3), Decl(numericIndexingResults.ts, 53, 3))
 >c : Symbol(c, Decl(numericIndexingResults.ts, 6, 3))
->1 : Symbol(C.1, Decl(numericIndexingResults.ts, 1, 24))
+>1 : Symbol(C[1], Decl(numericIndexingResults.ts, 1, 24))
 
 var r5 = c[2];
 >r5 : Symbol(r5, Decl(numericIndexingResults.ts, 11, 3), Decl(numericIndexingResults.ts, 25, 3), Decl(numericIndexingResults.ts, 38, 3), Decl(numericIndexingResults.ts, 46, 3), Decl(numericIndexingResults.ts, 54, 3))
 >c : Symbol(c, Decl(numericIndexingResults.ts, 6, 3))
->2 : Symbol(C."2", Decl(numericIndexingResults.ts, 2, 11))
+>2 : Symbol(C["2"], Decl(numericIndexingResults.ts, 2, 11))
 
 var r6 = c[3];
 >r6 : Symbol(r6, Decl(numericIndexingResults.ts, 12, 3), Decl(numericIndexingResults.ts, 26, 3), Decl(numericIndexingResults.ts, 39, 3), Decl(numericIndexingResults.ts, 47, 3), Decl(numericIndexingResults.ts, 55, 3))
@@ -58,12 +58,12 @@ var i: I
 var r1 = i['1'];
 >r1 : Symbol(r1, Decl(numericIndexingResults.ts, 7, 3), Decl(numericIndexingResults.ts, 21, 3), Decl(numericIndexingResults.ts, 34, 3))
 >i : Symbol(i, Decl(numericIndexingResults.ts, 20, 3))
->'1' : Symbol(I.1, Decl(numericIndexingResults.ts, 15, 24))
+>'1' : Symbol(I[1], Decl(numericIndexingResults.ts, 15, 24))
 
 var r2 = i['2'];
 >r2 : Symbol(r2, Decl(numericIndexingResults.ts, 8, 3), Decl(numericIndexingResults.ts, 22, 3), Decl(numericIndexingResults.ts, 35, 3))
 >i : Symbol(i, Decl(numericIndexingResults.ts, 20, 3))
->'2' : Symbol(I."2", Decl(numericIndexingResults.ts, 16, 14))
+>'2' : Symbol(I["2"], Decl(numericIndexingResults.ts, 16, 14))
 
 var r3 = i['3'];
 >r3 : Symbol(r3, Decl(numericIndexingResults.ts, 9, 3), Decl(numericIndexingResults.ts, 23, 3), Decl(numericIndexingResults.ts, 36, 3), Decl(numericIndexingResults.ts, 44, 3), Decl(numericIndexingResults.ts, 52, 3))
@@ -72,12 +72,12 @@ var r3 = i['3'];
 var r4 = i[1];
 >r4 : Symbol(r4, Decl(numericIndexingResults.ts, 10, 3), Decl(numericIndexingResults.ts, 24, 3), Decl(numericIndexingResults.ts, 37, 3), Decl(numericIndexingResults.ts, 45, 3), Decl(numericIndexingResults.ts, 53, 3))
 >i : Symbol(i, Decl(numericIndexingResults.ts, 20, 3))
->1 : Symbol(I.1, Decl(numericIndexingResults.ts, 15, 24))
+>1 : Symbol(I[1], Decl(numericIndexingResults.ts, 15, 24))
 
 var r5 = i[2];
 >r5 : Symbol(r5, Decl(numericIndexingResults.ts, 11, 3), Decl(numericIndexingResults.ts, 25, 3), Decl(numericIndexingResults.ts, 38, 3), Decl(numericIndexingResults.ts, 46, 3), Decl(numericIndexingResults.ts, 54, 3))
 >i : Symbol(i, Decl(numericIndexingResults.ts, 20, 3))
->2 : Symbol(I."2", Decl(numericIndexingResults.ts, 16, 14))
+>2 : Symbol(I["2"], Decl(numericIndexingResults.ts, 16, 14))
 
 var r6 = i[3];
 >r6 : Symbol(r6, Decl(numericIndexingResults.ts, 12, 3), Decl(numericIndexingResults.ts, 26, 3), Decl(numericIndexingResults.ts, 39, 3), Decl(numericIndexingResults.ts, 47, 3), Decl(numericIndexingResults.ts, 55, 3))