microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-05 08:11:30 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Make the distinction between PropertyAccessExpressions and QualifiedNames more explicit.

Browse Source
This commit is contained in:
Cyrus Najmabadi 2014-11-29 17:06:55 -08:00
parent 38a5ba05aa
commit da08a6ea1a
2 changed files with 32 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
src/compiler/checker.ts
View File

@ -5156,15 +5156,15 @@ module ts {
}
}
function checkPropertyAccess(node: PropertyAccessExpression) {
return checkPropertyAccessCore(node, node.left, node.right);
function checkPropertyAccessExpression(node: PropertyAccessExpression) {
return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right);
}
function checkQualifiedName(node: QualifiedName) {
return checkPropertyAccessCore(node, node.left, node.right);
return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right);
}
function checkPropertyAccessCore(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, right: Identifier) {
function checkPropertyAccessExpressionOrQualifiedName(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, right: Identifier) {
var type = checkExpression(left);
if (type === unknownType) return type;
if (type !== anyType) {
@ -6575,7 +6575,7 @@ module ts {
case SyntaxKind.ObjectLiteralExpression:
return checkObjectLiteral(<ObjectLiteralExpression>node, contextualMapper);
case SyntaxKind.PropertyAccessExpression:
return checkPropertyAccess(<PropertyAccessExpression>node);
return checkPropertyAccessExpression(<PropertyAccessExpression>node);
case SyntaxKind.ElementAccessExpression:
return checkIndexedAccess(<ElementAccessExpression>node);
case SyntaxKind.CallExpression:
@ -8817,27 +8817,29 @@ module ts {
}
function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
return (node.parent.kind === SyntaxKind.QualifiedName || node.parent.kind === SyntaxKind.PropertyAccessExpression) &&
(<QualifiedName>node.parent).right === node;
return (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) ||
(node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).right === node);
}
function getSymbolOfEntityName(entityName: EntityName): Symbol {
function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol {
if (isDeclarationOrFunctionExpressionOrCatchVariableName(entityName)) {
return getSymbolOfNode(entityName.parent);
}
if (entityName.parent.kind === SyntaxKind.ExportAssignment) {
return resolveEntityName(/*location*/ entityName.parent.parent, entityName,
return resolveEntityName(/*location*/ entityName.parent.parent, <Identifier>entityName,
/*all meanings*/ SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Import);
}
if (isInRightSideOfImportOrExportAssignment(entityName)) {
// Since we already checked for ExportAssignment, this really could only be an Import
return getSymbolOfPartOfRightHandSideOfImport(entityName);
if (entityName.kind !== SyntaxKind.PropertyAccessExpression) {
if (isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
// Since we already checked for ExportAssignment, this really could only be an Import
return getSymbolOfPartOfRightHandSideOfImport(<EntityName>entityName);
}
}
if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
entityName = <QualifiedName>entityName.parent;
entityName = <QualifiedName | PropertyAccessExpression>entityName.parent;
}
if (isExpression(entityName)) {
@ -8845,9 +8847,16 @@ module ts {
// Include Import in the meaning, this ensures that we do not follow aliases to where they point and instead
// return the alias symbol.
var meaning: SymbolFlags = SymbolFlags.Value | SymbolFlags.Import;
return resolveEntityName(entityName, entityName, meaning);
return resolveEntityName(entityName, <Identifier>entityName, meaning);
}
else if (entityName.kind === SyntaxKind.QualifiedName || entityName.kind === SyntaxKind.PropertyAccessExpression) {
else if (entityName.kind === SyntaxKind.PropertyAccessExpression) {
var symbol = getNodeLinks(entityName).resolvedSymbol;
if (!symbol) {
checkPropertyAccessExpression(<PropertyAccessExpression>entityName);
}
return getNodeLinks(entityName).resolvedSymbol;
}
else if (entityName.kind === SyntaxKind.QualifiedName) {
var symbol = getNodeLinks(entityName).resolvedSymbol;
if (!symbol) {
checkQualifiedName(<QualifiedName>entityName);
@ -8859,12 +8868,12 @@ module ts {
return;
}
}
else if (isTypeReferenceIdentifier(entityName)) {
else if (isTypeReferenceIdentifier(<EntityName>entityName)) {
var meaning = entityName.parent.kind === SyntaxKind.TypeReference ? SymbolFlags.Type : SymbolFlags.Namespace;
// Include Import in the meaning, this ensures that we do not follow aliases to where they point and instead
// return the alias symbol.
meaning |= SymbolFlags.Import;
return resolveEntityName(entityName, entityName, meaning);
return resolveEntityName(entityName, <EntityName>entityName, meaning);
}
// Do we want to return undefined here?
@ -8884,7 +8893,7 @@ module ts {
if (node.kind === SyntaxKind.Identifier && isInRightSideOfImportOrExportAssignment(<Identifier>node)) {
return node.parent.kind === SyntaxKind.ExportAssignment
? getSymbolOfEntityName(<Identifier>node)
? getSymbolOfEntityNameOrPropertyAccessExpression(<Identifier>node)
: getSymbolOfPartOfRightHandSideOfImport(<Identifier>node);
}
@ -8892,7 +8901,7 @@ module ts {
case SyntaxKind.Identifier:
case SyntaxKind.PropertyAccessExpression:
case SyntaxKind.QualifiedName:
return getSymbolOfEntityName(<Identifier>node);
return getSymbolOfEntityNameOrPropertyAccessExpression(<EntityName | PropertyAccessExpression>node);
case SyntaxKind.ThisKeyword:
case SyntaxKind.SuperKeyword:

5
src/compiler/parser.ts
View File

@ -537,7 +537,10 @@ module ts {
case SyntaxKind.OmittedExpression:
return true;
case SyntaxKind.QualifiedName:
while (node.parent.kind === SyntaxKind.QualifiedName) node = node.parent;
while (node.parent.kind === SyntaxKind.QualifiedName) {
node = node.parent;
}
return node.parent.kind === SyntaxKind.TypeQuery;
case SyntaxKind.Identifier:
if (node.parent.kind === SyntaxKind.TypeQuery) {