Performance issue related indent/clojure.vim

[hovsater]

I've just got my hands into Clojure recently and noticed that Vim was lagging pretty hard. It seems like the culprit is indent/clojure.vim.

Given the following Clojure file, adding newlines at the end of the file will result in noticeable lag.

core.clojure

(ns introduction-to-clojure.core
  (:require [bakery.core :refer :all]))

(defn error [& args]
  (apply println args)
  :error)

(def baking  {:recipes {:cake {:ingredients {:egg   2
                                             :flour 2
                                             :sugar 1
                                             :milk  1}
                               :steps [[:add :all]
                                       [:mix]
                                       [:pour]
                                       [:bake 25]
                                       [:cool]]}
                        :cookies {:ingredients {:egg 1
                                                :flour 1
                                                :butter 1
                                                :sugar 1}
                                  :steps [[:add :all]
                                          [:mix]
                                          [:pour]
                                          [:bake 30]
                                          [:cool]]}
                        :brownies {:ingredients {:egg 2
                                                 :flour 2
                                                 :butter 2
                                                 :cocoa 2
                                                 :sugar 1
                                                 :milk 1}
                                   :steps [[:add :butter]
                                           [:add :cocoa]
                                           [:add :sugar]
                                           [:mix]
                                           [:add :egg]
                                           [:add :flour]
                                           [:add :milk]
                                           [:mix]
                                           [:pour]
                                           [:bake 35]
                                           [:cool]]}}
              :ingredients {:egg {:storage :fridge
                                  :usage :squeezed}
                            :milk {:storage :fridge
                                   :usage :scooped}
                            :flour {:storage :pantry
                                    :usage :scooped}
                            :butter {:storage :fridge
                                     :usage :simple}
                            :sugar {:storage :pantry
                                    :usage :scooped}
                            :cocoa {:storage :pantry
                                    :usage :scooped}}})

(def usage {:squeezed (fn [ingredient amount]
                        (dotimes [i amount]
                          (grab ingredient)
                          (squeeze)
                          (add-to-bowl)))
            :simple (fn [ingredient amount]
                      (dotimes [i amount]
                        (grab ingredient)
                        (add-to-bowl)))
            :scooped (fn [ingredient amount]
                       (grab :cup)
                       (dotimes [i amount]
                         (scoop ingredient)
                         (add-to-bowl))
                       (release))})

(defn usage-type [ingredient]
  (let [ingredients (get baking :ingredients)
        info (get ingredients ingredient)]
    (get info :usage)))

(defn add
  ([ingredient]
    (add ingredient 1))
  ([ingredient amount]
    (let [ingredient-type (usage-type ingredient)]
      (if (contains? usage ingredient-type)
        (let [f (get usage ingredient-type)]
          (f ingredient amount))
        (error "I do not know the ingredient" ingredient)))))

(def actions {:cool (fn [ingredients step]
                      (cool-pan))
              :mix  (fn [ingredients step]
                      (mix))
              :pour (fn [ingredients step]
                      (pour-into-pan))
              :bake (fn [ingredients step]
                      (bake-pan (second step)))
              :add  (fn [ingredients step]
                      (cond
                        (and (= 2 (count step))
                             (= :all (second step)))
                          (doseq [kv ingredients]
                            (add (first kv) (second kv)))
                        (and (= 2 (count step))
                             (contains? ingredients (second step)))
                        (add (second step) (get ingredients (second step)))
                        (= 3 (count step))
                        (add (second step) (get step 2))
                        :else
                        (error "I don't know how to add" (second step) (get step 2))))})

(defn perform [ingredients step]
  (let [f (get actions (first step) (fn [ingredients step]
                                      (println "I do not know how to" (first step))))]
    (f ingredients step)))

(defn bake-recipe [recipe]
  (last
    (for [step (get recipe :steps)]
      (perform (get recipe :ingredients) step))))

(defn load-up-amount [ingredient amount]
  (dotimes [i amount]
    (load-up ingredient)))

(defn unload-amount [ingredient amount]
  (dotimes [i amount]
    (unload ingredient)))

(defn fetch-ingredient
  ([ingredient]
    (fetch-ingredient ingredient 1))
  ([ingredient amount]
    (let [ingredients (get baking :ingredients)
          info (get ingredients ingredient)]
      (if (contains? ingredients ingredient)
        (do
          (go-to (get info :storage))
          (load-up-amount ingredient amount)
          (go-to :prep-area)
          (unload-amount ingredient amount))
        (error "I don't know the ingredient" ingredient)))))

