maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Rename symbol.name to escapedName and make name unescaped (#17412)

Browse source
This commit is contained in:
Andy 2017-07-25 14:22:26 -07:00 committed by GitHub
parent e515151ba4
commit 30d973bdcb
17 changed files with 147 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/compiler/binder.ts
View file

@ -1649,7 +1649,7 @@ namespace ts {
const typeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, InternalSymbolName.Type);
addDeclarationToSymbol(typeLiteralSymbol, node, SymbolFlags.TypeLiteral);
typeLiteralSymbol.members = createSymbolTable();
typeLiteralSymbol.members.set(symbol.name, symbol);
typeLiteralSymbol.members.set(symbol.escapedName, symbol);
}
function bindObjectLiteralExpression(node: ObjectLiteralExpression) {
@ -2447,14 +2447,14 @@ namespace ts {
// module might have an exported variable called 'prototype'. We can't allow that as
// that would clash with the built-in 'prototype' for the class.
const prototypeSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Prototype, "prototype" as __String);
const symbolExport = symbol.exports.get(prototypeSymbol.name);
const symbolExport = symbol.exports.get(prototypeSymbol.escapedName);
if (symbolExport) {
if (node.name) {
node.name.parent = node;
}
file.bindDiagnostics.push(createDiagnosticForNode(symbolExport.declarations[0], Diagnostics.Duplicate_identifier_0, unescapeLeadingUnderscores(prototypeSymbol.name)));
file.bindDiagnostics.push(createDiagnosticForNode(symbolExport.declarations[0], Diagnostics.Duplicate_identifier_0, unescapeLeadingUnderscores(prototypeSymbol.escapedName)));
}
symbol.exports.set(prototypeSymbol.name, prototypeSymbol);
symbol.exports.set(prototypeSymbol.escapedName, prototypeSymbol);
prototypeSymbol.parent = symbol;
}

194
src/compiler/checker.ts
View file

