/** Provides predicates for recognizing commented-out code. */

import semmle.javascript.Comments

/** Gets a line in comment `c` that looks like commented-out code. */
private string getALineOfCommentedOutCode(Comment c) {
 result = c.getLine(_) and
 // line ends with ';', '{', or '}', optionally followed by a comma,
 (
 result.regexpMatch(".*[;{}],?\\s*") and
 // but it doesn't look like a JSDoc-like annotation
 not result.regexpMatch(".*@\\w+\\s*\\{.*\\}\\s*") and
 // and it does not contain three consecutive words (which is uncommon in code)
 not result.regexpMatch("[^'\\\"]*\\w\\s++\\w++\\s++\\w[^'\\\"]*")
 or
 // line is part of a block comment and ends with something that looks
 // like a line comment; character before '//' must not be ':' to
 // avoid matching URLs
 not c instanceof SlashSlashComment and
 result.regexpMatch("(.*[^:]|^)//.*[^/].*")
 or
 // similar, but don't be fooled by '//// this kind of comment' and
 // '//// this kind of comment ////'
 c instanceof SlashSlashComment and
 result.regexpMatch("/*([^/].*[^:]|[^:/])//.*[^/].*") and
 // exclude externalization comments
 not result.regexpMatch(".*\\$NON-NLS-\\d+\\$.*")
 )
}

/**
 * Holds if `c` is a comment containing code examples, and hence should be
 * disregarded when looking for commented-out code.
 */
private predicate containsCodeExample(Comment c) {
 c.getText().matches(["%<pre>%</pre>%", "%<code>%</code>%", "%@example%", "%```%"])
}

/**
 * Gets a comment that belongs to a run of consecutive comments in file `f`
 * starting with `c`, where `c` itself contains commented-out code, but the comment
 * preceding it, if any, does not.
 */
private Comment getCommentInRun(File f, Comment c) {
 exists(int n |
 c.onLines(f, n, _) and
 countCommentedOutLines(c) > 0 and
 not exists(Comment d | d.onLines(f, _, n - 1) | countCommentedOutLines(d) > 0)
 ) and
 (
 result = c
 or
 exists(Comment prev, int n |
 prev = getCommentInRun(f, c) and
 prev.onLines(f, _, n) and
 result.onLines(f, n + 1, _)
 )
 )
}

/**
 * Gets a comment that follows `c` in a run of consecutive comments and
 * does not contain a code example.
 */
private Comment getRelevantCommentInRun(Comment c) {
 result = getCommentInRun(_, c) and not containsCodeExample(result)
}

/** Gets the number of lines in comment `c` that look like commented-out code. */
private int countCommentedOutLines(Comment c) { result = count(getALineOfCommentedOutCode(c)) }

/** Gets the number of non-blank lines in comment `c`. */
private int countNonBlankLines(Comment c) {
 result = count(string line | line = c.getLine(_) and not line.regexpMatch("\\s*"))
}

/**
 * Gets the number of lines in comment `c` and subsequent comments that look like
 * they contain commented-out code.
 */
private int countCommentedOutLinesInRun(Comment c) {
 result = sum(Comment d | d = getRelevantCommentInRun(c) | countCommentedOutLines(d))
}

/** Gets the number of non-blank lines in `c` and subsequent comments. */
private int countNonBlankLinesInRun(Comment c) {
 result = sum(Comment d | d = getRelevantCommentInRun(c) | countNonBlankLines(d))
}

/**
 * A run of consecutive comments containing a high percentage of lines
 * that look like commented-out code.
 *
 * This is represented by the comment that starts the run, with a special
 * `hasLocationInfo` implementation that assigns it the entire run as its location.
 */
class CommentedOutCode extends Comment {
 CommentedOutCode() {
 exists(int codeLines, int nonBlankLines |
 countCommentedOutLines(this) > 0 and
 not exists(Comment prev | this = getCommentInRun(_, prev) and this != prev) and
 nonBlankLines = countNonBlankLinesInRun(this) and
 codeLines = countCommentedOutLinesInRun(this) and
 nonBlankLines > 0 and
 2 * codeLines > nonBlankLines
 )
 }

 /**
 * Gets the number of lines in this run of comments
 * that look like they contain commented-out code.
 */
 int getNumCodeLines() { result = countCommentedOutLinesInRun(this) }

 /**
 * Gets the number of non-blank lines in this run of comments.
 */
 int getNumNonBlankLines() { result = countNonBlankLinesInRun(this) }

 /**
 * Holds if this element is at the specified location.
 * The location spans column `startcolumn` of line `startline` to
 * column `endcolumn` of line `endline` in file `filepath`.
 * For more information, see
 * [Locations](https://codeql.github.com/docs/writing-codeql-queries/providing-locations-in-codeql-queries/).
 */
 predicate hasLocationInfo(
 string filepath, int startline, int startcolumn, int endline, int endcolumn
 ) {
 exists(Location loc, File f | loc = this.getLocation() and f = loc.getFile() |
 filepath = f.getAbsolutePath() and
 startline = loc.getStartLine() and
 startcolumn = loc.getStartColumn() and
 exists(Location last |
 last = getCommentInRun(f, this).getLocation() and
 last.getEndLine() = max(getCommentInRun(f, this).getLocation().getEndLine())
 |
 endline = last.getEndLine() and
 endcolumn = last.getEndColumn()
 )
 )
 }
}