(defn storage-location [ingredient]
  (let [ingredients (get baking :ingredients)
        info (get ingredients ingredient)]
    (get info :storage)))

(defn fetch-list [shopping]
  (let [by-location (group-by (fn [item-amount]
                                (storage-location (first item-amount)))
                              shopping)]
    (doseq [loc by-location]
      (go-to (first loc))
      (doseq [item-amount (second loc)]
        (load-up-amount (first item-amount) (second item-amount)))))

  (go-to :prep-area)
  (doseq [item-amount shopping]
    (unload-amount (first item-amount) (second item-amount))))

(defn add-ingredients [a b]
  (merge-with + a b))

(defn multiply-ingredients [n ingredients]
  (into {}
    (for [kv ingredients]
      [(first kv) (* n (second kv))])))

(defn order->ingredients [order]
  (let [recipes (get baking :recipes)
        items (get order :items)]
    (reduce add-ingredients {}
            (for [kv items]
              (let [recipe (get recipes (first kv))
                    ingredients (get recipe :ingredients)]
                (multiply-ingredients (second kv) ingredients))))))

(defn orders->ingredients [orders]
  (reduce add-ingredients {}
    (for [order orders]
      (order->ingredients order))))

(defn bake [item]
  (let [recipes (get baking :recipes)]
    (bake-recipe (get recipes item))))

(defn day-at-the-bakery []
  (let [orders (get-morning-orders-day3)
        ingredients (orders->ingredients orders)]
    (fetch-list ingredients)
    (doseq [order orders]
      (let [items (get order :items)
            racks (for [kv items
                        i (range (second kv))]
                    (bake (first kv)))
            receipt {:orderid (get order :orderid)
                     :address (get order :address)
                     :rackids racks}]
        (delivery receipt)))))

(defn -main []
  (bake-cake)
  (bake-cookies))

profile.log

FUNCTION  <SNR>8_match_pairs()
    Defined: /usr/local/Cellar/vim/8.1.0650/share/vim/vim81/indent/clojure.vim line 87
Called 63 times
Total time:   4.081067
 Self time:   0.245977

count  total (s)   self (s)
                            		" Stop only on vector and map [ resp. {. Ignore the ones in strings and
                            		" comments.
   63              0.000099 		if a:stopat == 0
   63              0.000279 			let stopat = max([line(".") - g:clojure_maxlines, 0])
                            		else
                            			let stopat = a:stopat
   63              0.000036 		endif
                            
   63   4.080176   0.245086 		let pos = searchpairpos(a:open, '', a:close, 'bWn', "!s:is_paren()", stopat)
   63              0.000211 		return [pos[0], col(pos)]

FUNCTION  <SNR>8_clojure_indent_pos()
    Defined: /usr/local/Cellar/vim/8.1.0650/share/vim/vim81/indent/clojure.vim line 206
Called 21 times
Total time:   4.092601
 Self time:   0.001783

