remove a rundant (and incorrect) computation and reuse the correct one

related to racket/drracket#177

Author: rfindler

gui-lib/framework/private/text-search.rkt

@@ -266,19 +266,21 @@
           (queue-callback
            (λ ()
              (when searching-str
-               (define start-pos (get-focus-editor-start-position))
-               (define (how-many-to-add k)
-                 (if (search-result-compare <= (car k) start-pos) 1 0))
-               (define count
-                 (+ (if to-replace-highlight
-                        (how-many-to-add to-replace-highlight)
-                        0)
-                    (for/sum ([(k v) (in-hash search-bubble-table)])
-                      (how-many-to-add k))))
-               (update-before-caret-search-hit-count count))
+               (update-before-caret-search-hit-count
+                (calculate-before-caret-search-hit-count)))
              (set! search-position-callback-running? #f))
            #f)))
 
+      (define/private (calculate-before-caret-search-hit-count)
+        (define start-pos (get-focus-editor-start-position))
+        (define (how-many-to-add k)
+          (if (search-result-compare <= (car k) start-pos) 1 0))
+        (+ (if to-replace-highlight
+               (how-many-to-add to-replace-highlight)
+               0)
+           (for/sum ([(k v) (in-hash search-bubble-table)])
+             (how-many-to-add k))))
+
       (define/private (get-focus-editor-start-position)
         (let loop ([txt this])
           (define focus (send txt get-focus-snip))
@@ -402,15 +404,14 @@
             (define new-search-bubbles '())
             (define new-replace-bubble #f)
             (define first-hit (do-search 0))
-         
-            (define-values (this-search-hit-count this-before-caret-search-hit-count)
+
+            ;; TODO (maybe-queue-search-position-update)
+            (define this-search-hit-count
               (cond
                 [first-hit
                  (define sp (get-focus-editor-start-position))
                  (let loop ([bubble-start first-hit]
-                            [search-hit-count 0]
-                            [before-caret-search-hit-count
-                             (if (search-result-compare < first-hit sp) 1 0)])
+                            [search-hit-count 0])
                    (maybe-pause)
                    (define bubble-end (search-result+ bubble-start (string-length searching-str)))
                    (define bubble (cons bubble-start (string-length searching-str)))
@@ -427,23 +428,15 @@
 
                    (define next (do-search bubble-end))
 
-                   (define next-before-caret-search-hit-count
-                     (if (and next (search-result-compare < next sp))
-                         (+ 1 before-caret-search-hit-count)
-                         before-caret-search-hit-count))
                    (cond
                      [next
                       ;; start a new one if there is another hit
-                      (loop next 
-                            (+ search-hit-count 1)
-                            next-before-caret-search-hit-count)]
+                      (loop next (+ search-hit-count 1))]
                      [else
-                      (values (+ search-hit-count 1) 
-                              before-caret-search-hit-count)]))]
-                [else (values 0 0)]))
+                      (+ search-hit-count 1)]))]
+                [else 0]))
 
             (set! search-hit-count this-search-hit-count)
-            (set! before-caret-search-hit-count this-before-caret-search-hit-count)
 
             (maybe-pause)
 
@@ -460,7 +453,8 @@
                  (highlight-hit search-bubble)])
               (maybe-pause))
 
-            (update-yellow) 
+            (update-yellow)
+            (set! before-caret-search-hit-count (calculate-before-caret-search-hit-count))
             (end-edit-sequence)]
            [else
             (begin-edit-sequence #t #f)

gui-test/framework/tests/text.rkt

@@ -332,6 +332,62 @@
       (send t set-searching-state "b" #f #f)))
    (list 1 1))
 
+  (check-equal?
+   (run-search-test
+    (λ (t)
+      (send t insert " a b a b a")
+      (send t set-position 0 0)
+      (send t set-searching-state "a" #f #f)))
+   (list 0 3))
+
+  (check-equal?
+   (run-search-test
+    (λ (t)
+      (send t insert " a b a b a")
+      (send t set-position 1 1)
+      (send t set-searching-state "a" #f #f)))
+   (list 1 3))
+
+  (check-equal?
+   (run-search-test
+    (λ (t)
+      (send t insert " a b a b a")
+      (send t set-position 2 2)
+      (send t set-searching-state "a" #f #f)))
+   (list 1 3))
+
+  (check-equal?
+   (run-search-test
+    (λ (t)
+      (send t insert " a b a b a")
+      (send t set-position 3 3)
+      (send t set-searching-state "a" #f #f)))
+   (list 1 3))
+
+  (check-equal?
+   (run-search-test
+    (λ (t)
+      (send t insert " a b a b a")
+      (send t set-position 4 4)
+      (send t set-searching-state "a" #f #f)))
+   (list 1 3))
+
+  (check-equal?
+   (run-search-test
+    (λ (t)
+      (send t insert " a b a b a")
+      (send t set-position 5 5)
+      (send t set-searching-state "a" #f #f)))
+   (list 2 3))
+
+  (check-equal?
+   (run-search-test
+    (λ (t)
+      (send t insert " a b a b a")
+      (send t set-position 2 2)
+      (send t set-searching-state "a" #f #f)))
+   (list 1 3))
+
   (check-equal?
    (run-search-test
     (λ (t)