hide byte offset api

main.rkt

@@ -35,7 +35,6 @@
   [make-covered?
    (-> file-coverage/c path-string?
        (->* (exact-positive-integer?)
-            (#:byte? boolean?)
             (or/c 'covered 'uncovered 'irrelevant)))]
 
   [generate-coveralls-coverage coverage-gen/c]

private/format-utils.rkt

@@ -31,11 +31,10 @@
   (define submods (irrelevant-submodules))
   (define vec
     (list->vector (string->list (file->string path))))
-  (define file/byte->str-offset (make-byte->str-offset vec))
   (define file-location-coverage-cache
     (coverage-cache-file path c submods))
-  (lambda (loc #:byte? [byte? #f])
+  (lambda (loc)
-    (hash-ref file-location-coverage-cache (if (not byte?) loc (- loc (file/byte->str-offset loc)))
+    (hash-ref file-location-coverage-cache loc
               'missing)))
 
 ;; (or/c #f (listof symbol))
@@ -170,12 +169,9 @@
        (define coverage (hash-ref (get-test-coverage) f))
        (define covered? (make-covered? coverage f))
        (check-equal? (covered? 14) 'irrelevant)
-       (check-equal? (covered? 14 #:byte? #t) 'irrelevant)
        (check-equal? (covered? 17) 'irrelevant)
        (check-equal? (covered? 28) 'irrelevant)
        (check-equal? (covered? 35) 'covered)
-       (check-equal? (covered? 50) 'uncovered)
-       (check-equal? (covered? 51 #:byte? #t) 'uncovered)
        (check-equal? (covered? 52) 'irrelevant)
        (check-equal? (covered? 53) 'irrelevant)
        (check-equal? (covered? 54) 'irrelevant)))))

private/html/html.rkt

@@ -58,7 +58,7 @@
       (define output-file
         (apply build-path (append coverage-dir-list (list relative-output-file))))
       (define output-dir (apply build-path coverage-dir-list))
-      (define assets-path 
+      (define assets-path
         (path->string
          (apply build-path
                 (append (build-list (sub1 (length coverage-dir-list)) (const ".."))
@@ -352,27 +352,33 @@
     ;; we don't need to look at the span because the coverage is expression based
     (define p (syntax-position e))
     (if p
-        (covered? p #:byte? #t)
+        (covered? p)
         'missing))
 
   (define e
     (with-module-reading-parameterization
-        (thunk (with-input-from-file path read-syntax))))
+        (thunk (with-input-from-file path
+                 (lambda ()
+                   (port-count-lines! (current-input-port))
+                   (read-syntax))))))
+
   (define (ret e) (values (e->n e) (a->n e)))
   (define (a->n e)
     (case (is-covered? e)
       [(covered uncovered) 1]
       [else 0]))
   (define (e->n e) (if (eq? (is-covered? e) 'covered) 1 0))
+
   (define-values (covered total)
     (let recur ([e e])
       (syntax-parse e
         [(v ...)
          (for/fold ([covered (e->n e)] [count (a->n e)])
-                   ([e (in-syntax e)])
+                   ([v (in-syntax e)])
-           (define-values (cov cnt) (recur e))
+           (define-values (cov cnt) (recur v))
            (values (+ covered cov)
                    (+ count cnt)))]
         [e:expr (ret #'e)]
         [_ (values 0 0)])))
+
   (list covered total))