From 7fff4499fd915bcea3fa93b1aa8b35f4fe7a6027 Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Sun, 28 May 2017 00:38:50 +0200 Subject: add linting (and some initial fixes) --- node_modules/tslint/lib/language/utils.js | 402 ++++++++++++++++++++++++++++++ 1 file changed, 402 insertions(+) create mode 100644 node_modules/tslint/lib/language/utils.js (limited to 'node_modules/tslint/lib/language/utils.js') diff --git a/node_modules/tslint/lib/language/utils.js b/node_modules/tslint/lib/language/utils.js new file mode 100644 index 000000000..4f1fa52cf --- /dev/null +++ b/node_modules/tslint/lib/language/utils.js @@ -0,0 +1,402 @@ +"use strict"; +/** + * @license + * Copyright 2013 Palantir Technologies, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +var path = require("path"); +var tsutils_1 = require("tsutils"); +var ts = require("typescript"); +function getSourceFile(fileName, source) { + var normalizedName = path.normalize(fileName).replace(/\\/g, "/"); + return ts.createSourceFile(normalizedName, source, ts.ScriptTarget.ES5, /*setParentNodes*/ true); +} +exports.getSourceFile = getSourceFile; +/** @deprecated See IDisabledInterval. */ +function doesIntersect(failure, disabledIntervals) { + return disabledIntervals.some(function (interval) { + var maxStart = Math.max(interval.startPosition, failure.getStartPosition().getPosition()); + var minEnd = Math.min(interval.endPosition, failure.getEndPosition().getPosition()); + return maxStart <= minEnd; + }); +} +exports.doesIntersect = doesIntersect; +/** + * @returns true if any modifier kinds passed along exist in the given modifiers array + */ +function hasModifier(modifiers) { + var modifierKinds = []; + for (var _i = 1; _i < arguments.length; _i++) { + modifierKinds[_i - 1] = arguments[_i]; + } + if (modifiers === undefined || modifierKinds.length === 0) { + return false; + } + return modifiers.some(function (m) { + return modifierKinds.some(function (k) { return m.kind === k; }); + }); +} +exports.hasModifier = hasModifier; +/** + * Determines if the appropriate bit in the parent (VariableDeclarationList) is set, + * which indicates this is a "let" or "const". + */ +function isBlockScopedVariable(node) { + if (node.kind === ts.SyntaxKind.VariableDeclaration) { + var parent = node.parent; + return parent.kind === ts.SyntaxKind.CatchClause || tsutils_1.isBlockScopedVariableDeclarationList(parent); + } + else { + return tsutils_1.isBlockScopedVariableDeclarationList(node.declarationList); + } +} +exports.isBlockScopedVariable = isBlockScopedVariable; +function isBlockScopedBindingElement(node) { + var variableDeclaration = getBindingElementVariableDeclaration(node); + // if no variable declaration, it must be a function param, which is block scoped + return (variableDeclaration == null) || isBlockScopedVariable(variableDeclaration); +} +exports.isBlockScopedBindingElement = isBlockScopedBindingElement; +function getBindingElementVariableDeclaration(node) { + var currentParent = node.parent; + while (currentParent.kind !== ts.SyntaxKind.VariableDeclaration) { + if (currentParent.parent == null) { + return null; // function parameter, no variable declaration + } + else { + currentParent = currentParent.parent; + } + } + return currentParent; +} +exports.getBindingElementVariableDeclaration = getBindingElementVariableDeclaration; +/** + * Finds a child of a given node with a given kind. + * Note: This uses `node.getChildren()`, which does extra parsing work to include tokens. + */ +function childOfKind(node, kind) { + return node.getChildren().find(function (child) { return child.kind === kind; }); +} +exports.childOfKind = childOfKind; +/** + * @returns true if some ancestor of `node` satisfies `predicate`, including `node` itself. + */ +function someAncestor(node, predicate) { + return predicate(node) || (node.parent != null && someAncestor(node.parent, predicate)); +} +exports.someAncestor = someAncestor; +function ancestorWhere(node, predicate) { + var cur = node; + do { + if (predicate(cur)) { + return cur; + } + cur = cur.parent; + } while (cur !== undefined); + return undefined; +} +exports.ancestorWhere = ancestorWhere; +function isAssignment(node) { + if (node.kind === ts.SyntaxKind.BinaryExpression) { + var binaryExpression = node; + return binaryExpression.operatorToken.kind >= ts.SyntaxKind.FirstAssignment + && binaryExpression.operatorToken.kind <= ts.SyntaxKind.LastAssignment; + } + else { + return false; + } +} +exports.isAssignment = isAssignment; +/** + * Bitwise check for node flags. + */ +function isNodeFlagSet(node, flagToCheck) { + // tslint:disable-next-line:no-bitwise + return (node.flags & flagToCheck) !== 0; +} +exports.isNodeFlagSet = isNodeFlagSet; +/** + * Bitwise check for combined node flags. + */ +function isCombinedNodeFlagSet(node, flagToCheck) { + // tslint:disable-next-line:no-bitwise + return (ts.getCombinedNodeFlags(node) & flagToCheck) !== 0; +} +exports.isCombinedNodeFlagSet = isCombinedNodeFlagSet; +/** + * Bitwise check for combined modifier flags. + */ +function isCombinedModifierFlagSet(node, flagToCheck) { + // tslint:disable-next-line:no-bitwise + return (ts.getCombinedModifierFlags(node) & flagToCheck) !== 0; +} +exports.isCombinedModifierFlagSet = isCombinedModifierFlagSet; +/** + * Bitwise check for type flags. + */ +function isTypeFlagSet(type, flagToCheck) { + // tslint:disable-next-line:no-bitwise + return (type.flags & flagToCheck) !== 0; +} +exports.isTypeFlagSet = isTypeFlagSet; +/** + * Bitwise check for symbol flags. + */ +function isSymbolFlagSet(symbol, flagToCheck) { + // tslint:disable-next-line:no-bitwise + return (symbol.flags & flagToCheck) !== 0; +} +exports.isSymbolFlagSet = isSymbolFlagSet; +/** + * Bitwise check for object flags. + * Does not work with TypeScript 2.0.x + */ +function isObjectFlagSet(objectType, flagToCheck) { + // tslint:disable-next-line:no-bitwise + return (objectType.objectFlags & flagToCheck) !== 0; +} +exports.isObjectFlagSet = isObjectFlagSet; +/** + * @returns true if decl is a nested module declaration, i.e. represents a segment of a dotted module path. + */ +function isNestedModuleDeclaration(decl) { + // in a declaration expression like 'module a.b.c' - 'a' is the top level module declaration node and 'b' and 'c' + // are nested therefore we can depend that a node's position will only match with its name's position for nested + // nodes + return decl.name.pos === decl.pos; +} +exports.isNestedModuleDeclaration = isNestedModuleDeclaration; +function unwrapParentheses(node) { + while (node.kind === ts.SyntaxKind.ParenthesizedExpression) { + node = node.expression; + } + return node; +} +exports.unwrapParentheses = unwrapParentheses; +function isScopeBoundary(node) { + return node.kind === ts.SyntaxKind.FunctionDeclaration + || node.kind === ts.SyntaxKind.FunctionExpression + || node.kind === ts.SyntaxKind.PropertyAssignment + || node.kind === ts.SyntaxKind.ShorthandPropertyAssignment + || node.kind === ts.SyntaxKind.MethodDeclaration + || node.kind === ts.SyntaxKind.Constructor + || node.kind === ts.SyntaxKind.ModuleDeclaration + || node.kind === ts.SyntaxKind.ArrowFunction + || node.kind === ts.SyntaxKind.ParenthesizedExpression + || node.kind === ts.SyntaxKind.ClassDeclaration + || node.kind === ts.SyntaxKind.ClassExpression + || node.kind === ts.SyntaxKind.InterfaceDeclaration + || node.kind === ts.SyntaxKind.GetAccessor + || node.kind === ts.SyntaxKind.SetAccessor + || node.kind === ts.SyntaxKind.SourceFile && ts.isExternalModule(node); +} +exports.isScopeBoundary = isScopeBoundary; +function isBlockScopeBoundary(node) { + return isScopeBoundary(node) + || node.kind === ts.SyntaxKind.Block + || isLoop(node) + || node.kind === ts.SyntaxKind.WithStatement + || node.kind === ts.SyntaxKind.SwitchStatement + || node.parent !== undefined + && (node.parent.kind === ts.SyntaxKind.TryStatement + || node.parent.kind === ts.SyntaxKind.IfStatement); +} +exports.isBlockScopeBoundary = isBlockScopeBoundary; +function isLoop(node) { + return node.kind === ts.SyntaxKind.DoStatement + || node.kind === ts.SyntaxKind.WhileStatement + || node.kind === ts.SyntaxKind.ForStatement + || node.kind === ts.SyntaxKind.ForInStatement + || node.kind === ts.SyntaxKind.ForOfStatement; +} +exports.isLoop = isLoop; +/** + * Iterate over all tokens of `node` + * + * @description JsDoc comments are treated like regular comments and only visited if `skipTrivia` === false. + * + * @param node The node whose tokens should be visited + * @param skipTrivia If set to false all trivia preceeding `node` or any of its children is included + * @param cb Is called for every token of `node`. It gets the full text of the SourceFile and the position of the token within that text. + * @param filter If provided, will be called for every Node and Token found. If it returns false `cb` will not be called for this subtree. + */ +function forEachToken(node, skipTrivia, cb, filter) { + // this function will most likely be called with SourceFile anyways, so there is no need for an additional parameter + var sourceFile = node.getSourceFile(); + var fullText = sourceFile.text; + var iterateFn = filter === undefined ? iterateChildren : iterateWithFilter; + var handleTrivia = skipTrivia ? undefined : createTriviaHandler(sourceFile, cb); + iterateFn(node); + // this function is used to save the if condition for the common case where no filter is provided + function iterateWithFilter(child) { + if (filter(child)) { + return iterateChildren(child); + } + } + function iterateChildren(child) { + if (child.kind < ts.SyntaxKind.FirstNode || + // for backwards compatibility to typescript 2.0.10 + // JsxText was no Token, but a Node in that version + child.kind === ts.SyntaxKind.JsxText) { + // we found a token, tokens have no children, stop recursing here + return callback(child); + } + /* Exclude everything contained in JsDoc, it will be handled with the other trivia anyway. + * When we would handle JsDoc tokens like regular ones, we would scan some trivia multiple times. + * Even worse, we would scan for trivia inside the JsDoc comment, which yields unexpected results.*/ + if (child.kind !== ts.SyntaxKind.JSDocComment) { + // recurse into Node's children to find tokens + return child.getChildren(sourceFile).forEach(iterateFn); + } + } + function callback(token) { + var tokenStart = token.getStart(sourceFile); + if (!skipTrivia && tokenStart !== token.pos) { + // we only have to handle trivia before each token, because there is nothing after EndOfFileToken + handleTrivia(token.pos, tokenStart, token); + } + return cb(fullText, token.kind, { tokenStart: tokenStart, fullStart: token.pos, end: token.end }, token.parent); + } +} +exports.forEachToken = forEachToken; +function createTriviaHandler(sourceFile, cb) { + var fullText = sourceFile.text; + var scanner = ts.createScanner(sourceFile.languageVersion, false, sourceFile.languageVariant, fullText); + /** + * Scan the specified range to get all trivia tokens. + * This includes trailing trivia of the last token and the leading trivia of the current token + */ + function handleTrivia(start, end, token) { + var parent = token.parent; + // prevent false positives by not scanning inside JsxText + if (!canHaveLeadingTrivia(token.kind, parent)) { + return; + } + scanner.setTextPos(start); + var position; + // we only get here if start !== end, so we can scan at least one time + do { + var kind = scanner.scan(); + position = scanner.getTextPos(); + cb(fullText, kind, { tokenStart: scanner.getTokenPos(), end: position, fullStart: start }, parent); + } while (position < end); + } + return handleTrivia; +} +/** Iterate over all comments owned by `node` or its children */ +function forEachComment(node, cb) { + /* Visit all tokens and skip trivia. + Comment ranges between tokens are parsed without the need of a scanner. + forEachToken also does intentionally not pay attention to the correct comment ownership of nodes as it always + scans all trivia before each token, which could include trailing comments of the previous token. + Comment onwership is done right in this function*/ + return forEachToken(node, true, function (fullText, tokenKind, pos, parent) { + // don't search for comments inside JsxText + if (canHaveLeadingTrivia(tokenKind, parent)) { + // Comments before the first token (pos.fullStart === 0) are all considered leading comments, so no need for special treatment + var comments = ts.getLeadingCommentRanges(fullText, pos.fullStart); + if (comments !== undefined) { + for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) { + var comment = comments_1[_i]; + cb(fullText, comment.kind, { fullStart: pos.fullStart, tokenStart: comment.pos, end: comment.end }); + } + } + } + if (canHaveTrailingTrivia(tokenKind, parent)) { + var comments = ts.getTrailingCommentRanges(fullText, pos.end); + if (comments !== undefined) { + for (var _a = 0, comments_2 = comments; _a < comments_2.length; _a++) { + var comment = comments_2[_a]; + cb(fullText, comment.kind, { fullStart: pos.fullStart, tokenStart: comment.pos, end: comment.end }); + } + } + } + }); +} +exports.forEachComment = forEachComment; +/** Exclude leading positions that would lead to scanning for trivia inside JsxText */ +function canHaveLeadingTrivia(tokenKind, parent) { + switch (tokenKind) { + case ts.SyntaxKind.JsxText: + return false; // there is no trivia before JsxText + case ts.SyntaxKind.OpenBraceToken: + // before a JsxExpression inside a JsxElement's body can only be other JsxChild, but no trivia + return parent.kind !== ts.SyntaxKind.JsxExpression || parent.parent.kind !== ts.SyntaxKind.JsxElement; + case ts.SyntaxKind.LessThanToken: + switch (parent.kind) { + case ts.SyntaxKind.JsxClosingElement: + return false; // would be inside the element body + case ts.SyntaxKind.JsxOpeningElement: + case ts.SyntaxKind.JsxSelfClosingElement: + // there can only be leading trivia if we are at the end of the top level element + return parent.parent.parent.kind !== ts.SyntaxKind.JsxElement; + default: + return true; + } + default: + return true; + } +} +/** Exclude trailing positions that would lead to scanning for trivia inside JsxText */ +function canHaveTrailingTrivia(tokenKind, parent) { + switch (tokenKind) { + case ts.SyntaxKind.JsxText: + // there is no trivia after JsxText + return false; + case ts.SyntaxKind.CloseBraceToken: + // after a JsxExpression inside a JsxElement's body can only be other JsxChild, but no trivia + return parent.kind !== ts.SyntaxKind.JsxExpression || parent.parent.kind !== ts.SyntaxKind.JsxElement; + case ts.SyntaxKind.GreaterThanToken: + switch (parent.kind) { + case ts.SyntaxKind.JsxOpeningElement: + return false; // would be inside the element + case ts.SyntaxKind.JsxClosingElement: + case ts.SyntaxKind.JsxSelfClosingElement: + // there can only be trailing trivia if we are at the end of the top level element + return parent.parent.parent.kind !== ts.SyntaxKind.JsxElement; + default: + return true; + } + default: + return true; + } +} +/** + * Checks if there are any comments between `position` and the next non-trivia token + * + * @param text The text to scan + * @param position The position inside `text` where to start scanning. Make sure that this is a valid start position. + * This value is typically obtained from `node.getFullStart()` or `node.getEnd()` + */ +function hasCommentAfterPosition(text, position) { + return ts.getTrailingCommentRanges(text, position) !== undefined || + ts.getLeadingCommentRanges(text, position) !== undefined; +} +exports.hasCommentAfterPosition = hasCommentAfterPosition; +function getEqualsKind(node) { + switch (node.kind) { + case ts.SyntaxKind.EqualsEqualsToken: + return { isPositive: true, isStrict: false }; + case ts.SyntaxKind.EqualsEqualsEqualsToken: + return { isPositive: true, isStrict: true }; + case ts.SyntaxKind.ExclamationEqualsToken: + return { isPositive: false, isStrict: false }; + case ts.SyntaxKind.ExclamationEqualsEqualsToken: + return { isPositive: false, isStrict: true }; + default: + return undefined; + } +} +exports.getEqualsKind = getEqualsKind; -- cgit v1.2.3