refactor(tsetse): optimize equals-nan rule

`getText()` should be avoid as it as an expensive call; favor node 'isXYZ' checks and direct `text` property access.

simplify rule registration method overloads

uses type property directly to remove the need for specialized overloads for each TS node type

cleanup ban-expect-truthy-promise rule

Closes bazel-contrib#346

PiperOrigin-RevId: 225020913

Author: clydin

third_party/github.com/bazelbuild/rules_typescript/internal/tsetse/checker.ts

@@ -47,36 +47,8 @@ export class Checker {
    * `nodeKind` node in `nodeHandlersMap` map. After all rules register their
    * handlers, the source file AST will be traversed.
    */
-  on(nodeKind: ts.SyntaxKind.BinaryExpression,
-     handlerFunction: (checker: Checker, node: ts.BinaryExpression) => void,
-     code: number): void;
-  on(nodeKind: ts.SyntaxKind.ConditionalExpression,
-     handlerFunction:
-         (checker: Checker, node: ts.ConditionalExpression) => void,
-     code: number): void;
-  on(nodeKind: ts.SyntaxKind.WhileStatement,
-     handlerFunction: (checker: Checker, node: ts.WhileStatement) => void,
-     code: number): void;
-  on(nodeKind: ts.SyntaxKind.IfStatement,
-     handlerFunction: (checker: Checker, node: ts.IfStatement) => void,
-     code: number): void;
-  on(nodeKind: ts.SyntaxKind.CallExpression,
-     handlerFunction: (checker: Checker, node: ts.CallExpression) => void,
-     code: number): void;
-  on(nodeKind: ts.SyntaxKind.PropertyDeclaration,
-     handlerFunction: (checker: Checker, node: ts.PropertyDeclaration) => void,
-     code: number): void;
-  on(nodeKind: ts.SyntaxKind.ElementAccessExpression,
-     handlerFunction: (checker: Checker, node: ts.ElementAccessExpression) => void,
-     code: number): void;
-  on(nodeKind: ts.SyntaxKind.ImportDeclaration,
-     handlerFunction: (checker: Checker, node: ts.ImportDeclaration) => void,
-     code: number): void;
-  on(nodeKind: ts.SyntaxKind,
-     handlerFunction: (checker: Checker, node: ts.Node) => void,
-     code: number): void;
   on<T extends ts.Node>(
-      nodeKind: ts.SyntaxKind,
+      nodeKind: T['kind'],
       handlerFunction: (checker: Checker, node: T) => void, code: number) {
     const newHandler: Handler = {handlerFunction, code};
     const registeredHandlers: Handler[]|undefined =

third_party/github.com/bazelbuild/rules_typescript/internal/tsetse/rules/ban_expect_truthy_promise_rule.ts

@@ -21,23 +21,27 @@ export class Rule extends AbstractRule {
   }
 }
 
-function checkForTruthy(checker: Checker, node: ts.Node) {
-  const tc = checker.typeChecker;
+function checkForTruthy(checker: Checker, node: ts.PropertyAccessExpression) {
+  if (node.name.text !== 'toBeTruthy') {
+    return;
+  }
 
-  if (!tsutils.isPropertyAccessExpression(node)) {
+  const expectCallNode = getLeftmostNode(node);
+  if (!ts.isCallExpression(expectCallNode)) {
     return;
   }
 
-  if (node.name.getText() !== 'toBeTruthy') {
+  if (!ts.isIdentifier(expectCallNode.expression) || expectCallNode.expression.text !== 'expect') {
     return;
   }
 
-  const expectCallNode = getLeftmostNode(tc, node);
-  if (!ts.isCallExpression(expectCallNode)) {
+  if (expectCallNode.arguments.length === 0 || ts.isAwaitExpression(expectCallNode.arguments[0])) {
     return;
   }
 
-  const signature = checker.typeChecker.getResolvedSignature(expectCallNode);
+  const tc = checker.typeChecker;
+
+  const signature = tc.getResolvedSignature(expectCallNode);
   if (signature === undefined) {
     return;
   }
@@ -48,13 +52,11 @@ function checkForTruthy(checker: Checker, node: ts.Node) {
   }
 
   // Only look for methods named expect that return a Matchers
-  if (!((symbol.name === 'Matchers') &&
-        expectCallNode.expression.getText() === 'expect')) {
+  if (symbol.name !== 'Matchers') {
     return;
   }
 
-  if (!tsutils.isThenableType(tc, expectCallNode.arguments[0]) ||
-      tsutils.isAwaitExpression(expectCallNode.arguments[0])) {
+  if (!tsutils.isThenableType(tc, expectCallNode.arguments[0])) {
     return;
   }
 
@@ -67,8 +69,7 @@ function checkForTruthy(checker: Checker, node: ts.Node) {
           `\n\tSee http://tsetse.info/ban-expect-truthy-promise`);
 }
 
-function getLeftmostNode(
-    tc: ts.TypeChecker, node: ts.PropertyAccessExpression) {
+function getLeftmostNode(node: ts.PropertyAccessExpression) {
   let current: ts.LeftHandSideExpression|undefined = node;
   while (ts.isPropertyAccessExpression(current)) {
     current = current.expression;

third_party/github.com/bazelbuild/rules_typescript/internal/tsetse/rules/equals_nan_rule.ts

@@ -20,19 +20,41 @@ export class Rule extends AbstractRule {
 }
 
 function checkBinaryExpression(checker: Checker, node: ts.BinaryExpression) {
-  if (node.left.getText() === 'NaN' || node.right.getText() === 'NaN') {
-    const operator = node.operatorToken;
-    if (operator.kind == ts.SyntaxKind.EqualsEqualsToken ||
-        operator.kind === ts.SyntaxKind.EqualsEqualsEqualsToken) {
+  const isLeftNaN = ts.isIdentifier(node.left) && node.left.text === 'NaN';
+  const isRightNaN = ts.isIdentifier(node.right) && node.right.text === 'NaN';
+  if (!isLeftNaN && !isRightNaN) {
+    return;
+  }
+
+  // We avoid calling getText() on the node.operatorToken because it's slow.
+  // Instead, manually map back from the kind to the string form of the operator
+  switch (node.operatorToken.kind) {
+    case ts.SyntaxKind.EqualsEqualsToken:
+      checker.addFailureAtNode(
+        node,
+        `x == NaN is always false; use isNaN(x) instead`,
+      );
+      break;
+    case ts.SyntaxKind.EqualsEqualsEqualsToken:
+      checker.addFailureAtNode(
+        node,
+        `x === NaN is always false; use isNaN(x) instead`,
+      );
+      break;
+    case ts.SyntaxKind.ExclamationEqualsToken:
       checker.addFailureAtNode(
-          node,
-          `x ${operator.getText()} NaN is always false; use isNaN(x) instead`);
-    }
-    if (operator.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
-        operator.kind === ts.SyntaxKind.ExclamationEqualsToken) {
+        node,
+        `x != NaN is always true; use !isNaN(x) instead`,
+      );
+      break;
+    case ts.SyntaxKind.ExclamationEqualsEqualsToken:
       checker.addFailureAtNode(
-          node,
-          `x ${operator.getText()} NaN is always true; use !isNaN(x) instead`);
-    }
+        node,
+        `x !== NaN is always true; use !isNaN(x) instead`,
+      );
+      break;
+    default:
+      // We don't care about other operators acting on NaN
+      break;
   }
 }

third_party/github.com/bazelbuild/rules_typescript/package.bzl

@@ -24,7 +24,7 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 # It will be automatically synced via the npm "version" script
 # that is run when running `npm version` during the release
 # process. See `Releasing` section in README.md.
-VERSION = "0.22.0"
+VERSION = "0.21.0"
 
 def rules_typescript_dependencies():
     """

third_party/github.com/bazelbuild/rules_typescript/package.json

@@ -1,7 +1,7 @@
 {
     "description": "Monorepo for TypeScript Bazel support. Published packages are in subdirectories under internal/",
     "private": true,
-    "version": "0.22.0",
+    "version": "0.21.0",
     "dependencies": {
         "jasmine-core": "2.8.0",
         "karma": "alexeagle/karma#fa1a84ac881485b5657cb669e9b4e5da77b79f0a",