* lisp/jit-lock.el (jit-lock-stealth-chunk-start): Don't widen.

(jit-lock-mode, jit-lock-functions, jit-lock-context-unfontify-pos):
Use defvar-local.
(jit-lock-register): Use setq-local.

Fixes: debbugs:13542

1 files changed, 40 insertions, 44 deletions

diff --git a/lisp/jit-lock.el b/lisp/jit-lock.el
index 668f1ec963a..d879735c344 100644
--- a/lisp/jit-lock.el
+++ b/lisp/jit-lock.el
@@ -132,20 +132,16 @@ If nil, fontification is not deferred."
 
 ;;; Variables that are not customizable.
 
-(defvar jit-lock-mode nil
+(defvar-local jit-lock-mode nil
   "Non-nil means Just-in-time Lock mode is active.")
-(make-variable-buffer-local 'jit-lock-mode)
 
-(defvar jit-lock-functions nil
+(defvar-local jit-lock-functions nil
   "Functions to do the actual fontification.
 They are called with two arguments: the START and END of the region to fontify.")
-(make-variable-buffer-local 'jit-lock-functions)
 
-(defvar jit-lock-context-unfontify-pos nil
+(defvar-local jit-lock-context-unfontify-pos nil
   "Consider text after this position as contextually unfontified.
 If nil, contextual fontification is disabled.")
-(make-variable-buffer-local 'jit-lock-context-unfontify-pos)
-
 
 (defvar jit-lock-stealth-timer nil
   "Timer for stealth fontification in Just-in-time Lock mode.")
@@ -305,7 +301,7 @@ that needs to be (re)fontified.
 If non-nil, CONTEXTUAL means that a contextual fontification would be useful."
   (add-hook 'jit-lock-functions fun nil t)
   (when (and contextual jit-lock-contextually)
-    (set (make-local-variable 'jit-lock-contextually) t))
+    (setq-local jit-lock-contextually t))
   (jit-lock-mode t))
 
 (defun jit-lock-unregister (fun)
@@ -439,41 +435,39 @@ Defaults to the whole buffer.  END can be out of bounds."
 Value is nil if there is nothing more to fontify."
   (if (zerop (buffer-size))
       nil
-    (save-restriction
-      (widen)
-      (let* ((next (text-property-not-all around (point-max) 'fontified t))
-	     (prev (previous-single-property-change around 'fontified))
-	     (prop (get-text-property (max (point-min) (1- around))
-				      'fontified))
-	     (start (cond
-		     ((null prev)
-		      ;; There is no property change between AROUND
-		      ;; and the start of the buffer.  If PROP is
-		      ;; non-nil, everything in front of AROUND is
-		      ;; fontified, otherwise nothing is fontified.
-		      (if (eq prop t)
-			  nil
-			(max (point-min)
-			     (- around (/ jit-lock-chunk-size 2)))))
-		     ((eq prop t)
-		      ;; PREV is the start of a region of fontified
-		      ;; text containing AROUND.  Start fontifying a
-		      ;; chunk size before the end of the unfontified
-		      ;; region in front of that.
-		      (max (or (previous-single-property-change prev 'fontified)
-			       (point-min))
-			   (- prev jit-lock-chunk-size)))
-		     (t
-		      ;; PREV is the start of a region of unfontified
-		      ;; text containing AROUND.  Start at PREV or
-		      ;; chunk size in front of AROUND, whichever is
-		      ;; nearer.
-		      (max prev (- around jit-lock-chunk-size)))))
-	     (result (cond ((null start) next)
-			   ((null next) start)
-			   ((< (- around start) (- next around)) start)
-			   (t next))))
-	result))))
+    (let* ((next (text-property-not-all around (point-max) 'fontified t))
+           (prev (previous-single-property-change around 'fontified))
+           (prop (get-text-property (max (point-min) (1- around))
+                                    'fontified))
+           (start (cond
+                   ((null prev)
+                    ;; There is no property change between AROUND
+                    ;; and the start of the buffer.  If PROP is
+                    ;; non-nil, everything in front of AROUND is
+                    ;; fontified, otherwise nothing is fontified.
+                    (if (eq prop t)
+                        nil
+                      (max (point-min)
+                           (- around (/ jit-lock-chunk-size 2)))))
+                   ((eq prop t)
+                    ;; PREV is the start of a region of fontified
+                    ;; text containing AROUND.  Start fontifying a
+                    ;; chunk size before the end of the unfontified
+                    ;; region in front of that.
+                    (max (or (previous-single-property-change prev 'fontified)
+                             (point-min))
+                         (- prev jit-lock-chunk-size)))
+                   (t
+                    ;; PREV is the start of a region of unfontified
+                    ;; text containing AROUND.  Start at PREV or
+                    ;; chunk size in front of AROUND, whichever is
+                    ;; nearer.
+                    (max prev (- around jit-lock-chunk-size)))))
+           (result (cond ((null start) next)
+                         ((null next) start)
+                         ((< (- around start) (- next around)) start)
+                         (t next))))
+      result)))
 
 (defun jit-lock-stealth-fontify (&optional repeat)
   "Fontify buffers stealthily.
@@ -564,7 +558,9 @@ non-nil in a repeated invocation of this function."
 	(when jit-lock-context-unfontify-pos
 	  ;; (message "Jit-Context %s" (buffer-name))
 	  (save-restriction
-	    (widen)
+            ;; Don't be blindsided by narrowing that starts in the middle
+            ;; of a jit-lock-defer-multiline.
+	    (widen) 
 	    (when (and (>= jit-lock-context-unfontify-pos (point-min))
 		       (< jit-lock-context-unfontify-pos (point-max)))
 	      ;; If we're in text that matches a complex multi-line