Ensure compatibility with older typescript in CI (#2893)

circle.yml

@@ -10,7 +10,7 @@ dependencies:
     - yarn
 test:
   override:
-    - case $CIRCLE_NODE_INDEX in [0-2]) yarn verify ;; 3) npm run clean && yarn compile && yarn add typescript@next && yarn test ;; esac:
+    - case $CIRCLE_NODE_INDEX in 0) npm run clean && yarn compile && yarn add typescript@2.1 && yarn test ;; 1) npm run clean && yarn compile && yarn add typescript@2.2 && yarn test ;; 2) yarn verify ;; 3) npm run clean && yarn compile && yarn add typescript@next && yarn test ;; esac:
         parallel: true
 deployment:
   npm-latest:

src/language/utils.ts

@@ -436,3 +436,9 @@ export function isNegativeNumberLiteral(node: ts.Node): node is ts.PrefixUnaryEx
         node.operator === ts.SyntaxKind.MinusToken &&
         node.operand.kind === ts.SyntaxKind.NumericLiteral;
 }
+
+/** Wrapper for compatibility with typescript@<2.3.1 */
+export function isWhiteSpace(ch: number): boolean {
+    // tslint:disable-next-line
+    return (ts.isWhiteSpaceLike || (ts as any).isWhiteSpace)(ch);
+}

src/rules/deprecationRule.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { isIdentifier } from "tsutils";
+import { getDeclarationOfBindingElement, isBindingElement, isIdentifier, isVariableDeclaration, isVariableDeclarationList } from "tsutils";
 import * as ts from "typescript";
 import * as Lint from "../index";
 
@@ -105,11 +105,52 @@ function getDeprecation(node: ts.Identifier, tc: ts.TypeChecker): string | undef
         symbol = tc.getAliasedSymbol(symbol);
     }
     if (symbol !== undefined) {
+        return getDeprecationValue(symbol);
+    }
+    return undefined;
+}
+
+function getDeprecationValue(symbol: ts.Symbol): string | undefined {
+    if (symbol.getJsDocTags !== undefined) {
         for (const tag of symbol.getJsDocTags()) {
             if (tag.name === "deprecated") {
                 return tag.text;
             }
         }
+        return undefined;
+    }
+    // for compatibility with typescript@<2.3.0
+    return getDeprecationFromDeclarations(symbol.declarations);
+}
+
+function getDeprecationFromDeclarations(declarations?: ts.Declaration[]): string | undefined {
+    if (declarations === undefined) {
+        return undefined;
+    }
+    let declaration: ts.Node;
+    for (declaration of declarations) {
+        if (isBindingElement(declaration)) {
+            declaration = getDeclarationOfBindingElement(declaration);
+        }
+        if (isVariableDeclaration(declaration)) {
+            declaration = declaration.parent!;
+        }
+        if (isVariableDeclarationList(declaration)) {
+            declaration = declaration.parent!;
+        }
+        for (const child of declaration.getChildren()) {
+            if (child.kind !== ts.SyntaxKind.JSDocComment) {
+                break;
+            }
+            if ((child as ts.JSDoc).tags === undefined) {
+                continue;
+            }
+            for (const tag of (child as ts.JSDoc).tags!) {
+                if (tag.tagName.text === "deprecated") {
+                    return tag.comment === undefined ? "" : tag.comment;
+                }
+            }
+        }
     }
     return undefined;
 }

src/rules/spaceBeforeFunctionParenRule.ts

@@ -95,7 +95,7 @@ function walk(ctx: Lint.WalkContext<Options>): void {
         // openParen may be missing for an async arrow function `async x => ...`.
         if (openParen === undefined) { return; }
 
-        const hasSpace = ts.isWhiteSpaceLike(sourceFile.text.charCodeAt(openParen.end - 2));
+        const hasSpace = Lint.isWhiteSpace(sourceFile.text.charCodeAt(openParen.end - 2));
 
         if (hasSpace && option === "never") {
             const pos = openParen.getStart() - 1;

src/rules/whitespaceRule.ts

@@ -247,7 +247,7 @@ function walk(ctx: Lint.WalkContext<Options>) {
     }
 
     function checkForTrailingWhitespace(position: number): void {
-        if (position !== sourceFile.end && !ts.isWhiteSpaceLike(sourceFile.text.charCodeAt(position))) {
+        if (position !== sourceFile.end && !Lint.isWhiteSpace(sourceFile.text.charCodeAt(position))) {
             addMissingWhitespaceErrorAt(position);
         }
     }

test/rules/return-undefined/test.ts.lint

@@ -1,3 +1,6 @@
+class Promise<T> {
+    then(): Promise<T>;
+}
 function valueWrong(): number | undefined {
     return;
     ~~~~~~~ [UNDEFINED]