Fixed startCol/endCol vs startOffset/endOffset mismatch due to greediness and whitespaces

.editorconfig

@@ -0,0 +1,4 @@
+[*.{.js,.json}]
+end_of_line = lf
+indent_size = 2
+indent_style = space

.gitattributes

@@ -1,3 +1,6 @@
 test/fixtures/scripts/needs-compile.js eol=crlf
 test/fixtures/scripts/needs-compile.compiled.js eol=crlf
-test/fixtures/scripts/needs-compile.compiled.js.map eol=crlf
+test/fixtures/scripts/needs-compile.compiled.js.map eol=crlf
+test/fixtures/scripts/branches.covered.js eol=lf
+test/fixtures/scripts/branches.js eol=lf
+test/fixtures/scripts/functions.js eol=lf

.gitignore

@@ -4,3 +4,5 @@ coverage
 node_modules
 .idea
 .vscode
+*.iml
+yarn.lock

lib/line.js

@@ -4,12 +4,14 @@ module.exports = class CovLine {
     // note that startCol and endCol are absolute positions
     // within a file, not relative to the line.
     this.startCol = startCol
+    this.minCol = startCol + lineStr.length - lineStr.trimStart().length
 
     // the line length itself does not include the newline characters,
     // these are however taken into account when enumerating absolute offset.
     const matchedNewLineChar = lineStr.match(/\r?\n$/u)
     const newLineLength = matchedNewLineChar ? matchedNewLineChar[0].length : 0
     this.endCol = startCol + lineStr.length - newLineLength
+    this.maxCol = startCol + lineStr.trimEnd().length
 
     // we start with all lines having been executed, and work
     // backwards zeroing out lines based on V8 output.

lib/range.js

@@ -0,0 +1,40 @@
+/**
+ * ...something resembling a binary search, to find the lowest line within the range.
+ * And then you could break as soon as the line is longer than the range...
+ */
+module.exports.sliceRange = (lines, startCol, endCol) => {
+  let lower = 0
+  let upper = lines.length - 1
+
+  let s
+  while (lower <= upper) {
+    s = (lower + upper) >> 1
+    if (startCol < lines[s].startCol) {
+      upper = s - 1
+    } else if (startCol >= lines[s].endCol) {
+      lower = s + 1
+    } else {
+      let e = s + 1
+      while (e < lines.length && endCol > lines[e].startCol) {
+        ++e
+      }
+      return lines.slice(s, e)
+    }
+  }
+  if (s >= 0 && lines[s].startCol >= startCol) {
+    let e = s + 1
+    while (e < lines.length && endCol > lines[e].startCol) {
+      ++e
+    }
+    return lines.slice(s, e)
+  }
+  return []
+}
+
+module.exports.trimRange = (rawSource, range) => {
+  const slice = rawSource.slice(range.startOffset, range.endOffset)
+  return {
+    startOffset: range.startOffset + (slice.length - slice.trimStart().length),
+    endOffset: range.endOffset - (slice.length - slice.trimEnd().length)
+  }
+}

lib/source.js

@@ -1,4 +1,5 @@
 const CovLine = require('./line')
+const { sliceRange } = require('./range')
 const { GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND } = require('source-map').SourceMapConsumer
 
 module.exports = class CovSource {
@@ -75,27 +76,24 @@ module.exports = class CovSource {
   // given a start column and end column in absolute offsets within
   // a source file (0 - EOF), returns the relative line column positions.
   offsetToOriginalRelative (sourceMap, startCol, endCol) {
-    const lines = this.lines.filter((line, i) => {
-      return startCol <= line.endCol && endCol >= line.startCol
-    })
+    const lines = sliceRange(this.lines, startCol, endCol)
     if (!lines.length) return {}
 
     const start = originalPositionTryBoth(
       sourceMap,
       lines[0].line,
       Math.max(0, startCol - lines[0].startCol)
     )
+    if (!(start && start.source)) {
+      return {}
+    }
+
     let end = originalEndPositionFor(
       sourceMap,
       lines[lines.length - 1].line,
       endCol - lines[lines.length - 1].startCol
     )
-
-    if (!(start && end)) {
-      return {}
-    }
-
-    if (!(start.source && end.source)) {
+    if (!(end && end.source)) {
       return {}
     }
 

lib/v8-to-istanbul.js

@@ -5,6 +5,7 @@ const { fileURLToPath } = require('url')
 const CovBranch = require('./branch')
 const CovFunction = require('./function')
 const CovSource = require('./source')
+const { sliceRange, trimRange } = require('./range')
 const compatError = Error(`requires Node.js ${require('../package.json').engines.node}`)
 let readFile = () => { throw compatError }
 try {
@@ -42,6 +43,7 @@ module.exports = class V8ToIstanbul {
 
   async load () {
     const rawSource = this.sources.source || await readFile(this.path, 'utf8')
+    this.rawSource = rawSource
     this.rawSourceMap = this.sources.sourceMap ||
       // if we find a source-map (either inline, or a .map file) we load
       // both the transpiled and original source, both of which are used during
@@ -112,22 +114,25 @@ module.exports = class V8ToIstanbul {
         if (this.excludePath(path)) {
           return
         }
-        const lines = covSource.lines.filter(line => {
-          // Upstream tooling can provide a block with the functionName
-          // (empty-report), this will result in a report that has all
-          // lines zeroed out.
-          if (block.functionName === '(empty-report)') {
+
+        // (empty-report), this will result in a report that has all
+        // lines zeroed out.
+        if (block.functionName === '(empty-report)') {
+          this.all = true
+          covSource.lines.forEach(line => {
             line.count = 0
-            this.all = true
-            return true
-          }
+          })
+        }
+
+        const lines = this.all ? covSource.lines : sliceRange(covSource.lines, startCol, endCol)
+        if (!lines.length) {
+          return
+        }
 
-          return startCol < line.endCol && endCol >= line.startCol
-        })
         const startLineInstance = lines[0]
         const endLineInstance = lines[lines.length - 1]
 
-        if (block.isBlockCoverage && lines.length) {
+        if (block.isBlockCoverage) {
           this.branches[path] = this.branches[path] || []
           // record branches.
           this.branches[path].push(new CovBranch(
@@ -138,7 +143,7 @@ module.exports = class V8ToIstanbul {
             range.count
           ))
 
-          // if block-level granularity is enabled, we we still create a single
+          // if block-level granularity is enabled, we still create a single
           // CovFunction tracking object for each set of ranges.
           if (block.functionName && i === 0) {
             this.functions[path] = this.functions[path] || []
@@ -151,7 +156,7 @@ module.exports = class V8ToIstanbul {
               range.count
             ))
           }
-        } else if (block.functionName && lines.length) {
+        } else if (block.functionName) {
           this.functions[path] = this.functions[path] || []
           // record functions.
           this.functions[path].push(new CovFunction(
@@ -164,6 +169,11 @@ module.exports = class V8ToIstanbul {
           ))
         }
 
+        const {
+          startCol: minCol,
+          endCol: maxCol
+        } = this._maybeRemapStartColEndCol(trimRange(this.rawSource, range))
+
         // record the lines (we record these as statements, such that we're
         // compatible with Istanbul 2.0).
         lines.forEach(line => {
@@ -176,7 +186,7 @@ module.exports = class V8ToIstanbul {
           // set to 0, and is set if the special comment /* c8 ignore next */
           // is used.
 
-          if (startCol <= line.startCol && endCol >= line.endCol && !line.ignore) {
+          if (minCol <= line.minCol && maxCol >= line.maxCol && !line.ignore) {
             line.count = range.count
           }
         })