adapt to changes in paren-tree

Author: rfindler

gui-lib/framework/private/color.rkt

@@ -64,14 +64,10 @@ added get-regions
  (define (attribs->invisible attribs)
    (cond
      [(symbol? attribs)
-      (values 0 #f)]
+      (values 0 0)]
      [else
-      (define open-count (hash-ref attribs 'invisible-open-count #f))
-      (define close-count (hash-ref attribs 'invisible-close-count #f))
-      (cond
-        [open-count (values open-count invisible-open)]
-        [close-count (values close-count invisible-close)]
-        [else (values 0 #f)])]))
+      (values (hash-ref attribs 'invisible-open-count 0)
+              (hash-ref attribs 'invisible-close-count 0))]))
 (define (attribs->table attribs)
   (if (symbol? attribs)
       (hasheq 'type attribs)
@@ -432,10 +428,11 @@ added get-regions
                                  len
                                  (make-data attribs new-lexer-mode backup-delta))
               #; (show-tree (lexer-state-tokens ls))
-              (define-values (invisible-count invisible-paren)
+              (define-values (invisible-opens invisible-closes)
                 (attribs->invisible attribs))
-              (send (lexer-state-parens ls) add-token (or paren invisible-paren) len
-                    #:invisible invisible-count)
+              (send (lexer-state-parens ls) add-token paren len
+                    #:invisible-opens invisible-opens
+                    #:invisible-closes invisible-closes)
               (cond
                 [(and (not (send (lexer-state-invalid-tokens ls) is-empty?))
                       (= (lexer-state-invalid-tokens-start ls)
@@ -890,15 +887,17 @@ added get-regions
             (when ls
               (define-values (start-f end-f error-f)
                 (send (lexer-state-parens ls) match-forward 
-                      (- caret-pos (lexer-state-start-pos ls))))
+                      (- caret-pos (lexer-state-start-pos ls))
+                      #:invisible 0))
               (when (and (not (f-match-false-error ls start-f end-f error-f))
                          start-f end-f)
                 (if error-f
                     (highlight ls start-f end-f caret-pos (and error-f #t))
                     (highlight-nested-region ls start-f end-f caret-pos)))
               (define-values (start-b end-b error-b)
                 (send (lexer-state-parens ls) match-backward 
-                      (- caret-pos (lexer-state-start-pos ls))))
+                      (- caret-pos (lexer-state-start-pos ls))
+                      #:invisible 0))
               (when (and start-b end-b)
                 (if error-b
                     (highlight ls start-b end-b caret-pos (and error-b #t))
@@ -944,28 +943,35 @@ added get-regions
       (define (single-spot-loop start depth)
         ;; the -1 and +1s in the calls to seq-loop should probably be based on the tokenization,
         ;; as more positions can be skipped in general
+        (define-values (invisible-paren-opens invisible-paren-closes)
+          (send (lexer-state-parens ls) get-invisible-count
+                (- start (lexer-state-start-pos ls))))
         (cond
-          [(send (lexer-state-parens ls) is-open-pos? start #:invisible-ok? #t)
-           (define invisible-paren-count (send (lexer-state-parens ls) get-invisible-count start))
+          [(or (not (zero? invisible-paren-opens))
+               (not (zero? invisible-paren-closes))
+               (send (lexer-state-parens ls) is-open-pos? (- start (lexer-state-start-pos ls))))
+           (define invisible-paren-count (+ invisible-paren-opens invisible-paren-closes))
            (define-values (outermost-start outermost-end error-outermost)
-             (send (lexer-state-parens ls) match-forward start #:invisible invisible-paren-count))
+             (send (lexer-state-parens ls) match-forward (- start (lexer-state-start-pos ls)) #:invisible invisible-paren-count))
            (let loop ([invisible-paren-count invisible-paren-count]
                       [end-position outermost-end]
                       [depth depth])
              (when (< depth (vector-length paren-colors))
                (define color (vector-ref paren-colors depth))
                (cond
                  [(zero? invisible-paren-count)
-                  (when (send (lexer-state-parens ls) is-open-pos? start #:invisible-ok? #f)
+                  (when (send (lexer-state-parens ls) is-open-pos? (- start (lexer-state-start-pos ls)))
                     (define-values (start-inner end-inner error-inner)
-                      (send (lexer-state-parens ls) match-forward start))
+                      (send (lexer-state-parens ls) match-forward (- start (lexer-state-start-pos ls))))
                     (unless error-inner
                       (seq-loop (+ start-inner 1) (- end-inner 1) (+ depth 1))
                       (seq-loop (+ end-inner 1) (- end-position 1) depth)
                       (highlight ls start-inner end-inner caret-pos color priority)))]
                  [else
                   (define-values (start-inner end-inner error-inner)
-                    (send (lexer-state-parens ls) match-forward start #:invisible invisible-paren-count))
+                    (send (lexer-state-parens ls) match-forward
+                          (- start (lexer-state-start-pos ls))
+                          #:invisible invisible-paren-count))
                   (unless error-inner
                     (seq-loop (+ end-inner 1) (- end-position 1) depth)
                     (loop (- invisible-paren-count 1) end-inner (+ depth 1))