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

Use isPartOfExpression in extractMethod, not isExpression (#18047)

Browse Source 
* Use isPartOfExpression in extractMethod, not isExpression

* Add whitespace
This commit is contained in:
Andy
2017-08-25 15:15:16 -07:00
committed by GitHub
parent 4d05bfdf4a
commit e73b10a304
2 changed files with 25 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
src/compiler/utilities.ts
View File

@@ -4953,7 +4953,11 @@ namespace ts {
/* @internal */
export function isLeftHandSideExpression(node: Node): node is LeftHandSideExpression {
switch (node.kind) {
return isLeftHandSideExpressionKind(skipPartiallyEmittedExpressions(node).kind);
}
function isLeftHandSideExpressionKind(kind: SyntaxKind): boolean {
switch (kind) {
case SyntaxKind.PropertyAccessExpression:
case SyntaxKind.ElementAccessExpression:
case SyntaxKind.NewExpression:
@@ -4979,11 +4983,8 @@ namespace ts {
case SyntaxKind.SuperKeyword:
case SyntaxKind.NonNullExpression:
case SyntaxKind.MetaProperty:
case SyntaxKind.ImportKeyword: // technically this is only an Expression if it's in a CallExpression
return true;
case SyntaxKind.PartiallyEmittedExpression:
return isLeftHandSideExpression((node as PartiallyEmittedExpression).expression);
case SyntaxKind.ImportKeyword:
return node.parent.kind === SyntaxKind.CallExpression;
default:
return false;
}
@@ -4991,7 +4992,11 @@ namespace ts {
/* @internal */
export function isUnaryExpression(node: Node): node is UnaryExpression {
switch (node.kind) {
return isUnaryExpressionKind(skipPartiallyEmittedExpressions(node).kind);
}
function isUnaryExpressionKind(kind: SyntaxKind): boolean {
switch (kind) {
case SyntaxKind.PrefixUnaryExpression:
case SyntaxKind.PostfixUnaryExpression:
case SyntaxKind.DeleteExpression:
@@ -5000,10 +5005,8 @@ namespace ts {
case SyntaxKind.AwaitExpression:
case SyntaxKind.TypeAssertionExpression:
return true;
case SyntaxKind.PartiallyEmittedExpression:
return isUnaryExpression((node as PartiallyEmittedExpression).expression);
default:
return isLeftHandSideExpression(node);
return isLeftHandSideExpressionKind(kind);
}
}
@@ -5021,8 +5024,16 @@ namespace ts {
}
/* @internal */
/**
* Determines whether a node is an expression based only on its kind.
* Use `isPartOfExpression` if not in transforms.
*/
export function isExpression(node: Node): node is Expression {
switch (node.kind) {
return isExpressionKind(skipPartiallyEmittedExpressions(node).kind);
}
function isExpressionKind(kind: SyntaxKind): boolean {
switch (kind) {
case SyntaxKind.ConditionalExpression:
case SyntaxKind.YieldExpression:
case SyntaxKind.ArrowFunction:
@@ -5034,7 +5045,7 @@ namespace ts {
case SyntaxKind.PartiallyEmittedExpression:
return true;
default:
return isUnaryExpression(node);
return isUnaryExpressionKind(kind);
}
}

6
src/services/refactors/extractMethod.ts
View File

@@ -278,7 +278,7 @@ namespace ts.refactor.extractMethod {
Continue = 1 << 1,
Return = 1 << 2
}
if (!isStatement(nodeToCheck) && !(isExpression(nodeToCheck) && isExtractableExpression(nodeToCheck))) {
if (!isStatement(nodeToCheck) && !(isPartOfExpression(nodeToCheck) && isExtractableExpression(nodeToCheck))) {
return [createDiagnosticForNode(nodeToCheck, Messages.StatementOrExpressionExpected)];
}
@@ -452,12 +452,12 @@ namespace ts.refactor.extractMethod {
if (isStatement(node)) {
return [node];
}
else if (isExpression(node)) {
else if (isPartOfExpression(node)) {
// If our selection is the expression in an ExpressionStatement, expand
// the selection to include the enclosing Statement (this stops us
// from trying to care about the return value of the extracted function
// and eliminates double semicolon insertion in certain scenarios)
return isExpressionStatement(node.parent) ? [node.parent] : node;
return isExpressionStatement(node.parent) ? [node.parent] : node as Expression;
}
return undefined;
}