count  total (s)   self (s)
                            		" Get rid of special case.
   21              0.000048 		if line(".") == 1
                            			return [0, 0]
   21              0.000018 		endif
                            
                            		" We have to apply some heuristics here to figure out, whether to use
                            		" normal lisp indenting or not.
   21   0.010045   0.000294 		let i = s:check_for_string()
   21              0.000020 		if i > -1
                            			return [0, i + !!g:clojure_align_multiline_strings]
   21              0.000014 		endif
                            
   21              0.000048 		call cursor(0, 1)
                            
                            		" Find the next enclosing [ or {. We can limit the second search
                            		" to the line, where the [ was found. If no [ was there this is
                            		" zero and we search for an enclosing {.
   21   3.064751   0.000319 		let paren = s:match_pairs('(', ')', 0)
   21   0.895804   0.000275 		let bracket = s:match_pairs('\[', '\]', paren[0])
   21   0.121386   0.000280 		let curly = s:match_pairs('{', '}', bracket[0])
                            
                            		" In case the curly brace is on a line later then the [ or - in
                            		" case they are on the same line - in a higher column, we take the
                            		" curly indent.
   21              0.000055 		if curly[0] > bracket[0] || curly[1] > bracket[1]
                            			if curly[0] > paren[0] || curly[1] > paren[1]
                            				return curly
                            			endif
   21              0.000014 		endif
                            
                            		" If the curly was not chosen, we take the bracket indent - if
                            		" there was one.
   21              0.000042 		if bracket[0] > paren[0] || bracket[1] > paren[1]
                            			return bracket
   21              0.000012 		endif
                            
                            		" There are neither { nor [ nor (, ie. we are at the toplevel.
   21              0.000035 		if paren == [0, 0]
   21              0.000018 			return paren
                            		endif
                            
                            		" Now we have to reimplement lispindent. This is surprisingly easy, as
                            		" soon as one has access to syntax items.
                            		"
                            		" - Check whether we are in a special position after a word in
                            		"   g:clojure_special_indent_words. These are special cases.
                            		" - Get the next keyword after the (.
                            		" - If its first character is also a (, we have another sexp and align
                            		"   one column to the right of the unmatched (.
                            		" - In case it is in lispwords, we indent the next line to the column of
                            		"   the ( + sw.
                            		" - If not, we check whether it is last word in the line. In that case
                            		"   we again use ( + sw for indent.
                            		" - In any other case we use the column of the end of the word + 2.
                            		call cursor(paren)
                            
                            		if s:is_method_special_case(paren)
                            			return [paren[0], paren[1] + shiftwidth() - 1]
                            		endif
                            
                            		if s:is_reader_conditional_special_case(paren)
                            			return paren
                            		endif
                            
                            		" In case we are at the last character, we use the paren position.
                            		if col("$") - 1 == paren[1]
                            			return paren
                            		endif
                            
                            		" In case after the paren is a whitespace, we search for the next word.
                            		call cursor(0, col('.') + 1)
                            		if s:current_char() == ' '
                            			call search('\v\S', 'W')
                            		endif
                            
                            		" If we moved to another line, there is no word after the (. We
                            		" use the ( position for indent.
                            		if line(".") > paren[0]
                            			return paren
                            		endif
                            
                            		" We still have to check, whether the keyword starts with a (, [ or {.
                            		" In that case we use the ( position for indent.
                            		let w = s:current_word()
                            		if s:bracket_type(w[0]) == 1
                            			return paren
                            		endif
                            
                            		" Test words without namespace qualifiers and leading reader macro
                            		" metacharacters.
                            		"
                            		" e.g. clojure.core/defn and #'defn should both indent like defn.
                            		let ww = s:strip_namespace_and_macro_chars(w)
                            
                            		if &lispwords =~# '\V\<' . ww . '\>'
                            			return [paren[0], paren[1] + shiftwidth() - 1]
                            		endif
                            
                            		if g:clojure_fuzzy_indent && !s:match_one(g:clojure_fuzzy_indent_blacklist, ww) && s:match_one(g:clojure_fuzzy_indent_patterns, ww)
                            			return [paren[0], paren[1] + shiftwidth() - 1]
                            		endif
                            
                            		call search('\v\_s', 'cW')
                            		call search('\v\S', 'W')
                            		if paren[0] < line(".")
                            			return [paren[0], paren[1] + (g:clojure_align_subforms ? 0 : shiftwidth() - 1)]
                            		endif
                            
                            		call search('\v\S', 'bW')
                            		return [line('.'), col('.') + 1]

FUNCTION  <SNR>8_clojure_check_for_string_worker()
    Defined: /usr/local/Cellar/vim/8.1.0650/share/vim/vim81/indent/clojure.vim line 100
Called 21 times
Total time:   0.009117
 Self time:   0.000672

count  total (s)   self (s)
                            		" Check whether there is the last character of the previous line is
                            		" highlighted as a string. If so, we check whether it's a ". In this
                            		" case we have to check also the previous character. The " might be the
                            		" closing one. In case the we are still in the string, we search for the
                            		" opening ". If this is not found we take the indent of the line.
   21              0.000086 		let nb = prevnonblank(v:lnum - 1)
                            
   21              0.000019 		if nb == 0
                            			return -1
   21              0.000012 		endif
                            
   21              0.000047 		call cursor(nb, 0)
   21              0.000065 		call cursor(0, col("$") - 1)
   21   0.008778   0.000333 		if s:syn_id_name() !~? "string"
   21              0.000022 			return -1
                            		endif
                            
                            		" This will not work for a " in the first column...
                            		if s:current_char() == '"'
                            			call cursor(0, col("$") - 2)
                            			if s:syn_id_name() !~? "string"
                            				return -1
                            			endif
                            			if s:current_char() != '\\'
                            				return -1
                            			endif
                            			call cursor(0, col("$") - 1)
                            		endif
                            
                            		let p = searchpos('\(^\|[^\\]\)\zs"', 'bW')
                            
                            		if p != [0, 0]
                            			return p[1] - 1
                            		endif
                            
                            		return indent(".")

FUNCTION  <SNR>8_current_char()
    Defined: /usr/local/Cellar/vim/8.1.0650/share/vim/vim81/indent/clojure.vim line 63