@ -490,7 +490,7 @@ namespace ts {
}
const builtinGlobals = createSymbolTable();
builtinGlobals.set(undefinedSymbol.name, undefinedSymbol);
builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
initializeTypeChecker();
@ -567,7 +567,7 @@ namespace ts {
}
function cloneSymbol(symbol: Symbol): Symbol {
const result = createSymbol(symbol.flags, symbol.name);
const result = createSymbol(symbol.flags, symbol.escapedName);
result.declarations = symbol.declarations.slice(0);
result.parent = symbol.parent;
if (symbol.valueDeclaration) result.valueDeclaration = symbol.valueDeclaration;
@ -935,7 +935,7 @@ namespace ts {
// name of that export default matches.
if (result = moduleExports.get("default" as __String)) {
const localSymbol = getLocalSymbolForExportDefault(result);
if (localSymbol && (result.flags & meaning) && localSymbol.name === name) {
if (localSymbol && (result.flags & meaning) && localSymbol.escapedName === name) {
break loop;
}
result = undefined;
@ -1385,7 +1385,7 @@ namespace ts {
if (valueSymbol.flags & (SymbolFlags.Type | SymbolFlags.Namespace)) {
return valueSymbol;
}
const result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.name);
const result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.escapedName);
result.declarations = concatenate(valueSymbol.declarations, typeSymbol.declarations);
result.parent = valueSymbol.parent || typeSymbol.parent;
if (valueSymbol.valueDeclaration) result.valueDeclaration = valueSymbol.valueDeclaration;
@ -2042,14 +2042,14 @@ namespace ts {
function trySymbolTable(symbols: SymbolTable) {
// If symbol is directly available by its name in the symbol table
if (isAccessible(symbols.get(symbol.name))) {
if (isAccessible(symbols.get(symbol.escapedName))) {
return [symbol];
}
// Check if symbol is any of the alias
return forEachEntry(symbols, symbolFromSymbolTable => {
if (symbolFromSymbolTable.flags & SymbolFlags.Alias
&& symbolFromSymbolTable.name !== "export="
&& symbolFromSymbolTable.escapedName !== "export="
&& !getDeclarationOfKind(symbolFromSymbolTable, SyntaxKind.ExportSpecifier)) {
if (!useOnlyExternalAliasing || // We can use any type of alias to get the name
// Is this external alias, then use it to name
@ -2083,7 +2083,7 @@ namespace ts {
let qualify = false;
forEachSymbolTableInScope(enclosingDeclaration, symbolTable => {
// If symbol of this name is not available in the symbol table we are ok
let symbolFromSymbolTable = symbolTable.get(symbol.name);
let symbolFromSymbolTable = symbolTable.get(symbol.escapedName);
if (!symbolFromSymbolTable) {
// Continue to the next symbol table
return false;
@ -2599,7 +2599,7 @@ namespace ts {
function symbolToTypeReferenceName(symbol: Symbol) {
// Unnamed function expressions and arrow functions have reserved names that we don't want to display
const entityName = symbol.flags & SymbolFlags.Class || !isReservedMemberName(symbol.name) ? symbolToName(symbol, context, SymbolFlags.Type, /*expectsIdentifier*/ false) : createIdentifier("");
const entityName = symbol.flags & SymbolFlags.Class || !isReservedMemberName(symbol.escapedName) ? symbolToName(symbol, context, SymbolFlags.Type, /*expectsIdentifier*/ false) : createIdentifier("");
return entityName;
}
@ -2851,7 +2851,7 @@ namespace ts {
parameterDeclaration.name.kind === SyntaxKind.Identifier ?
setEmitFlags(getSynthesizedClone(parameterDeclaration.name), EmitFlags.NoAsciiEscaping) :
cloneBindingName(parameterDeclaration.name) :
unescapeLeadingUnderscores(parameterSymbol.name);
unescapeLeadingUnderscores(parameterSymbol.escapedName);
const questionToken = isOptionalParameter(parameterDeclaration) ? createToken(SyntaxKind.QuestionToken) : undefined;
let parameterType = getTypeOfSymbol(parameterSymbol);
@ -2987,7 +2987,7 @@ namespace ts {
return "(Anonymous function)";
}
}
return unescapeLeadingUnderscores(symbol.name);
return unescapeLeadingUnderscores(symbol.escapedName);
}
}
@ -3071,7 +3071,7 @@ namespace ts {
return "(Anonymous function)";
}
}
return unescapeLeadingUnderscores(symbol.name);
return unescapeLeadingUnderscores(symbol.escapedName);
}
function getSymbolDisplayBuilder(): SymbolDisplayBuilder {
@ -3283,7 +3283,7 @@ namespace ts {
function writeSymbolTypeReference(symbol: Symbol, typeArguments: Type[], pos: number, end: number, flags: TypeFormatFlags) {
// Unnamed function expressions and arrow functions have reserved names that we don't want to display
if (symbol.flags & SymbolFlags.Class || !isReservedMemberName(symbol.name)) {
if (symbol.flags & SymbolFlags.Class || !isReservedMemberName(symbol.escapedName)) {
buildSymbolDisplay(symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags);
}
if (pos < end) {
@ -3534,7 +3534,7 @@ namespace ts {
continue;
}
if (getDeclarationModifierFlagsFromSymbol(p) & (ModifierFlags.Private | ModifierFlags.Protected)) {
writer.reportPrivateInBaseOfClassExpression(unescapeLeadingUnderscores(p.name));
writer.reportPrivateInBaseOfClassExpression(unescapeLeadingUnderscores(p.escapedName));
}
}
const t = getTypeOfSymbol(p);
@ -4082,11 +4082,11 @@ namespace ts {
names.set(getTextOfPropertyName(name), true);
}
for (const prop of getPropertiesOfType(source)) {
const inNamesToRemove = names.has(prop.name);
const inNamesToRemove = names.has(prop.escapedName);
const isPrivate = getDeclarationModifierFlagsFromSymbol(prop) & (ModifierFlags.Private | ModifierFlags.Protected);
const isSetOnlyAccessor = prop.flags & SymbolFlags.SetAccessor && !(prop.flags & SymbolFlags.GetAccessor);
if (!inNamesToRemove && !isPrivate && !isClassMethod(prop) && !isSetOnlyAccessor) {
members.set(prop.name, prop);
members.set(prop.escapedName, prop);
}
}
const stringIndexInfo = getIndexInfoOfType(source, IndexKind.String);
@ -4273,7 +4273,7 @@ namespace ts {
}
// Use contextual parameter type if one is available
let type: Type;
if (declaration.symbol.name === "this") {
if (declaration.symbol.escapedName === "this") {
type = getContextualThisParameterType(func);
}
else {
@ -4393,7 +4393,7 @@ namespace ts {
const symbol = createSymbol(flags, text);
symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors);
symbol.bindingElement = e;
members.set(symbol.name, symbol);
members.set(symbol.escapedName, symbol);
});
const result = createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, undefined);
if (includePatternInType) {
@ -5323,15 +5323,15 @@ namespace ts {
function createInstantiatedSymbolTable(symbols: Symbol[], mapper: TypeMapper, mappingThisOnly: boolean): SymbolTable {
const result = createSymbolTable();
for (const symbol of symbols) {
result.set(symbol.name, mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper));
result.set(symbol.escapedName, mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper));
}
return result;
}
function addInheritedMembers(symbols: SymbolTable, baseSymbols: Symbol[]) {
for (const s of baseSymbols) {
if (!symbols.has(s.name)) {
symbols.set(s.name, s);
if (!symbols.has(s.escapedName)) {
symbols.set(s.escapedName, s);
}
}
}
@ -5833,10 +5833,10 @@ namespace ts {
const members = createSymbolTable();
for (const current of type.types) {
for (const prop of getPropertiesOfType(current)) {
if (!members.has(prop.name)) {
const combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.name);
if (!members.has(prop.escapedName)) {
const combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName);
if (combinedProp) {
members.set(prop.name, combinedProp);
members.set(prop.escapedName, combinedProp);
}
}
}
@ -5866,9 +5866,9 @@ namespace ts {
continue;
}
for (const { name } of getPropertiesOfType(memberType)) {
if (!props.has(name)) {
props.set(name, createUnionOrIntersectionProperty(type as UnionType, name));
for (const { escapedName } of getPropertiesOfType(memberType)) {
if (!props.has(escapedName)) {
props.set(escapedName, createUnionOrIntersectionProperty(type as UnionType, escapedName));
}
}
}
@ -6176,7 +6176,7 @@ namespace ts {
if (isObjectLiteralType(type)) {
const propTypes: Type[] = [];
for (const prop of getPropertiesOfType(type)) {
if (kind === IndexKind.String || isNumericLiteralName(prop.name)) {
if (kind === IndexKind.String || isNumericLiteralName(prop.escapedName)) {
propTypes.push(getTypeOfSymbol(prop));
}
}
@ -6353,10 +6353,10 @@ namespace ts {
let paramSymbol = param.symbol;
// Include parameter symbol instead of property symbol in the signature
if (paramSymbol && !!(paramSymbol.flags & SymbolFlags.Property) && !isBindingPattern(param.name)) {
const resolvedSymbol = resolveName(param, paramSymbol.name, SymbolFlags.Value, undefined, undefined);
const resolvedSymbol = resolveName(param, paramSymbol.escapedName, SymbolFlags.Value, undefined, undefined);
paramSymbol = resolvedSymbol;
}
if (i === 0 && paramSymbol.name === "this") {
if (i === 0 && paramSymbol.escapedName === "this") {
hasThisParameter = true;
thisParameter = param.symbol;
}
@ -6988,11 +6988,11 @@ namespace ts {
}
const type = getDeclaredTypeOfSymbol(symbol);
if (!(type.flags & TypeFlags.Object)) {
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, unescapeLeadingUnderscores(symbol.name));
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, unescapeLeadingUnderscores(symbol.escapedName));
return arity ? emptyGenericType : emptyObjectType;
}
if (length((<InterfaceType>type).typeParameters) !== arity) {
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_have_1_type_parameter_s, unescapeLeadingUnderscores(symbol.name), arity);
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_have_1_type_parameter_s, unescapeLeadingUnderscores(symbol.escapedName), arity);
return arity ? emptyGenericType : emptyObjectType;
}
return <ObjectType>type;
@ -7476,9 +7476,9 @@ namespace ts {
}
function getLiteralTypeFromPropertyName(prop: Symbol) {
return getDeclarationModifierFlagsFromSymbol(prop) & ModifierFlags.NonPublicAccessibilityModifier || startsWith(prop.name as string, "__@") ?
return getDeclarationModifierFlagsFromSymbol(prop) & ModifierFlags.NonPublicAccessibilityModifier || startsWith(prop.escapedName as string, "__@") ?
neverType :
getLiteralType(unescapeLeadingUnderscores(prop.name));
getLiteralType(unescapeLeadingUnderscores(prop.escapedName));
}
function getLiteralTypeFromPropertyNames(type: Type) {
@ -7723,34 +7723,34 @@ namespace ts {
// we approximate own properties as non-methods plus methods that are inside the object literal
const isSetterWithoutGetter = rightProp.flags & SymbolFlags.SetAccessor && !(rightProp.flags & SymbolFlags.GetAccessor);
if (getDeclarationModifierFlagsFromSymbol(rightProp) & (ModifierFlags.Private | ModifierFlags.Protected)) {
skippedPrivateMembers.set(rightProp.name, true);
skippedPrivateMembers.set(rightProp.escapedName, true);
}
else if (!isClassMethod(rightProp) && !isSetterWithoutGetter) {
members.set(rightProp.name, getNonReadonlySymbol(rightProp));
members.set(rightProp.escapedName, getNonReadonlySymbol(rightProp));
}
}
for (const leftProp of getPropertiesOfType(left)) {
if (leftProp.flags & SymbolFlags.SetAccessor && !(leftProp.flags & SymbolFlags.GetAccessor)
|| skippedPrivateMembers.has(leftProp.name)
|| skippedPrivateMembers.has(leftProp.escapedName)
|| isClassMethod(leftProp)) {
continue;
}
if (members.has(leftProp.name)) {
const rightProp = members.get(leftProp.name);
if (members.has(leftProp.escapedName)) {
const rightProp = members.get(leftProp.escapedName);
const rightType = getTypeOfSymbol(rightProp);
if (rightProp.flags & SymbolFlags.Optional) {
const declarations: Declaration[] = concatenate(leftProp.declarations, rightProp.declarations);
const flags = SymbolFlags.Property | (leftProp.flags & SymbolFlags.Optional);
const result = createSymbol(flags, leftProp.name);
const result = createSymbol(flags, leftProp.escapedName);
result.type = getUnionType([getTypeOfSymbol(leftProp), getTypeWithFacts(rightType, TypeFacts.NEUndefined)]);
result.leftSpread = leftProp;
result.rightSpread = rightProp;
result.declarations = declarations;
members.set(leftProp.name, result);
members.set(leftProp.escapedName, result);
}
}
else {
members.set(leftProp.name, getNonReadonlySymbol(leftProp));
members.set(leftProp.escapedName, getNonReadonlySymbol(leftProp));
}
}
return createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);
@ -7761,7 +7761,7 @@ namespace ts {
return prop;
}
const flags = SymbolFlags.Property | (prop.flags & SymbolFlags.Optional);
const result = createSymbol(flags, prop.name);
const result = createSymbol(flags, prop.escapedName);
result.type = getTypeOfSymbol(prop);
result.declarations = prop.declarations;
result.syntheticOrigin = prop;
@ -8078,7 +8078,7 @@ namespace ts {
}
// Keep the flags from the symbol we're instantiating. Mark that is instantiated, and
// also transient so that we can just store data on it directly.
const result = createSymbol(symbol.flags, symbol.name);
const result = createSymbol(symbol.flags, symbol.escapedName);
result.checkFlags = CheckFlags.Instantiated;
result.declarations = symbol.declarations;
result.parent = symbol.parent;
@ -8495,8 +8495,8 @@ namespace ts {
if (!related) {
if (reportErrors) {
errorReporter(Diagnostics.Types_of_parameters_0_and_1_are_incompatible,
unescapeLeadingUnderscores(sourceParams[i < sourceMax ? i : sourceMax].name),
unescapeLeadingUnderscores(targetParams[i < targetMax ? i : targetMax].name));
unescapeLeadingUnderscores(sourceParams[i < sourceMax ? i : sourceMax].escapedName),
unescapeLeadingUnderscores(targetParams[i < targetMax ? i : targetMax].escapedName));
}
return Ternary.False;
}
@ -8635,17 +8635,17 @@ namespace ts {
if (relation !== undefined) {
return relation;
}
if (sourceSymbol.name !== targetSymbol.name || !(sourceSymbol.flags & SymbolFlags.RegularEnum) || !(targetSymbol.flags & SymbolFlags.RegularEnum)) {
if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & SymbolFlags.RegularEnum) || !(targetSymbol.flags & SymbolFlags.RegularEnum)) {
enumRelation.set(id, false);
return false;
}
const targetEnumType = getTypeOfSymbol(targetSymbol);
for (const property of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
if (property.flags & SymbolFlags.EnumMember) {
const targetProperty = getPropertyOfType(targetEnumType, property.name);
const targetProperty = getPropertyOfType(targetEnumType, property.escapedName);
if (!targetProperty || !(targetProperty.flags & SymbolFlags.EnumMember)) {
if (errorReporter) {
errorReporter(Diagnostics.Property_0_is_missing_in_type_1, unescapeLeadingUnderscores(property.name),
errorReporter(Diagnostics.Property_0_is_missing_in_type_1, unescapeLeadingUnderscores(property.escapedName),
typeToString(getDeclaredTypeOfSymbol(targetSymbol), /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType));
}
enumRelation.set(id, false);
@ -8951,7 +8951,7 @@ namespace ts {
return false;
}
for (const prop of getPropertiesOfObjectType(source)) {
if (!isKnownProperty(target, prop.name, isComparingJsxAttributes)) {
if (!isKnownProperty(target, prop.escapedName, isComparingJsxAttributes)) {
if (reportErrors) {
// We know *exactly* where things went wrong when comparing the types.
// Use this property as the error node as this will be more helpful in
@ -9014,10 +9014,10 @@ namespace ts {
const sourceProperties = getPropertiesOfObjectType(source);
if (sourceProperties) {
for (const sourceProperty of sourceProperties) {
if (isDiscriminantProperty(target, sourceProperty.name)) {
if (isDiscriminantProperty(target, sourceProperty.escapedName)) {
const sourceType = getTypeOfSymbol(sourceProperty);
for (const type of target.types) {
const targetType = getTypeOfPropertyOfType(type, sourceProperty.name);
const targetType = getTypeOfPropertyOfType(type, sourceProperty.escapedName);
if (targetType && isRelatedTo(sourceType, targetType)) {
return type;
}
@ -9332,7 +9332,7 @@ namespace ts {
const properties = getPropertiesOfObjectType(target);
const requireOptionalProperties = relation === subtypeRelation && !(getObjectFlags(source) & ObjectFlags.ObjectLiteral);
for (const targetProp of properties) {
const sourceProp = getPropertyOfType(source, targetProp.name);
const sourceProp = getPropertyOfType(source, targetProp.escapedName);
if (sourceProp !== targetProp) {
if (!sourceProp) {
if (!(targetProp.flags & SymbolFlags.Optional) || requireOptionalProperties) {
@ -9432,7 +9432,7 @@ namespace ts {
function hasCommonProperties(source: Type, target: Type) {
const isComparingJsxAttributes = !!(source.flags & TypeFlags.JsxAttributes);
for (const prop of getPropertiesOfType(source)) {
if (isKnownProperty(target, prop.name, isComparingJsxAttributes)) {
if (isKnownProperty(target, prop.escapedName, isComparingJsxAttributes)) {
return true;
}
}
@ -9450,7 +9450,7 @@ namespace ts {
}
let result = Ternary.True;
for (const sourceProp of sourceProperties) {
const targetProp = getPropertyOfObjectType(target, sourceProp.name);
const targetProp = getPropertyOfObjectType(target, sourceProp.escapedName);
if (!targetProp) {
return Ternary.False;
}
@ -9567,7 +9567,7 @@ namespace ts {
function eachPropertyRelatedTo(source: Type, target: Type, kind: IndexKind, reportErrors: boolean): Ternary {
let result = Ternary.True;
for (const prop of getPropertiesOfObjectType(source)) {
if (kind === IndexKind.String || isNumericLiteralName(prop.name)) {
if (kind === IndexKind.String || isNumericLiteralName(prop.escapedName)) {
const related = isRelatedTo(getTypeOfSymbol(prop), target, reportErrors);
if (!related) {
if (reportErrors) {
@ -9670,7 +9670,7 @@ namespace ts {
function forEachProperty<T>(prop: Symbol, callback: (p: Symbol) => T): T {
if (getCheckFlags(prop) & CheckFlags.Synthetic) {
for (const t of (<TransientSymbol>prop).containingType.types) {
const p = getPropertyOfType(t, prop.name);
const p = getPropertyOfType(t, prop.escapedName);
const result = p && forEachProperty(p, callback);
if (result) {
return result;
@ -10008,7 +10008,7 @@ namespace ts {
}
function createSymbolWithType(source: Symbol, type: Type) {
const symbol = createSymbol(source.flags, source.name);
const symbol = createSymbol(source.flags, source.escapedName);
symbol.declarations = source.declarations;
symbol.parent = source.parent;
symbol.type = type;
@ -10024,7 +10024,7 @@ namespace ts {
for (const property of getPropertiesOfObjectType(type)) {
const original = getTypeOfSymbol(property);
const updated = f(original);
members.set(property.name, updated === original ? property : createSymbolWithType(property, updated));
members.set(property.escapedName, updated === original ? property : createSymbolWithType(property, updated));
}
return members;
}
@ -10068,7 +10068,7 @@ namespace ts {
for (const prop of getPropertiesOfObjectType(type)) {
// Since get accessors already widen their return value there is no need to
// widen accessor based properties here.
members.set(prop.name, prop.flags & SymbolFlags.Property ? getWidenedProperty(prop) : prop);
members.set(prop.escapedName, prop.flags & SymbolFlags.Property ? getWidenedProperty(prop) : prop);
}
const stringIndexInfo = getIndexInfoOfType(type, IndexKind.String);
const numberIndexInfo = getIndexInfoOfType(type, IndexKind.Number);
@ -10131,7 +10131,7 @@ namespace ts {
const t = getTypeOfSymbol(p);
if (t.flags & TypeFlags.ContainsWideningType) {
if (!reportWideningErrorsInType(t)) {
error(p.valueDeclaration, Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, unescapeLeadingUnderscores(p.name), typeToString(getWidenedType(t)));
error(p.valueDeclaration, Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, unescapeLeadingUnderscores(p.escapedName), typeToString(getWidenedType(t)));
}
errorReported = true;
}
@ -10292,11 +10292,11 @@ namespace ts {
if (!inferredPropType) {
return undefined;
}
const inferredProp = createSymbol(SymbolFlags.Property | prop.flags & optionalMask, prop.name);
const inferredProp = createSymbol(SymbolFlags.Property | prop.flags & optionalMask, prop.escapedName);
inferredProp.checkFlags = readonlyMask && isReadonlySymbol(prop) ? CheckFlags.Readonly : 0;
inferredProp.declarations = prop.declarations;
inferredProp.type = inferredPropType;
members.set(prop.name, inferredProp);
members.set(prop.escapedName, inferredProp);
}
if (indexInfo) {
const inferredIndexType = inferTargetType(indexInfo.type);
@ -10516,7 +10516,7 @@ namespace ts {
function inferFromProperties(source: Type, target: Type) {
const properties = getPropertiesOfObjectType(target);
for (const targetProp of properties) {
const sourceProp = getPropertyOfObjectType(source, targetProp.name);
const sourceProp = getPropertyOfObjectType(source, targetProp.escapedName);
if (sourceProp) {
inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
}
@ -12949,7 +12949,7 @@ namespace ts {
// For a (non-symbol) computed property, there is no reason to look up the name
// in the type. It will just be "__computed", which does not appear in any
// SymbolTable.
const symbolName = getSymbolOfNode(element).name;
const symbolName = getSymbolOfNode(element).escapedName;
const propertyType = getTypeOfPropertyOfContextualType(type, symbolName);
if (propertyType) {
return propertyType;
@ -13422,7 +13422,7 @@ namespace ts {
}
typeFlags |= type.flags;
const prop = createSymbol(SymbolFlags.Property | member.flags, member.name);
const prop = createSymbol(SymbolFlags.Property | member.flags, member.escapedName);
if (inDestructuringPattern) {
// If object literal is an assignment pattern and if the assignment pattern specifies a default value
// for the property, make the property optional.
@ -13439,7 +13439,7 @@ namespace ts {
else if (contextualTypeHasPattern && !(getObjectFlags(contextualType) & ObjectFlags.ObjectLiteralPatternWithComputedProperties)) {
// If object literal is contextually typed by the implied type of a binding pattern, and if the
// binding pattern specifies a default value for the property, make the property optional.
const impliedProp = getPropertyOfType(contextualType, member.name);
const impliedProp = getPropertyOfType(contextualType, member.escapedName);
if (impliedProp) {
prop.flags |= impliedProp.flags & SymbolFlags.Optional;
}
@ -13499,7 +13499,7 @@ namespace ts {
}
}
else {
propertiesTable.set(member.name, member);
propertiesTable.set(member.escapedName, member);
}
propertiesArray.push(member);
}
@ -13508,12 +13508,12 @@ namespace ts {
// type with those properties for which the binding pattern specifies a default value.
if (contextualTypeHasPattern) {
for (const prop of getPropertiesOfType(contextualType)) {
if (!propertiesTable.get(prop.name)) {
if (!propertiesTable.get(prop.escapedName)) {
if (!(prop.flags & SymbolFlags.Optional)) {
error(prop.valueDeclaration || (<TransientSymbol>prop).bindingElement,
Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value);
}
propertiesTable.set(prop.name, prop);
propertiesTable.set(prop.escapedName, prop);
propertiesArray.push(prop);
}
}
@ -13631,7 +13631,7 @@ namespace ts {
checkExpression(attributeDecl.initializer, checkMode) :
trueType; // <Elem attr /> is sugar for <Elem attr={true} />
const attributeSymbol = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.name);
const attributeSymbol = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.escapedName);
attributeSymbol.declarations = member.declarations;
attributeSymbol.parent = member.parent;
if (member.valueDeclaration) {
@ -13639,7 +13639,7 @@ namespace ts {
}
attributeSymbol.type = exprType;
attributeSymbol.target = member;
attributesTable.set(attributeSymbol.name, attributeSymbol);
attributesTable.set(attributeSymbol.escapedName, attributeSymbol);
attributesArray.push(attributeSymbol);
if (attributeDecl.name.escapedText === jsxChildrenPropertyName) {
explicitlySpecifyChildrenAttribute = true;
@ -13676,7 +13676,7 @@ namespace ts {
attributesTable = createSymbolTable();
for (const attr of attributesArray) {
if (!filter || filter(attr)) {
attributesTable.set(attr.name, attr);
attributesTable.set(attr.escapedName, attr);
}
}
}
@ -13856,7 +13856,7 @@ namespace ts {
// Element Attributes has one property, so the element attributes type will be the type of the corresponding
// property of the class instance type
else if (propertiesOfJsxElementAttribPropInterface.length === 1) {
return propertiesOfJsxElementAttribPropInterface[0].name;
return propertiesOfJsxElementAttribPropInterface[0].escapedName;
}
else if (propertiesOfJsxElementAttribPropInterface.length > 1) {
// More than one property on ElementAttributesProperty is an error
@ -14324,7 +14324,7 @@ namespace ts {
// attr1 and attr2 are treated as JSXAttributes attached in the JsxOpeningLikeElement as "attributes".
const sourceAttributesType = createJsxAttributesTypeFromAttributesProperty(openingLikeElement,
attribute => {
return isUnhyphenatedJsxName(attribute.name) || !!(getPropertyOfType(targetAttributesType, attribute.name));
return isUnhyphenatedJsxName(attribute.escapedName) || !!(getPropertyOfType(targetAttributesType, attribute.escapedName));
});
// If the targetAttributesType is an emptyObjectType, indicating that there is no property named 'props' on this instance type.
@ -14585,7 +14585,7 @@ namespace ts {
function getSuggestionForNonexistentProperty(node: Identifier, containingType: Type): __String | undefined {
const suggestion = getSpellingSuggestionForName(unescapeLeadingUnderscores(node.escapedText), getPropertiesOfType(containingType), SymbolFlags.Value);
return suggestion && suggestion.name;
return suggestion && suggestion.escapedName;
}
function getSuggestionForNonexistentSymbol(location: Node, name: __String, meaning: SymbolFlags): __String {
@ -14600,7 +14600,7 @@ namespace ts {
return getSpellingSuggestionForName(unescapeLeadingUnderscores(name), arrayFrom(symbols.values()), meaning);
});
if (result) {
return result.name;
return result.escapedName;
}
}
@ -14631,7 +14631,7 @@ namespace ts {
}
name = name.toLowerCase();
for (const candidate of symbols) {
let candidateName = unescapeLeadingUnderscores(candidate.name);
let candidateName = unescapeLeadingUnderscores(candidate.escapedName);
if (candidate.flags & meaning &&
candidateName &&
Math.abs(candidateName.length - name.length) < maximumLengthDifference) {
@ -15200,7 +15200,7 @@ namespace ts {
const attributesType = checkExpressionWithContextualType(node.attributes, paramType, /*contextualMapper*/ undefined);
const argProperties = getPropertiesOfType(attributesType);
for (const arg of argProperties) {
if (!getPropertyOfType(paramType, arg.name) && isUnhyphenatedJsxName(arg.name)) {
if (!getPropertyOfType(paramType, arg.escapedName) && isUnhyphenatedJsxName(arg.escapedName)) {
return false;
}
}
@ -19625,11 +19625,11 @@ namespace ts {
!isParameterPropertyDeclaration(parameter) &&
!parameterIsThisKeyword(parameter) &&
!parameterNameStartsWithUnderscore(name)) {
error(name, Diagnostics._0_is_declared_but_never_used, unescapeLeadingUnderscores(local.name));
error(name, Diagnostics._0_is_declared_but_never_used, unescapeLeadingUnderscores(local.escapedName));
}
}
else if (compilerOptions.noUnusedLocals) {
forEach(local.declarations, d => errorUnusedLocal(getNameOfDeclaration(d) || d, unescapeLeadingUnderscores(local.name)));
forEach(local.declarations, d => errorUnusedLocal(getNameOfDeclaration(d) || d, unescapeLeadingUnderscores(local.escapedName)));
}
}
});
@ -19671,13 +19671,13 @@ namespace ts {
for (const member of node.members) {
if (member.kind === SyntaxKind.MethodDeclaration || member.kind === SyntaxKind.PropertyDeclaration) {
if (!member.symbol.isReferenced && getModifierFlags(member) & ModifierFlags.Private) {
error(member.name, Diagnostics._0_is_declared_but_never_used, unescapeLeadingUnderscores(member.symbol.name));
error(member.name, Diagnostics._0_is_declared_but_never_used, unescapeLeadingUnderscores(member.symbol.escapedName));
}
}
else if (member.kind === SyntaxKind.Constructor) {
for (const parameter of (<ConstructorDeclaration>member).parameters) {
if (!parameter.symbol.isReferenced && getModifierFlags(parameter) & ModifierFlags.Private) {
error(parameter.name, Diagnostics.Property_0_is_declared_but_never_used, unescapeLeadingUnderscores(parameter.symbol.name));
error(parameter.name, Diagnostics.Property_0_is_declared_but_never_used, unescapeLeadingUnderscores(parameter.symbol.escapedName));
}
}
}
@ -19698,7 +19698,7 @@ namespace ts {
}
for (const typeParameter of node.typeParameters) {
if (!getMergedSymbol(typeParameter.symbol).isReferenced) {
error(typeParameter.name, Diagnostics._0_is_declared_but_never_used, unescapeLeadingUnderscores(typeParameter.symbol.name));
error(typeParameter.name, Diagnostics._0_is_declared_but_never_used, unescapeLeadingUnderscores(typeParameter.symbol.escapedName));
}
}
}
@ -19711,7 +19711,7 @@ namespace ts {
if (!local.isReferenced && !local.exportSymbol) {
for (const declaration of local.declarations) {
if (!isAmbientModule(declaration)) {
errorUnusedLocal(getNameOfDeclaration(declaration), unescapeLeadingUnderscores(local.name));
errorUnusedLocal(getNameOfDeclaration(declaration), unescapeLeadingUnderscores(local.escapedName));
}
}
}
@ -19737,7 +19737,7 @@ namespace ts {
}
forEach(node.parameters, p => {
if (p.name && !isBindingPattern(p.name) && p.name.escapedText === argumentsSymbol.name) {
if (p.name && !isBindingPattern(p.name) && p.name.escapedText === argumentsSymbol.escapedName) {
error(p, Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters);
}
});
@ -20938,7 +20938,7 @@ namespace ts {
const propDeclaration = prop.valueDeclaration;
// index is numeric and property name is not valid numeric literal
if (indexKind === IndexKind.Number && !(propDeclaration ? isNumericName(getNameOfDeclaration(propDeclaration)) : isNumericLiteralName(prop.name))) {
if (indexKind === IndexKind.Number && !(propDeclaration ? isNumericName(getNameOfDeclaration(propDeclaration)) : isNumericLiteralName(prop.escapedName))) {
return;
}
@ -20958,7 +20958,7 @@ namespace ts {
// for interfaces property and indexer might be inherited from different bases
// check if any base class already has both property and indexer.
// check should be performed only if 'type' is the first type that brings property\indexer together
const someBaseClassHasBothPropertyAndIndexer = forEach(getBaseTypes(<InterfaceType>containingType), base => getPropertyOfObjectType(base, prop.name) && getIndexTypeOfType(base, indexKind));
const someBaseClassHasBothPropertyAndIndexer = forEach(getBaseTypes(<InterfaceType>containingType), base => getPropertyOfObjectType(base, prop.escapedName) && getIndexTypeOfType(base, indexKind));
errorNode = someBaseClassHasBothPropertyAndIndexer ? undefined : containingType.symbol.declarations[0];
}
@ -21056,7 +21056,7 @@ namespace ts {
// If the type parameter node does not have the same as the resolved type
// parameter at this position, we report an error.
if (source.name.escapedText !== target.symbol.name) {
if (source.name.escapedText !== target.symbol.escapedName) {
return false;
}
@ -21249,7 +21249,7 @@ namespace ts {
continue;
}
const derived = getTargetSymbol(getPropertyOfObjectType(type, base.name));
const derived = getTargetSymbol(getPropertyOfObjectType(type, base.escapedName));
const baseDeclarationFlags = getDeclarationModifierFlagsFromSymbol(base);
Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration.");
@ -21320,15 +21320,15 @@ namespace ts {
type InheritanceInfoMap = { prop: Symbol; containingType: Type };
const seen = createUnderscoreEscapedMap<InheritanceInfoMap>();
forEach(resolveDeclaredMembers(type).declaredProperties, p => { seen.set(p.name, { prop: p, containingType: type }); });
forEach(resolveDeclaredMembers(type).declaredProperties, p => { seen.set(p.escapedName, { prop: p, containingType: type }); });
let ok = true;
for (const base of baseTypes) {
const properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
for (const prop of properties) {
const existing = seen.get(prop.name);
const existing = seen.get(prop.escapedName);
if (!existing) {
seen.set(prop.name, { prop, containingType: base });
seen.set(prop.escapedName, { prop, containingType: base });
}
else {
const isInheritedProperty = existing.containingType !== type;
@ -22488,7 +22488,7 @@ namespace ts {
*/
function copySymbol(symbol: Symbol, meaning: SymbolFlags): void {
if (getCombinedLocalAndExportSymbolFlags(symbol) & meaning) {
const id = symbol.name;
const id = symbol.escapedName;
// We will copy all symbol regardless of its reserved name because
// symbolsToArray will check whether the key is a reserved name and
// it will not copy symbol with reserved name to the array
@ -22946,8 +22946,8 @@ namespace ts {
const propsByName = createSymbolTable(getPropertiesOfType(type));
if (getSignaturesOfType(type, SignatureKind.Call).length || getSignaturesOfType(type, SignatureKind.Construct).length) {
forEach(getPropertiesOfType(globalFunctionType), p => {
if (!propsByName.has(p.name)) {
propsByName.set(p.name, p);
if (!propsByName.has(p.escapedName)) {
propsByName.set(p.escapedName, p);
}
});
}
@ -22957,7 +22957,7 @@ namespace ts {
function getRootSymbols(symbol: Symbol): Symbol[] {
if (getCheckFlags(symbol) & CheckFlags.Synthetic) {
const symbols: Symbol[] = [];
const name = symbol.name;
const name = symbol.escapedName;
forEach(getSymbolLinks(symbol).containingType.types, t => {
const symbol = getPropertyOfType(t, name);
if (symbol) {
@ -23094,7 +23094,7 @@ namespace ts {
const container = getEnclosingBlockScopeContainer(symbol.valueDeclaration);
if (isStatementWithLocals(container)) {
const nodeLinks = getNodeLinks(symbol.valueDeclaration);
if (!!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined)) {
if (!!resolveName(container.parent, symbol.escapedName, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined)) {
// redeclaration - always should be renamed
links.isDeclarationWithCollidingName = true;
}

4
src/compiler/core.ts
View file

@ -59,7 +59,7 @@ namespace ts {
const result = createMap<Symbol>() as SymbolTable;
if (symbols) {
for (const symbol of symbols) {
result.set(symbol.name, symbol);
result.set(symbol.escapedName, symbol);
}
}
return result;
@ -2306,7 +2306,7 @@ namespace ts {
function Symbol(this: Symbol, flags: SymbolFlags, name: __String) {
this.flags = flags;
this.name = name;
this.escapedName = name;
this.declarations = undefined;
}

4
src/compiler/transformers/ts.ts
View file

@ -2644,7 +2644,7 @@ namespace ts {
* on symbol names.
*/
function recordEmittedDeclarationInScope(node: Node) {
const name = node.symbol && node.symbol.name;
const name = node.symbol && node.symbol.escapedName;
if (name) {
if (!currentScopeFirstDeclarationsOfName) {
currentScopeFirstDeclarationsOfName = createUnderscoreEscapedMap<Node>();
@ -2662,7 +2662,7 @@ namespace ts {
*/
function isFirstEmittedDeclarationInScope(node: Node) {
if (currentScopeFirstDeclarationsOfName) {
const name = node.symbol && node.symbol.name;
const name = node.symbol && node.symbol.escapedName;
if (name) {
return currentScopeFirstDeclarationsOfName.get(name) === node;
}

2
src/compiler/types.ts
View file

@ -2899,7 +2899,7 @@ namespace ts {
export interface Symbol {
flags: SymbolFlags; // Symbol flags
name: __String; // Name of symbol
escapedName: __String; // Name of symbol
declarations?: Declaration[]; // Declarations associated with this symbol
valueDeclaration?: Declaration; // First value declaration of the symbol
members?: SymbolTable; // Class, interface or literal instance members

4
src/services/codefixes/helpers.ts
View file

@ -35,7 +35,7 @@ namespace ts.codefix {
*/
export function createMissingMemberNodes(classDeclaration: ClassLikeDeclaration, possiblyMissingSymbols: Symbol[], checker: TypeChecker): Node[] {
const classMembers = classDeclaration.symbol.members;
const missingMembers = possiblyMissingSymbols.filter(symbol => !classMembers.has(symbol.name));
const missingMembers = possiblyMissingSymbols.filter(symbol => !classMembers.has(symbol.escapedName));
let newNodes: Node[] = [];
for (const symbol of missingMembers) {
@ -205,7 +205,7 @@ namespace ts.codefix {
}
}
const maxNonRestArgs = maxArgsSignature.parameters.length - (maxArgsSignature.hasRestParameter ? 1 : 0);
const maxArgsParameterSymbolNames = maxArgsSignature.parameters.map(symbol => symbol.getUnescapedName());
const maxArgsParameterSymbolNames = maxArgsSignature.parameters.map(symbol => symbol.name);
const parameters = createDummyParameters(maxNonRestArgs, maxArgsParameterSymbolNames, minArgumentCount, /*addAnyType*/ true);

4
src/services/codefixes/importFixes.ts
View file

@ -148,7 +148,7 @@ namespace ts.codefix {
else if (isJsxOpeningLikeElement(token.parent) && token.parent.tagName === token) {
// The error wasn't for the symbolAtLocation, it was for the JSX tag itself, which needs access to e.g. `React`.
symbol = checker.getAliasedSymbol(checker.resolveNameAtLocation(token, checker.getJsxNamespace(), SymbolFlags.Value));
symbolName = symbol.getUnescapedName();
symbolName = symbol.name;
}
else {
Debug.fail("Either the symbol or the JSX namespace should be a UMD global if we got here");
@ -171,7 +171,7 @@ namespace ts.codefix {
const defaultExport = checker.tryGetMemberInModuleExports("default", moduleSymbol);
if (defaultExport) {
const localSymbol = getLocalSymbolForExportDefault(defaultExport);
if (localSymbol && localSymbol.name === name && checkSymbolHasMeaning(localSymbol, currentTokenMeaning)) {
if (localSymbol && localSymbol.escapedName === name && checkSymbolHasMeaning(localSymbol, currentTokenMeaning)) {
// check if this symbol is already used
const symbolId = getUniqueSymbolId(localSymbol);
symbolIdActionMap.addActions(symbolId, getCodeActionForImport(moduleSymbol, name, /*isDefault*/ true));

16
src/services/completions.ts
View file

@ -606,7 +606,7 @@ namespace ts.Completions {
if (symbol.flags & (SymbolFlags.Module | SymbolFlags.Enum)) {
// Extract module or enum members
const exportedSymbols = typeChecker.getExportsOfModule(symbol);
const isValidValueAccess = (symbol: Symbol) => typeChecker.isValidPropertyAccess(<PropertyAccessExpression>(node.parent), symbol.getUnescapedName());
const isValidValueAccess = (symbol: Symbol) => typeChecker.isValidPropertyAccess(<PropertyAccessExpression>(node.parent), symbol.name);
const isValidTypeAccess = (symbol: Symbol) => symbolCanBeReferencedAtTypeLocation(symbol);
const isValidAccess = isRhsOfImportDeclaration ?
// Any kind is allowed when dotting off namespace in internal import equals declaration
@ -636,7 +636,7 @@ namespace ts.Completions {
function addTypeProperties(type: Type) {
// Filter private properties
for (const symbol of type.getApparentProperties()) {
if (typeChecker.isValidPropertyAccess(<PropertyAccessExpression>(node.parent), symbol.getUnescapedName())) {
if (typeChecker.isValidPropertyAccess(<PropertyAccessExpression>(node.parent), symbol.name)) {
symbols.push(symbol);
}
}
@ -1457,10 +1457,10 @@ namespace ts.Completions {
}
if (existingImportsOrExports.size === 0) {
return filter(exportsOfModule, e => e.name !== "default");
return filter(exportsOfModule, e => e.escapedName !== "default");
}
return filter(exportsOfModule, e => e.name !== "default" && !existingImportsOrExports.get(e.name));
return filter(exportsOfModule, e => e.escapedName !== "default" && !existingImportsOrExports.get(e.escapedName));
}
/**
@ -1510,7 +1510,7 @@ namespace ts.Completions {
existingMemberNames.set(existingName, true);
}
return filter(contextualMemberSymbols, m => !existingMemberNames.get(m.name));
return filter(contextualMemberSymbols, m => !existingMemberNames.get(m.escapedName));
}
/**
@ -1571,7 +1571,7 @@ namespace ts.Completions {
}
function isValidProperty(propertySymbol: Symbol, inValidModifierFlags: ModifierFlags) {
return !existingMemberNames.get(propertySymbol.name) &&
return !existingMemberNames.get(propertySymbol.escapedName) &&
propertySymbol.getDeclarations() &&
!(getDeclarationModifierFlagsFromSymbol(propertySymbol) & inValidModifierFlags);
}
@ -1596,7 +1596,7 @@ namespace ts.Completions {
}
}
return filter(symbols, a => !seenNames.get(a.name));
return filter(symbols, a => !seenNames.get(a.escapedName));
}
function isCurrentlyEditingNode(node: Node): boolean {
@ -1610,7 +1610,7 @@ namespace ts.Completions {
* @return undefined if the name is of external module
*/
function getCompletionEntryDisplayNameForSymbol(symbol: Symbol, target: ScriptTarget, performCharacterChecks: boolean): string | undefined {
const name = symbol.getUnescapedName();
const name = symbol.name;
if (!name) return undefined;
// First check of the displayName is not external module; if it is an external module, it is not valid entry

10
src/services/findAllReferences.ts
View file

@ -1417,7 +1417,7 @@ namespace ts.FindAllReferences.Core {
// Property Declaration symbol is a member of the class, so the symbol is stored in its class Declaration.symbol.members
if (symbol.valueDeclaration && symbol.valueDeclaration.kind === SyntaxKind.Parameter &&
isParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration)) {
addRange(result, checker.getSymbolsOfParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration, symbol.getUnescapedName()));
addRange(result, checker.getSymbolsOfParameterPropertyDeclaration(<ParameterDeclaration>symbol.valueDeclaration, symbol.name));
}
// If this is symbol of binding element without propertyName declaration in Object binding pattern
@ -1436,7 +1436,7 @@ namespace ts.FindAllReferences.Core {
// Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions
if (!implementations && rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getUnescapedName(), result, /*previousIterationSymbolsCache*/ createSymbolTable(), checker);
getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.name, result, /*previousIterationSymbolsCache*/ createSymbolTable(), checker);
}
}
@ -1467,7 +1467,7 @@ namespace ts.FindAllReferences.Core {
// the function will add any found symbol of the property-name, then its sub-routine will call
// getPropertySymbolsFromBaseTypes again to walk up any base types to prevent revisiting already
// visited symbol, interface "C", the sub-routine will pass the current symbol as previousIterationSymbol.
if (previousIterationSymbolsCache.has(symbol.name)) {
if (previousIterationSymbolsCache.has(symbol.escapedName)) {
return;
}
@ -1494,7 +1494,7 @@ namespace ts.FindAllReferences.Core {
}
// Visit the typeReference as well to see if it directly or indirectly use that property
previousIterationSymbolsCache.set(symbol.name, symbol);
previousIterationSymbolsCache.set(symbol.escapedName, symbol);
getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result, previousIterationSymbolsCache, checker);
}
}
@ -1554,7 +1554,7 @@ namespace ts.FindAllReferences.Core {
}
const result: Symbol[] = [];
getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getUnescapedName(), result, /*previousIterationSymbolsCache*/ createSymbolTable(), state.checker);
getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.name, result, /*previousIterationSymbolsCache*/ createSymbolTable(), state.checker);
return find(result, search.includes);
}

10
src/services/importTracker.ts
View file

@ -180,7 +180,7 @@ namespace ts.FindAllReferences {
* But re-exports will be placed in 'singleReferences' since they cannot be locally referenced.
*/
function getSearchesFromDirectImports(directImports: Importer[], exportSymbol: Symbol, exportKind: ExportKind, checker: TypeChecker, isForRename: boolean): Pick<ImportsResult, "importSearches" | "singleReferences"> {
const exportName = exportSymbol.name;
const exportName = exportSymbol.escapedName;
const importSearches: Array<[Identifier, Symbol]> = [];
const singleReferences: Identifier[] = [];
function addSearch(location: Identifier, symbol: Symbol): void {
@ -521,11 +521,11 @@ namespace ts.FindAllReferences {
// Search on the local symbol in the exporting module, not the exported symbol.
importedSymbol = skipExportSpecifierSymbol(importedSymbol, checker);
// Similarly, skip past the symbol for 'export ='
if (importedSymbol.name === "export=") {
if (importedSymbol.escapedName === "export=") {
importedSymbol = getExportEqualsLocalSymbol(importedSymbol, checker);
}
if (symbolName(importedSymbol) === symbol.name) { // If this is a rename import, do not continue searching.
if (symbolName(importedSymbol) === symbol.escapedName) { // If this is a rename import, do not continue searching.
return { kind: ImportExport.Import, symbol: importedSymbol, ...isImport };
}
}
@ -595,8 +595,8 @@ namespace ts.FindAllReferences {
}
function symbolName(symbol: Symbol): __String | undefined {
if (symbol.name !== "default") {
return symbol.getName();
if (symbol.escapedName !== "default") {
return symbol.escapedName;
}
return forEach(symbol.declarations, decl => {

2
src/services/navigateTo.ts
View file

@ -54,7 +54,7 @@ namespace ts.NavigateTo {
if (decl.kind === SyntaxKind.ImportClause || decl.kind === SyntaxKind.ImportSpecifier || decl.kind === SyntaxKind.ImportEqualsDeclaration) {
const importer = checker.getSymbolAtLocation((decl as NamedDeclaration).name);
const imported = checker.getAliasedSymbol(importer);
return importer.name !== imported.name;
return importer.escapedName !== imported.escapedName;
}
else {
return true;

2
src/services/pathCompletions.ts
View file

@ -239,7 +239,7 @@ namespace ts.Completions.PathCompletions {
const moduleNameFragment = isNestedModule ? fragment.substr(0, fragment.lastIndexOf(directorySeparator)) : undefined;
// Get modules that the type checker picked up
const ambientModules = map(typeChecker.getAmbientModules(), sym => stripQuotes(sym.getUnescapedName()));
const ambientModules = map(typeChecker.getAmbientModules(), sym => stripQuotes(sym.name));
let nonRelativeModuleNames = filter(ambientModules, moduleName => startsWith(moduleName, fragment));
// Nested modules of the form "module-name/sub" need to be adjusted to only return the string

2
src/services/refactors/convertFunctionToEs6Class.ts
View file

@ -163,7 +163,7 @@ namespace ts.refactor {
deleteNode(nodeToDelete);
if (!assignmentBinaryExpression.right) {
return createProperty([], modifiers, symbol.getUnescapedName(), /*questionToken*/ undefined,
return createProperty([], modifiers, symbol.name, /*questionToken*/ undefined,
/*type*/ undefined, /*initializer*/ undefined);
}

16
src/services/services.ts
View file

@ -304,7 +304,7 @@ namespace ts {
class SymbolObject implements Symbol {
flags: SymbolFlags;
name: __String;
escapedName: __String;
declarations?: Declaration[];
// Undefined is used to indicate the value has not been computed. If, after computing, the
@ -317,19 +317,23 @@ namespace ts {
constructor(flags: SymbolFlags, name: __String) {
this.flags = flags;
this.name = name;
this.escapedName = name;
}
getFlags(): SymbolFlags {
return this.flags;
}
getName(): __String {
return this.name;
get name(): string {
return unescapeLeadingUnderscores(this.escapedName);
}
getUnescapedName(): string {
return unescapeLeadingUnderscores(this.name);
getEscapedName(): __String {
return this.escapedName;
}
getName(): string {
return this.name;
}
getDeclarations(): Declaration[] | undefined {

4
src/services/signatureHelp.ts
View file

@ -414,7 +414,7 @@ namespace ts.SignatureHelp {
typeChecker.getSymbolDisplayBuilder().buildParameterDisplay(parameter, writer, invocation));
return {
name: parameter.getUnescapedName(),
name: parameter.name,
documentation: parameter.getDocumentationComment(),
displayParts,
isOptional: typeChecker.isOptionalParameter(<ParameterDeclaration>parameter.valueDeclaration)
@ -426,7 +426,7 @@ namespace ts.SignatureHelp {
typeChecker.getSymbolDisplayBuilder().buildTypeParameterDisplay(typeParameter, writer, invocation));
return {
name: typeParameter.symbol.getUnescapedName(),
name: typeParameter.symbol.name,
documentation: emptyArray,
displayParts,
isOptional: false

5
src/services/types.ts
View file

@ -27,9 +27,10 @@ namespace ts {
}
export interface Symbol {
readonly name: string;
getFlags(): SymbolFlags;
getName(): __String;
getUnescapedName(): string;
getEscapedName(): __String;
getName(): string;
getDeclarations(): Declaration[] | undefined;
getDocumentationComment(): SymbolDisplayPart[];
getJsDocTags(): JSDocTagInfo[];

2
src/services/utilities.ts
View file

@ -1090,7 +1090,7 @@ namespace ts {
/** True if the symbol is for an external module, as opposed to a namespace. */
export function isExternalModuleSymbol(moduleSymbol: Symbol): boolean {
Debug.assert(!!(moduleSymbol.flags & SymbolFlags.Module));
return moduleSymbol.getUnescapedName().charCodeAt(0) === CharacterCodes.doubleQuote;
return moduleSymbol.name.charCodeAt(0) === CharacterCodes.doubleQuote;
}
/** Returns `true` the first time it encounters a node and `false` afterwards. */