initial commit
This commit is contained in:
265
node_modules/tslint/lib/verify/parse.js
generated
vendored
Normal file
265
node_modules/tslint/lib/verify/parse.js
generated
vendored
Normal file
@@ -0,0 +1,265 @@
|
||||
"use strict";
|
||||
/*
|
||||
* @license
|
||||
* Copyright 2018 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 semver = require("semver");
|
||||
var ts = require("typescript");
|
||||
var util_1 = require("util");
|
||||
var utils_1 = require("../utils");
|
||||
var lines_1 = require("./lines");
|
||||
var lintError_1 = require("./lintError");
|
||||
var scanner;
|
||||
function getTypescriptVersionRequirement(text) {
|
||||
var lines = text.split(/\r?\n/);
|
||||
var firstLine = lines_1.parseLine(lines[0]);
|
||||
if (firstLine instanceof lines_1.MessageSubstitutionLine && firstLine.key === "typescript") {
|
||||
return firstLine.message;
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
exports.getTypescriptVersionRequirement = getTypescriptVersionRequirement;
|
||||
function getNormalizedTypescriptVersion() {
|
||||
var tsVersion = new semver.SemVer(ts.version);
|
||||
// remove prerelease suffix when matching to allow testing with nightly builds
|
||||
return tsVersion.major + "." + tsVersion.minor + "." + tsVersion.patch;
|
||||
}
|
||||
exports.getNormalizedTypescriptVersion = getNormalizedTypescriptVersion;
|
||||
function preprocessDirectives(text) {
|
||||
if (!/^#(?:if|else|endif)\b/m.test(text)) {
|
||||
return text; // If there are no directives, just return the input unchanged
|
||||
}
|
||||
var tsVersion = getNormalizedTypescriptVersion();
|
||||
var lines = text.split(/\n/);
|
||||
var result = [];
|
||||
var collecting = true;
|
||||
var state = 0 /* Initial */;
|
||||
for (var _i = 0, lines_2 = lines; _i < lines_2.length; _i++) {
|
||||
var line = lines_2[_i];
|
||||
if (line.startsWith("#if typescript")) {
|
||||
if (state !== 0 /* Initial */) {
|
||||
throw lintError_1.lintSyntaxError("#if directives cannot be nested");
|
||||
}
|
||||
state = 1 /* If */;
|
||||
collecting = semver.satisfies(tsVersion, line.slice("#if typescript".length).trim());
|
||||
}
|
||||
else if (/^#else\s*$/.test(line)) {
|
||||
if (state !== 1 /* If */) {
|
||||
throw lintError_1.lintSyntaxError("unexpected #else");
|
||||
}
|
||||
state = 2 /* Else */;
|
||||
collecting = !collecting;
|
||||
}
|
||||
else if (/^#endif\s*$/.test(line)) {
|
||||
if (state === 0 /* Initial */) {
|
||||
throw lintError_1.lintSyntaxError("unexpected #endif");
|
||||
}
|
||||
state = 0 /* Initial */;
|
||||
collecting = true;
|
||||
}
|
||||
else if (collecting) {
|
||||
result.push(line);
|
||||
}
|
||||
}
|
||||
if (state !== 0 /* Initial */) {
|
||||
throw lintError_1.lintSyntaxError("expected #endif");
|
||||
}
|
||||
return result.join("\n");
|
||||
}
|
||||
exports.preprocessDirectives = preprocessDirectives;
|
||||
/**
|
||||
* Takes the full text of a .lint file and returns the contents of the file
|
||||
* with all error markup removed
|
||||
*/
|
||||
function removeErrorMarkup(text) {
|
||||
var textWithMarkup = text.split("\n");
|
||||
var lines = textWithMarkup.map(lines_1.parseLine);
|
||||
var codeText = lines
|
||||
.filter(function (line) { return line instanceof lines_1.CodeLine; })
|
||||
.map(function (line) { return line.contents; });
|
||||
return codeText.join("\n");
|
||||
}
|
||||
exports.removeErrorMarkup = removeErrorMarkup;
|
||||
/* tslint:disable:object-literal-sort-keys */
|
||||
/**
|
||||
* Takes the full text of a .lint file and returns an array of LintErrors
|
||||
* corresponding to the error markup in the file.
|
||||
*/
|
||||
function parseErrorsFromMarkup(text) {
|
||||
var textWithMarkup = text.split("\n");
|
||||
var lines = textWithMarkup.map(lines_1.parseLine);
|
||||
if (lines.length > 0 && !(lines[0] instanceof lines_1.CodeLine)) {
|
||||
throw lintError_1.lintSyntaxError("text cannot start with an error mark line.");
|
||||
}
|
||||
var messageSubstitutionLines = lines.filter(function (l) { return l instanceof lines_1.MessageSubstitutionLine; });
|
||||
var messageSubstitutions = new Map();
|
||||
for (var _i = 0, messageSubstitutionLines_1 = messageSubstitutionLines; _i < messageSubstitutionLines_1.length; _i++) {
|
||||
var _a = messageSubstitutionLines_1[_i], key = _a.key, message = _a.message;
|
||||
messageSubstitutions.set(key, formatMessage(messageSubstitutions, message));
|
||||
}
|
||||
// errorLineForCodeLine[5] contains all the ErrorLine objects associated with the 5th line of code, for example
|
||||
var errorLinesForCodeLines = createCodeLineNoToErrorsMap(lines);
|
||||
var lintErrors = [];
|
||||
function addError(errorLine, errorStartPos, lineNo) {
|
||||
lintErrors.push({
|
||||
startPos: errorStartPos,
|
||||
endPos: { line: lineNo, col: errorLine.endCol },
|
||||
message: substituteMessage(messageSubstitutions, errorLine.message),
|
||||
});
|
||||
}
|
||||
// for each line of code...
|
||||
errorLinesForCodeLines.forEach(function (errorLinesForLineOfCode, lineNo) {
|
||||
// for each error marking on that line...
|
||||
while (errorLinesForLineOfCode.length > 0) {
|
||||
var errorLine = errorLinesForLineOfCode.shift();
|
||||
var errorStartPos = { line: lineNo, col: errorLine.startCol };
|
||||
// if the error starts and ends on this line, add it now to list of errors
|
||||
if (errorLine instanceof lines_1.EndErrorLine) {
|
||||
addError(errorLine, errorStartPos, lineNo);
|
||||
// if the error is the start of a multiline error
|
||||
}
|
||||
else if (errorLine instanceof lines_1.MultilineErrorLine) {
|
||||
// iterate through the MultilineErrorLines until we get to an EndErrorLine
|
||||
for (var nextLineNo = lineNo + 1;; ++nextLineNo) {
|
||||
if (!isValidErrorMarkupContinuation(errorLinesForCodeLines, nextLineNo)) {
|
||||
throw lintError_1.lintSyntaxError("Error mark starting at " + errorStartPos.line + ":" + errorStartPos.col + " does not end correctly.");
|
||||
}
|
||||
else {
|
||||
var nextErrorLine = errorLinesForCodeLines[nextLineNo].shift();
|
||||
// if end of multiline error, add it it list of errors
|
||||
if (nextErrorLine instanceof lines_1.EndErrorLine) {
|
||||
addError(nextErrorLine, errorStartPos, nextLineNo);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
lintErrors.sort(lintError_1.errorComparator);
|
||||
return lintErrors;
|
||||
}
|
||||
exports.parseErrorsFromMarkup = parseErrorsFromMarkup;
|
||||
/**
|
||||
* Process `message` as follows:
|
||||
* - search `substitutions` for an exact match and return the substitution
|
||||
* - try to format the message when it looks like: name % ('substitution1' [, "substitution2" [, ...]])
|
||||
* - or return it unchanged
|
||||
*/
|
||||
function substituteMessage(templates, message) {
|
||||
var substitution = templates.get(message);
|
||||
if (substitution !== undefined) {
|
||||
return substitution;
|
||||
}
|
||||
return formatMessage(templates, message);
|
||||
}
|
||||
/**
|
||||
* Tries to format the message when it has the correct format or returns it unchanged: name % ('substitution1' [, "substitution2" [, ...]])
|
||||
* Where `name` is the name of a message substitution that is used as template.
|
||||
* If `name` is not found in `templates`, `message` is returned unchanged.
|
||||
*/
|
||||
function formatMessage(templates, message) {
|
||||
var formatMatch = /^([-\w]+) % \((.+)\)$/.exec(message);
|
||||
if (formatMatch !== null) {
|
||||
var template = templates.get(formatMatch[1]);
|
||||
if (template !== undefined) {
|
||||
var formatArgs = parseFormatArguments(formatMatch[2]);
|
||||
if (formatArgs !== undefined) {
|
||||
message = util_1.format.apply(void 0, [template].concat(formatArgs));
|
||||
}
|
||||
}
|
||||
}
|
||||
return message;
|
||||
}
|
||||
/**
|
||||
* Parse a list of comma separated string literals.
|
||||
* This function bails out if it sees something unexpected.
|
||||
* Whitespace between tokens is ignored.
|
||||
* Trailing comma is allowed.
|
||||
*/
|
||||
function parseFormatArguments(text) {
|
||||
if (scanner === undefined) {
|
||||
// once the scanner is created, it is cached for subsequent calls
|
||||
scanner = ts.createScanner(ts.ScriptTarget.Latest, false);
|
||||
}
|
||||
scanner.setText(text);
|
||||
var result = [];
|
||||
var expectValue = true;
|
||||
for (var token = scanner.scan(); token !== ts.SyntaxKind.EndOfFileToken; token = scanner.scan()) {
|
||||
if (token === ts.SyntaxKind.StringLiteral) {
|
||||
if (!expectValue) {
|
||||
return undefined;
|
||||
}
|
||||
result.push(scanner.getTokenValue());
|
||||
expectValue = false;
|
||||
}
|
||||
else if (token === ts.SyntaxKind.CommaToken) {
|
||||
if (expectValue) {
|
||||
return undefined;
|
||||
}
|
||||
expectValue = true;
|
||||
}
|
||||
else if (token !== ts.SyntaxKind.WhitespaceTrivia) {
|
||||
// only ignore whitespace, other trivia like comments makes this function bail out
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
return result.length === 0 ? undefined : result;
|
||||
}
|
||||
function createMarkupFromErrors(fileName, code, lintErrors) {
|
||||
lintErrors.sort(lintError_1.errorComparator);
|
||||
var codeText = code.split("\n");
|
||||
var errorLinesForCodeText = codeText.map(function () { return []; });
|
||||
for (var _i = 0, lintErrors_1 = lintErrors; _i < lintErrors_1.length; _i++) {
|
||||
var error = lintErrors_1[_i];
|
||||
var startPos = error.startPos, endPos = error.endPos, message = error.message;
|
||||
if (startPos.line === endPos.line) {
|
||||
// single line error
|
||||
errorLinesForCodeText[startPos.line].push(new lines_1.EndErrorLine(startPos.col, endPos.col, message));
|
||||
}
|
||||
else {
|
||||
// multiline error
|
||||
errorLinesForCodeText[startPos.line].push(new lines_1.MultilineErrorLine(startPos.col));
|
||||
for (var lineNo = startPos.line + 1; lineNo < endPos.line; ++lineNo) {
|
||||
errorLinesForCodeText[lineNo].push(new lines_1.MultilineErrorLine(0));
|
||||
}
|
||||
errorLinesForCodeText[endPos.line].push(new lines_1.EndErrorLine(0, endPos.col, message));
|
||||
}
|
||||
}
|
||||
return utils_1.flatMap(codeText, function (line, i) { return [
|
||||
line
|
||||
].concat(utils_1.mapDefined(errorLinesForCodeText[i], function (err) { return lines_1.printLine(fileName, err, line); })); }).join("\n");
|
||||
}
|
||||
exports.createMarkupFromErrors = createMarkupFromErrors;
|
||||
/* tslint:enable:object-literal-sort-keys */
|
||||
function createCodeLineNoToErrorsMap(lines) {
|
||||
var errorLinesForCodeLine = [];
|
||||
for (var _i = 0, lines_3 = lines; _i < lines_3.length; _i++) {
|
||||
var line = lines_3[_i];
|
||||
if (line instanceof lines_1.CodeLine) {
|
||||
errorLinesForCodeLine.push([]);
|
||||
}
|
||||
else if (line instanceof lines_1.ErrorLine) {
|
||||
errorLinesForCodeLine[errorLinesForCodeLine.length - 1].push(line);
|
||||
}
|
||||
}
|
||||
return errorLinesForCodeLine;
|
||||
}
|
||||
function isValidErrorMarkupContinuation(errorLinesForCodeLines, lineNo) {
|
||||
return (lineNo < errorLinesForCodeLines.length &&
|
||||
errorLinesForCodeLines[lineNo].length !== 0 &&
|
||||
errorLinesForCodeLines[lineNo][0].startCol === 0);
|
||||
}
|
||||
Reference in New Issue
Block a user