Called 6050 times
Total time:   0.022916
 Self time:   0.022916

count  total (s)   self (s)
 6050              0.021053 		return getline('.')[col('.')-1]

FUNCTION  <SNR>8_check_for_string()
    Defined: /usr/local/Cellar/vim/8.1.0650/share/vim/vim81/indent/clojure.vim line 139
Called 21 times
Total time:   0.009751
 Self time:   0.000634

count  total (s)   self (s)
   21              0.000072 		let pos = getpos('.')
   21              0.000020 		try
   21   0.009506   0.000389 			let val = s:clojure_check_for_string_worker()
   21              0.000023 		finally
   21              0.000060 			call setpos('.', pos)
   21              0.000018 		endtry
   21              0.000032 		return val

FUNCTION  <SNR>8_is_paren()
    Defined: /usr/local/Cellar/vim/8.1.0650/share/vim/vim81/indent/clojure.vim line 71
Called 6050 times
Total time:   3.835090
 Self time:   0.143374

count  total (s)   self (s)
 6050   3.833106   0.141390 		return s:current_char() =~# '\v[\(\)\[\]\{\}]' && !s:ignored_region()

FUNCTION  GetClojureIndent()
    Defined: /usr/local/Cellar/vim/8.1.0650/share/vim/vim81/indent/clojure.vim line 321
Called 21 times
Total time:   4.093354
 Self time:   0.000753

count  total (s)   self (s)
   21              0.000089 		let lnum = line('.')
   21              0.000028 		let orig_lnum = lnum
   21              0.000043 		let orig_col = col('.')
   21   4.092957   0.000356 		let [opening_lnum, indent] = s:clojure_indent_pos()
                            
                            		" Account for multibyte characters
   21              0.000018 		if opening_lnum > 0
                            			let indent -= indent - virtcol([opening_lnum, indent])
   21              0.000011 		endif
                            
                            		" Return if there are no previous lines to inherit from
   21              0.000025 		if opening_lnum < 1 || opening_lnum >= lnum - 1
   21              0.000064 			call cursor(orig_lnum, orig_col)
   21              0.000019 			return indent
                            		endif
                            
                            		let bracket_count = 0
                            
                            		" Take the indent of the first previous non-white line that is
                            		" at the same sexp level. cf. src/misc1.c:get_lisp_indent()
                            		while 1
                            			let lnum = prevnonblank(lnum - 1)
                            			let col = 1
                            
                            			if lnum <= opening_lnum
                            				break
                            			endif
                            
                            			call cursor(lnum, col)
                            
                            			" Handle bracket counting edge case
                            			if s:is_paren()
                            				let bracket_count += s:bracket_type(s:current_char())
                            			endif
                            
                            			while 1
                            				if search('\v[(\[{}\])]', '', lnum) < 1
                            					break
                            				elseif !s:ignored_region()
                            					let bracket_count += s:bracket_type(s:current_char())
                            				endif
                            			endwhile
                            
                            			if bracket_count == 0
                            				" Check if this is part of a multiline string
                            				call cursor(lnum, 1)
                            				if s:syn_id_name() !~? '\vstring|regex'
                            					call cursor(orig_lnum, orig_col)
                            					return indent(lnum)
                            				endif
                            			endif
                            		endwhile
                            
                            		call cursor(orig_lnum, orig_col)
                            		return indent

FUNCTION  <SNR>8_ignored_region()
    Defined: /usr/local/Cellar/vim/8.1.0650/share/vim/vim81/indent/clojure.vim line 59
Called 6050 times
Total time:   3.668800
 Self time:   0.127724

count  total (s)   self (s)
 6050   3.666821   0.125745 		return s:syn_id_name() =~? '\vstring|regex|comment|character'

FUNCTION  <SNR>8_syn_id_name()
    Defined: /usr/local/Cellar/vim/8.1.0650/share/vim/vim81/indent/clojure.vim line 55
Called 6071 times
Total time:   3.549521
 Self time:   3.549521

count  total (s)   self (s)
 6071              3.547512 		return synIDattr(synID(line("."), col("."), 0), "name")

FUNCTIONS SORTED ON TOTAL TIME
count  total (s)   self (s)  function
   21   4.093354   0.000753  GetClojureIndent()
   21   4.092601   0.001783  <SNR>8_clojure_indent_pos()
   63   4.081067   0.245977  <SNR>8_match_pairs()
 6050   3.835090   0.143374  <SNR>8_is_paren()
 6050   3.668800   0.127724  <SNR>8_ignored_region()
 6071   3.549521             <SNR>8_syn_id_name()
 6050   0.022916             <SNR>8_current_char()
   21   0.009751   0.000634  <SNR>8_check_for_string()
   21   0.009117   0.000672  <SNR>8_clojure_check_for_string_worker()

