Use setq-local and defvar-local

fice-t · fice-t · commit d2b83833a1b3 · 2016-04-09T16:01:13.000-06:00
Can now use these macros as support only goes back to 24.3.
diff --git a/ghci-script-mode.el b/ghci-script-mode.el
@@ -30,23 +30,22 @@
 ;;;###autoload
 (define-derived-mode ghci-script-mode text-mode "GHCi-Script"
   "Major mode for working with .ghci files."
-  (set (make-local-variable 'adaptive-fill-mode) nil)
-  (set (make-local-variable 'comment-start) "-- ")
-  (set (make-local-variable 'comment-padding) 0)
-  (set (make-local-variable 'comment-start-skip) "[-{]-[ \t]*")
-  (set (make-local-variable 'comment-end) "")
-  (set (make-local-variable 'comment-end-skip) "[ \t]*\\(-}\\|\\s>\\)")
-  (set (make-local-variable 'indent-line-function) 'haskell-mode-suggest-indent-choice)
-  (set (make-local-variable 'font-lock-defaults)
-       '(ghci-script-mode-keywords t t nil nil))
-  (set (make-local-variable 'indent-tabs-mode) nil)
-  (set (make-local-variable 'tab-width) 8)
+  (setq-local adaptive-fill-mode nil)
+  (setq-local comment-start "-- ")
+  (setq-local comment-padding 0)
+  (setq-local comment-start-skip "[-{]-[ \t]*")
+  (setq-local comment-end "")
+  (setq-local comment-end-skip "[ \t]*\\(-}\\|\\s>\\)")
+  (setq-local indent-line-function 'haskell-mode-suggest-indent-choice)
+  (setq-local font-lock-defaults '(ghci-script-mode-keywords t t nil nil))
+  (setq-local indent-tabs-mode nil)
+  (setq-local tab-width 8)
   (when (boundp 'electric-indent-inhibit)
     (setq electric-indent-inhibit t))
-  (set (make-local-variable 'dabbrev-case-fold-search) nil)
-  (set (make-local-variable 'dabbrev-case-distinction) nil)
-  (set (make-local-variable 'dabbrev-case-replace) nil)
-  (set (make-local-variable 'dabbrev-abbrev-char-regexp) "\\sw\\|[.]")
+  (setq-local dabbrev-case-fold-search nil)
+  (setq-local dabbrev-case-distinction nil)
+  (setq-local dabbrev-case-replace nil)
+  (setq-local dabbrev-abbrev-char-regexp "\\sw\\|[.]")
   (setq haskell-literate nil))
 
 ;;;###autoload
diff --git a/haskell-cabal.el b/haskell-cabal.el
@@ -145,16 +145,16 @@ it from list if one of the following conditions are hold:
 ;;;###autoload
 (define-derived-mode haskell-cabal-mode fundamental-mode "Haskell-Cabal"
   "Major mode for Cabal package description files."
-  (set (make-local-variable 'font-lock-defaults)
-       '(haskell-cabal-font-lock-keywords t t nil nil))
+  (setq-local font-lock-defaults
+              '(haskell-cabal-font-lock-keywords t t nil nil))
   (add-to-list 'haskell-cabal-buffers (current-buffer))
   (add-hook 'change-major-mode-hook 'haskell-cabal-unregister-buffer nil 'local)
   (add-hook 'kill-buffer-hook 'haskell-cabal-unregister-buffer nil 'local)
-  (set (make-local-variable 'comment-start) "-- ")
-  (set (make-local-variable 'comment-start-skip) "\\(^[ \t]*\\)--[ \t]*")
-  (set (make-local-variable 'comment-end) "")
-  (set (make-local-variable 'comment-end-skip) "[ \t]*\\(\\s>\\|\n\\)")
-  (set (make-local-variable 'indent-line-function) 'haskell-cabal-indent-line)
+  (setq-local comment-start "-- ")
+  (setq-local comment-start-skip "\\(^[ \t]*\\)--[ \t]*")
+  (setq-local comment-end "")
+  (setq-local comment-end-skip "[ \t]*\\(\\s>\\|\n\\)")
+  (setq-local indent-line-function 'haskell-cabal-indent-line)
   (setq indent-tabs-mode nil)
   )
 
diff --git a/haskell-checkers.el b/haskell-checkers.el
@@ -154,12 +154,12 @@ name - user visible name for this mode"
 ;;;###autoload
        (define-compilation-mode ,(intern (concat nm "-mode")) ,name
          ,(concat "Mode to check Haskell source code using " name)
-         (set (make-local-variable 'compilation-process-setup-function)
-              ',(intern (concat nm "-process-setup")))
-         (set (make-local-variable 'compilation-disable-input) t)
-         (set (make-local-variable 'compilation-scroll-output) nil)
-         (set (make-local-variable 'compilation-finish-functions)
-              (list ',(intern (concat nm "-finish-hook")))))
+         (setq-local compilation-process-setup-function
+                     ',(intern (concat nm "-process-setup")))
+         (setq-local compilation-disable-input t)
+         (setq-local compilation-scroll-output nil)
+         (setq-local compilation-finish-functions
+                     (list ',(intern (concat nm "-finish-hook")))))
 ;;;###autoload
        (defun ,(intern nm) ()
          ,(concat "Run " name " for current buffer with haskell source")
diff --git a/haskell-compile.el b/haskell-compile.el
@@ -106,8 +106,8 @@ format is supported, as well as info-locations within compile
 messages pointing to additional source locations.
 
 See Info node `(haskell-mode)compilation' for more details."
-  (set (make-local-variable 'compilation-error-regexp-alist)
-       haskell-compilation-error-regexp-alist)
+  (setq-local compilation-error-regexp-alist
+              haskell-compilation-error-regexp-alist)
 
   (add-hook 'compilation-filter-hook
             'haskell-compilation-filter-hook nil t)
diff --git a/haskell-decl-scan.el b/haskell-decl-scan.el
@@ -604,10 +604,8 @@ Invokes `haskell-decl-scan-mode-hook' on activation."
       (local-set-key [menu-bar index] nil)))
 
   (when haskell-decl-scan-mode
-    (set (make-local-variable 'beginning-of-defun-function)
-         'haskell-ds-backward-decl)
-    (set (make-local-variable 'end-of-defun-function)
-         'haskell-ds-forward-decl)
+    (setq-local beginning-of-defun-function 'haskell-ds-backward-decl)
+    (setq-local end-of-defun-function 'haskell-ds-forward-decl)
     (haskell-ds-imenu)))
 
 
diff --git a/haskell-doc.el b/haskell-doc.el
@@ -315,7 +315,7 @@
   :prefix "haskell-doc-")
 
 
-(defvar haskell-doc-mode nil
+(defvar-local haskell-doc-mode nil
   "*If non-nil, show the type of the function near point or a related comment.
 
 If the identifier near point is a Haskell keyword and the variable
@@ -343,17 +343,15 @@ in the alist `haskell-doc-user-defined-ids' and the variable
 `haskell-doc-show-user-defined' is non-nil show the type of the function.
 
 This variable is buffer-local.")
-(make-variable-buffer-local 'haskell-doc-mode)
 
 (defvar haskell-doc-mode-hook nil
   "Hook invoked when entering `haskell-doc-mode'.")
 
-(defvar haskell-doc-index nil
+(defvar-local haskell-doc-index nil
   "Variable holding an alist matching file names to fct-type alists.
 The function `haskell-doc-make-global-fct-index' rebuilds this variables
 \(similar to an `imenu' rescan\).
 This variable is buffer-local.")
-(make-variable-buffer-local 'haskell-doc-index)
 
 (defcustom haskell-doc-show-global-types nil
   "If non-nil, search for the types of global functions by loading the files.
diff --git a/haskell-font-lock.el b/haskell-font-lock.el
@@ -544,14 +544,14 @@ like ::, class, instance, data, newtype, type."
 
 (defun haskell-font-lock-defaults-create ()
   "Locally set `font-lock-defaults' for Haskell."
-  (set (make-local-variable 'font-lock-defaults)
-       '((haskell-font-lock-keywords)
-         nil nil nil nil
-         (font-lock-syntactic-face-function
-          . haskell-syntactic-face-function)
-         ;; Get help from font-lock-syntactic-keywords.
-         (parse-sexp-lookup-properties . t)
-         (font-lock-extra-managed-props . (composition)))))
+  (setq-local font-lock-defaults
+              '((haskell-font-lock-keywords)
+                nil nil nil nil
+                (font-lock-syntactic-face-function
+                 . haskell-syntactic-face-function)
+                ;; Get help from font-lock-syntactic-keywords.
+                (parse-sexp-lookup-properties . t)
+                (font-lock-extra-managed-props . (composition)))))
 
 (defun haskell-fontify-as-mode (text mode)
   "Fontify TEXT as MODE, returning the fontified text."
diff --git a/haskell-indent.el b/haskell-indent.el
@@ -1489,9 +1489,8 @@ One indentation cycle is used."
 
 ;;; haskell-indent-mode
 
-(defvar haskell-indent-mode nil
+(defvar-local haskell-indent-mode nil
   "Non-nil if the semi-intelligent Haskell indentation mode is in effect.")
-(make-variable-buffer-local 'haskell-indent-mode)
 
 (defvar haskell-indent-map
   (let ((map (make-sparse-keymap)))
@@ -1517,8 +1516,8 @@ One indentation cycle is used."
              (fboundp 'haskell-indentation-mode))
     (haskell-indentation-mode 0))
 
-  (set (make-local-variable 'indent-line-function) 'haskell-indent-cycle)
-  (set (make-local-variable 'indent-region-function) 'haskell-indent-region)
+  (setq-local indent-line-function 'haskell-indent-cycle)
+  (setq-local indent-region-function 'haskell-indent-region)
   (setq haskell-indent-mode t)
   ;; Activate our keymap.
   (let ((map (current-local-map)))
diff --git a/haskell-indentation.el b/haskell-indentation.el
@@ -111,10 +111,8 @@ set and deleted as if they were real tabs."
     (when (and (bound-and-true-p haskell-simple-indent-mode)
                (fboundp 'haskell-simple-indent-mode))
       (haskell-simple-indent-mode 0))
-    (set (make-local-variable 'indent-line-function)
-         'haskell-indentation-indent-line)
-    (set (make-local-variable 'indent-region-function)
-         'haskell-indentation-indent-region)))
+    (setq-local indent-line-function 'haskell-indentation-indent-line)
+    (setq-local indent-region-function 'haskell-indentation-indent-region)))
 
 ;;;###autoload
 (defun turn-on-haskell-indentation ()
diff --git a/haskell-interactive-mode.el b/haskell-interactive-mode.el
@@ -42,16 +42,12 @@
 (require 'cl-lib)
 (require 'etags)
 
-(defvar haskell-interactive-mode-history-index)
-(make-variable-buffer-local 'haskell-interactive-mode-history-index)
+(defvar-local haskell-interactive-mode-history-index 0)
 
-(defvar haskell-interactive-mode-history (list))
-(make-variable-buffer-local 'haskell-interactive-mode-history)
+(defvar-local haskell-interactive-mode-history (list))
 
-(defvar haskell-interactive-mode-old-prompt-start
-  nil
+(defvar-local haskell-interactive-mode-old-prompt-start nil
   "Mark used for the old beginning of the prompt.")
-(make-variable-buffer-local 'haskell-interactive-mode-old-prompt-start)
 
 (defun haskell-interactive-prompt-regex ()
   "Generate a regex for searching for any occurence of the prompt\
@@ -111,11 +107,10 @@ Key bindings:
   "Mark used to figure out where the end of the current result output is.
 Used to distinguish betwen user input.")
 
-(defvar haskell-interactive-previous-buffer nil
+(defvar-local haskell-interactive-previous-buffer nil
   "Records the buffer to which `haskell-interactive-switch-back' should jump.
 This is set by `haskell-interactive-switch', and should otherwise
 be nil.")
-(make-variable-buffer-local 'haskell-interactive-previous-buffer)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Hooks
@@ -327,8 +322,7 @@ SESSION, otherwise operate on the current buffer."
       (insert (substring prompt 0 1)
               (propertize (substring prompt 1)
                           'front-sticky t)))
-    (let ((marker (set (make-local-variable 'haskell-interactive-mode-prompt-start)
-                       (make-marker))))
+    (let ((marker (setq-local haskell-interactive-mode-prompt-start (make-marker))))
       (set-marker marker (point)))
     (when haskell-interactive-mode-scroll-to-bottom
       (haskell-interactive-mode-scroll-to-bottom))))
@@ -346,8 +340,7 @@ SESSION, otherwise operate on the current buffer."
                          'rear-nonsticky t
                          'result t)))
     (haskell-interactive-mode-handle-h)
-    (let ((marker (set (make-local-variable 'haskell-interactive-mode-result-end)
-                       (make-marker))))
+    (let ((marker (setq-local haskell-interactive-mode-result-end (make-marker))))
       (set-marker marker
                   (point)
                   (current-buffer)))
diff --git a/haskell-menu.el b/haskell-menu.el
@@ -61,8 +61,7 @@
 Each line describes one session.
 Letters do not insert themselves; instead, they are commands."
   (setq buffer-read-only t)
-  (set (make-local-variable 'revert-buffer-function)
-       'haskell-menu-revert-function)
+  (setq-local revert-buffer-function 'haskell-menu-revert-function)
   (setq truncate-lines t)
   (haskell-menu-revert-function nil t))
 
diff --git a/haskell-mode.el b/haskell-mode.el
@@ -177,15 +177,14 @@ With prefix argument HERE, insert it at point."
     (outline-show-subtree)))
 
 ;; Are we looking at a literate script?
-(defvar haskell-literate nil
+(defvar-local haskell-literate nil
   "If not nil, the current buffer contains a literate Haskell script.
 Possible values are: `bird' and `tex', for Bird-style and LaTeX-style
 literate scripts respectively.  Set by `haskell-mode' and
 `literate-haskell-mode'.  For an ambiguous literate buffer -- i.e. does
 not contain either \"\\begin{code}\" or \"\\end{code}\" on a line on
 its own, nor does it contain \">\" at the start of a line -- the value
 of `haskell-literate-default' is used.")
-(make-variable-buffer-local 'haskell-literate)
 (put 'haskell-literate 'safe-local-variable 'symbolp)
 
 ;; Default literate style for ambiguous literate buffers.
@@ -790,31 +789,26 @@ Minor modes that work well with `haskell-mode':
     (error "haskell-mode requires at least Emacs 24.3"))
 
   ;; paragraph-{start,separate} should treat comments as paragraphs as well.
-  (set (make-local-variable 'paragraph-start)
-       (concat " *{-\\| *-- |\\|" page-delimiter))
-  (set (make-local-variable 'paragraph-separate)
-       (concat " *$\\| *\\({-\\|-}\\) *$\\|" page-delimiter))
-  (set (make-local-variable 'fill-paragraph-function) 'haskell-fill-paragraph)
-  ;; (set (make-local-variable 'adaptive-fill-function) 'haskell-adaptive-fill)
-  (set (make-local-variable 'adaptive-fill-mode) nil)
-  (set (make-local-variable 'comment-start) "-- ")
-  (set (make-local-variable 'comment-padding) 0)
-  (set (make-local-variable 'comment-start-skip) "[-{]-[ \t]*")
-  (set (make-local-variable 'comment-end) "")
-  (set (make-local-variable 'comment-end-skip) "[ \t]*\\(-}\\|\\s>\\)")
-  (set (make-local-variable 'forward-sexp-function) #'haskell-forward-sexp)
-  (set (make-local-variable 'parse-sexp-ignore-comments) nil)
-  (set (make-local-variable 'syntax-propertize-function) #'haskell-syntax-propertize)
+  (setq-local paragraph-start (concat " *{-\\| *-- |\\|" page-delimiter))
+  (setq-local paragraph-separate (concat " *$\\| *\\({-\\|-}\\) *$\\|" page-delimiter))
+  (setq-local fill-paragraph-function 'haskell-fill-paragraph)
+  ;; (setq-local adaptive-fill-function 'haskell-adaptive-fill)
+  (setq-local adaptive-fill-mode nil)
+  (setq-local comment-start "-- ")
+  (setq-local comment-padding 0)
+  (setq-local comment-start-skip "[-{]-[ \t]*")
+  (setq-local comment-end "")
+  (setq-local comment-end-skip "[ \t]*\\(-}\\|\\s>\\)")
+  (setq-local forward-sexp-function #'haskell-forward-sexp)
+  (setq-local parse-sexp-ignore-comments nil)
+  (setq-local syntax-propertize-function #'haskell-syntax-propertize)
 
   ;; Set things up for eldoc-mode.
-  (set (make-local-variable 'eldoc-documentation-function)
-       'haskell-doc-current-info)
+  (setq-local eldoc-documentation-function 'haskell-doc-current-info)
   ;; Set things up for imenu.
-  (set (make-local-variable 'imenu-create-index-function)
-       'haskell-ds-create-imenu-index)
+  (setq-local imenu-create-index-function 'haskell-ds-create-imenu-index)
   ;; Set things up for font-lock.
-  (set (make-local-variable 'font-lock-defaults)
-       '((haskell-font-lock-keywords)
+  (setq-local font-lock-defaults '((haskell-font-lock-keywords)
          nil nil nil nil
          (font-lock-syntactic-face-function
           . haskell-syntactic-face-function)
@@ -824,20 +818,20 @@ Minor modes that work well with `haskell-mode':
   ;; Haskell's layout rules mean that TABs have to be handled with extra care.
   ;; The safer option is to avoid TABs.  The second best is to make sure
   ;; TABs stops are 8 chars apart, as mandated by the Haskell Report.  --Stef
-  (set (make-local-variable 'indent-tabs-mode) nil)
-  (set (make-local-variable 'tab-width) 8)
-  (set (make-local-variable 'comment-auto-fill-only-comments) t)
+  (setq-local indent-tabs-mode nil)
+  (setq-local tab-width 8)
+  (setq-local comment-auto-fill-only-comments t)
   ;; Haskell is not generally suitable for electric indentation, since
   ;; there is no unambiguously correct indent level for any given line.
   (when (boundp 'electric-indent-inhibit)
     (setq electric-indent-inhibit t))
 
   ;; dynamic abbrev support: recognize Haskell identifiers
   ;; Haskell is case-sensitive language
-  (set (make-local-variable 'dabbrev-case-fold-search) nil)
-  (set (make-local-variable 'dabbrev-case-distinction) nil)
-  (set (make-local-variable 'dabbrev-case-replace) nil)
-  (set (make-local-variable 'dabbrev-abbrev-char-regexp) "\\sw\\|[.]")
+  (setq-local dabbrev-case-fold-search nil)
+  (setq-local dabbrev-case-distinction nil)
+  (setq-local dabbrev-case-replace nil)
+  (setq-local dabbrev-abbrev-char-regexp "\\sw\\|[.]")
   (setq haskell-literate nil)
   (add-hook 'before-save-hook 'haskell-mode-before-save-handler nil t)
   (add-hook 'after-save-hook 'haskell-mode-after-save-handler nil t)
@@ -963,9 +957,8 @@ list marker of some kind), and end of the obstacle."
       ;; fill-comment-paragraph isn't much use there, and even gets confused
       ;; by the syntax-table text-properties we add to mark the first char
       ;; of each line as a comment-starter.
-      (set (make-local-variable 'fill-paragraph-handle-comment) nil))
-  (set (make-local-variable 'mode-line-process)
-       '("/" (:eval (symbol-name haskell-literate)))))
+      (setq-local fill-paragraph-handle-comment nil))
+  (setq-local mode-line-process '("/" (:eval (symbol-name haskell-literate)))))
 
 ;;;###autoload
 (add-to-list 'auto-mode-alist        '("\\.[gh]s\\'" . haskell-mode))
diff --git a/haskell-presentation-mode.el b/haskell-presentation-mode.el
@@ -85,7 +85,7 @@ buffer before presenting message."
     (with-current-buffer buffer
 
       (when (boundp 'shm-display-quarantine)
-        (set (make-local-variable 'shm-display-quarantine) nil))
+        (setq-local shm-display-quarantine nil))
 
       (when clear (haskell-presentation-clear))
       (haskell-session-assign session)
diff --git a/haskell-session.el b/haskell-session.el
@@ -36,9 +36,7 @@
 ;; Globals
 
 ;; Used internally
-(defvar haskell-session)
-
-(make-variable-buffer-local 'haskell-session)
+(defvar-local haskell-session nil)
 
 (defvar haskell-sessions (list)
   "All Haskell sessions in the Emacs session.")
@@ -92,7 +90,7 @@
 This could be helpful for temporary or auxiliary buffers such as
 presentation mode buffers (e.g. in case when session is killed
 with all relevant buffers)."
-  (set (make-local-variable 'haskell-session) session))
+  (setq-local haskell-session session))
 
 (defun haskell-session-choose ()
   "Find a session by choosing from a list of the current sessions."
@@ -112,7 +110,7 @@ with all relevant buffers)."
 
 (defun haskell-session-clear ()
   "Clear the buffer of any Haskell session choice."
-  (set (make-local-variable 'haskell-session) nil))
+  (setq-local haskell-session nil))
 
 (defun haskell-session-lookup (name)
   "Get the session by name."
diff --git a/haskell-utils.el b/haskell-utils.el
diff --git a/highlight-uses-mode.el b/highlight-uses-mode.el
diff --git a/inf-haskell.el b/inf-haskell.el
