Rename "isPartOfExpression" (microsoft#18469)

Andy · web-flow · commit f4236ec5c8a0 · 2017-10-31T08:05:39.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -6576,7 +6576,7 @@ namespace ts {
                 if (!node) return false;
                 switch (node.kind) {
                     case SyntaxKind.Identifier:
-                        return (<Identifier>node).escapedText === "arguments" && isPartOfExpression(node);
+                        return (<Identifier>node).escapedText === "arguments" && isExpressionNode(node);
 
                     case SyntaxKind.PropertyDeclaration:
                     case SyntaxKind.MethodDeclaration:
@@ -12522,7 +12522,7 @@ namespace ts {
                 if (isRightSideOfQualifiedNameOrPropertyAccess(location)) {
                     location = location.parent;
                 }
-                if (isPartOfExpression(location) && !isAssignmentTarget(location)) {
+                if (isExpressionNode(location) && !isAssignmentTarget(location)) {
                     const type = getTypeOfExpression(<Expression>location);
                     if (getExportSymbolOfValueSymbolIfExported(getNodeLinks(location).resolvedSymbol) === symbol) {
                         return type;
@@ -15211,7 +15211,7 @@ namespace ts {
                         // We might be in `a = { b: this.b }`, so keep looking. See `tests/cases/compiler/useBeforeDeclaration_propertyAssignment.ts`.
                         return false;
                     default:
-                        return isPartOfExpression(node) ? false : "quit";
+                        return isExpressionNode(node) ? false : "quit";
                 }
             });
         }
@@ -23482,7 +23482,7 @@ namespace ts {
                 return typeParameter && typeParameter.symbol;
             }
 
-            if (isPartOfExpression(entityName)) {
+            if (isExpressionNode(entityName)) {
                 if (nodeIsMissing(entityName)) {
                     // Missing entity name.
                     return undefined;
@@ -23656,7 +23656,7 @@ namespace ts {
                 return typeFromTypeNode;
             }
 
-            if (isPartOfExpression(node)) {
+            if (isExpressionNode(node)) {
                 return getRegularTypeOfExpression(<Expression>node);
             }
 
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -1228,7 +1228,7 @@ namespace ts {
         return false;
     }
 
-    export function isPartOfExpression(node: Node): boolean {
+    export function isExpressionNode(node: Node): boolean {
         switch (node.kind) {
             case SyntaxKind.SuperKeyword:
             case SyntaxKind.NullKeyword:
@@ -1331,7 +1331,7 @@ namespace ts {
             case SyntaxKind.ExpressionWithTypeArguments:
                 return (<ExpressionWithTypeArguments>parent).expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent);
             default:
-                return isPartOfExpression(parent);
+                return isExpressionNode(parent);
         }
     }
 
@@ -5381,7 +5381,7 @@ namespace ts {
     /* @internal */
     /**
      * Determines whether a node is an expression based only on its kind.
-     * Use `isPartOfExpression` if not in transforms.
+     * Use `isExpressionNode` if not in transforms.
      */
     export function isExpression(node: Node): node is Expression {
         return isExpressionKind(skipPartiallyEmittedExpressions(node).kind);
diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts
@@ -52,7 +52,7 @@ class TypeWriterWalker {
     }
 
     private *visitNode(node: ts.Node, isSymbolWalk: boolean): IterableIterator<TypeWriterResult> {
-        if (ts.isPartOfExpression(node) || node.kind === ts.SyntaxKind.Identifier) {
+        if (ts.isExpressionNode(node) || node.kind === ts.SyntaxKind.Identifier) {
             const result = this.writeTypeOrSymbol(node, isSymbolWalk);
             if (result) {
                 yield result;
diff --git a/src/services/breakpoints.ts b/src/services/breakpoints.ts
@@ -297,7 +297,7 @@ namespace ts.BreakpointResolver {
                             }
                         }
 
-                        if (isPartOfExpression(node)) {
+                        if (isExpressionNode(node)) {
                             switch (node.parent.kind) {
                                 case SyntaxKind.DoStatement:
                                     // Set span as if on while keyword
diff --git a/src/services/codefixes/inferFromUsage.ts b/src/services/codefixes/inferFromUsage.ts
@@ -368,7 +368,7 @@ namespace ts.codefix {
         }
 
         function inferTypeFromContextualType(node: Expression, checker: TypeChecker, usageContext: UsageContext): void {
-            if (isPartOfExpression(node)) {
+            if (isExpressionNode(node)) {
                 addCandidateType(usageContext, checker.getContextualType(node));
             }
         }
diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts
@@ -849,7 +849,7 @@ namespace ts.formatting {
         }
 
         static NodeIsInDecoratorContext(node: Node): boolean {
-            while (isPartOfExpression(node)) {
+            while (isExpressionNode(node)) {
                 node = node.parent;
             }
             return node.kind === SyntaxKind.Decorator;
diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts
@@ -331,7 +331,7 @@ namespace ts.refactor.extractSymbol {
                 Continue = 1 << 1,
                 Return = 1 << 2
             }
-            if (!isStatement(nodeToCheck) && !(isPartOfExpression(nodeToCheck) && isExtractableExpression(nodeToCheck))) {
+            if (!isStatement(nodeToCheck) && !(isExpressionNode(nodeToCheck) && isExtractableExpression(nodeToCheck))) {
                 return [createDiagnosticForNode(nodeToCheck, Messages.StatementOrExpressionExpected)];
             }
 
@@ -491,7 +491,7 @@ namespace ts.refactor.extractSymbol {
         if (isStatement(node)) {
             return [node];
         }
-        else if (isPartOfExpression(node)) {
+        else if (isExpressionNode(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
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
@@ -178,7 +178,7 @@ namespace ts {
 
         switch (node.kind) {
             case SyntaxKind.ThisKeyword:
-                return !isPartOfExpression(node);
+                return !isExpressionNode(node);
             case SyntaxKind.ThisType:
                 return true;
         }

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ class TypeWriterWalker {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`private *visitNode(node: ts.Node, isSymbolWalk: boolean): IterableIterator<TypeWriterResult> {`
`55`		`- if (ts.isPartOfExpression(node) \|\| node.kind === ts.SyntaxKind.Identifier) {`
	`55`	`+ if (ts.isExpressionNode(node) \|\| node.kind === ts.SyntaxKind.Identifier) {`
`56`	`56`	`const result = this.writeTypeOrSymbol(node, isSymbolWalk);`
`57`	`57`	`if (result) {`
`58`	`58`	`yield result;`
Original file line number	Diff line number	Diff line change
`@@ -297,7 +297,7 @@ namespace ts.BreakpointResolver {`
`297`	`297`	`}`
`298`	`298`	`}`
`299`	`299`
`300`		`- if (isPartOfExpression(node)) {`
	`300`	`+ if (isExpressionNode(node)) {`
`301`	`301`	`switch (node.parent.kind) {`
`302`	`302`	`case SyntaxKind.DoStatement:`
`303`	`303`	`// Set span as if on while keyword`
Original file line number	Diff line number	Diff line change
`@@ -368,7 +368,7 @@ namespace ts.codefix {`
`368`	`368`	`}`
`369`	`369`
`370`	`370`	`function inferTypeFromContextualType(node: Expression, checker: TypeChecker, usageContext: UsageContext): void {`
`371`		`- if (isPartOfExpression(node)) {`
	`371`	`+ if (isExpressionNode(node)) {`
`372`	`372`	`addCandidateType(usageContext, checker.getContextualType(node));`
`373`	`373`	`}`
`374`	`374`	`}`
Original file line number	Diff line number	Diff line change
`@@ -849,7 +849,7 @@ namespace ts.formatting {`
`849`	`849`	`}`
`850`	`850`
`851`	`851`	`static NodeIsInDecoratorContext(node: Node): boolean {`
`852`		`- while (isPartOfExpression(node)) {`
	`852`	`+ while (isExpressionNode(node)) {`
`853`	`853`	`node = node.parent;`
`854`	`854`	`}`
`855`	`855`	`return node.kind === SyntaxKind.Decorator;`
Original file line number	Diff line number	Diff line change
`@@ -331,7 +331,7 @@ namespace ts.refactor.extractSymbol {`
`331`	`331`	`Continue = 1 << 1,`
`332`	`332`	`Return = 1 << 2`
`333`	`333`	`}`
`334`		`- if (!isStatement(nodeToCheck) && !(isPartOfExpression(nodeToCheck) && isExtractableExpression(nodeToCheck))) {`
	`334`	`+ if (!isStatement(nodeToCheck) && !(isExpressionNode(nodeToCheck) && isExtractableExpression(nodeToCheck))) {`
`335`	`335`	`return [createDiagnosticForNode(nodeToCheck, Messages.StatementOrExpressionExpected)];`
`336`	`336`	`}`
`337`	`337`
`@@ -491,7 +491,7 @@ namespace ts.refactor.extractSymbol {`
`491`	`491`	`if (isStatement(node)) {`
`492`	`492`	`return [node];`
`493`	`493`	`}`
`494`		`- else if (isPartOfExpression(node)) {`
	`494`	`+ else if (isExpressionNode(node)) {`
`495`	`495`	`// If our selection is the expression in an ExpressionStatement, expand`
`496`	`496`	`// the selection to include the enclosing Statement (this stops us`
`497`	`497`	`// from trying to care about the return value of the extracted function`
Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ namespace ts {`
`178`	`178`
`179`	`179`	`switch (node.kind) {`
`180`	`180`	`case SyntaxKind.ThisKeyword:`
`181`		`- return !isPartOfExpression(node);`
	`181`	`+ return !isExpressionNode(node);`
`182`	`182`	`case SyntaxKind.ThisType:`
`183`	`183`	`return true;`
`184`	`184`	`}`