FUNCTIONS SORTED ON SELF TIME
count  total (s)   self (s)  function
 6071              3.549521  <SNR>8_syn_id_name()
   63   4.081067   0.245977  <SNR>8_match_pairs()
 6050   3.835090   0.143374  <SNR>8_is_paren()
 6050   3.668800   0.127724  <SNR>8_ignored_region()
 6050              0.022916  <SNR>8_current_char()
   21   4.092601   0.001783  <SNR>8_clojure_indent_pos()
   21   4.093354   0.000753  GetClojureIndent()
   21   0.009117   0.000672  <SNR>8_clojure_check_for_string_worker()
   21   0.009751   0.000634  <SNR>8_check_for_string()

vim --version

VIM - Vi IMproved 8.1 (2018 May 18, compiled Dec 28 2018 20:12:37)
macOS version
Included patches: 1-650
Compiled by Homebrew
Huge version without GUI.  Features included (+) or not (-):
+acl               +extra_search      +mouse_netterm     +tag_old_static
+arabic            +farsi             +mouse_sgr         -tag_any_white
+autocmd           +file_in_path      -mouse_sysmouse    -tcl
+autochdir         +find_in_path      +mouse_urxvt       +termguicolors
-autoservername    +float             +mouse_xterm       +terminal
-balloon_eval      +folding           +multi_byte        +terminfo
+balloon_eval_term -footer            +multi_lang        +termresponse
-browse            +fork()            -mzscheme          +textobjects
++builtin_terms    +gettext           +netbeans_intg     +textprop
+byte_offset       -hangul_input      +num64             +timers
+channel           +iconv             +packages          +title
+cindent           +insert_expand     +path_extra        -toolbar
-clientserver      +job               +perl              +user_commands
+clipboard         +jumplist          +persistent_undo   +vartabs
+cmdline_compl     +keymap            +postscript        +vertsplit
+cmdline_hist      +lambda            +printer           +virtualedit
+cmdline_info      +langmap           +profile           +visual
+comments          +libcall           -python            +visualextra
+conceal           +linebreak         +python3           +viminfo
+cryptv            +lispindent        +quickfix          +vreplace
+cscope            +listcmds          +reltime           +wildignore
+cursorbind        +localmap          +rightleft         +wildmenu
+cursorshape       +lua               +ruby              +windows
+dialog_con        +menu              +scrollbind        +writebackup
+diff              +mksession         +signs             -X11
+digraphs          +modify_fname      +smartindent       -xfontset
-dnd               +mouse             +startuptime       -xim
-ebcdic            -mouseshape        +statusline        -xpm
+emacs_tags        +mouse_dec         -sun_workshop      -xsmp
+eval              -mouse_gpm         +syntax            -xterm_clipboard
+ex_extra          -mouse_jsbterm     +tag_binary        -xterm_save
   system vimrc file: "$VIM/vimrc"
     user vimrc file: "$HOME/.vimrc"
 2nd user vimrc file: "~/.vim/vimrc"
      user exrc file: "$HOME/.exrc"
       defaults file: "$VIMRUNTIME/defaults.vim"
  fall-back for $VIM: "/usr/local/share/vim"
Compilation: clang -c -I. -Iproto -DHAVE_CONFIG_H   -DMACOS_X -DMACOS_X_DARWIN  -g -O2 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1
Linking: clang   -L. -fstack-protector-strong -L/usr/local/lib -L/usr/local/opt/libyaml/lib -L/usr/local/opt/openssl/lib -L/usr/local/opt/readline/lib  -L/usr/local/lib -o vim        -lncurses -liconv -lintl -framework AppKit  -L/usr/local/opt/lua/lib -llua5.3 -mmacosx-version-min=10.14 -fstack-protector-strong -L/usr/local/lib  -L/usr/local/Cellar/perl/5.28.1/lib/perl5/5.28.1/darwin-thread-multi-2level/CORE -lperl -lm -lutil -lc  -L/usr/local/opt/python/Frameworks/Python.framework/Versions/3.7/lib/python3.7/config-3.7m-darwin -lpython3.7m -framework CoreFoundation  -lruby.2.6

MacOS

MacOS Mojave
Version 10.14.2 (18C54)

[tvirolai]

Setting the let g:clojure_maxlines parameter to a lower value (200 currently) fixed this for me.

[benknoble]

@tvirolai are you sure 200? The default was 100... I was considering using 20.