;;; clojure-mode.el --- Major mode for Clojure code

;;; clojure-mode.el --- Major mode for Clojure code -*- lexical-binding: t; -*-

;; Copyright © 2007-2013 Jeffrey Chu, Lennart Staflin, Phil Hagelberg

;; Copyright © 2007-2017 Jeffrey Chu, Lennart Staflin, Phil Hagelberg

;; Copyright © 2013-2017 Bozhidar Batsov, Artur Malabarba

;;          Lennart Staflin <lenst@lysator.liu.se>

;;       Lennart Staflin <lenst@lysator.liu.se>

;;          Phil Hagelberg <technomancy@gmail.com>

;;       Phil Hagelberg <technomancy@gmail.com>

;;       Bozhidar Batsov <bozhidar@batsov.com>

;;       Artur Malabarba <bruce.connor.am@gmail.com>

;; Version: 2.1.1

;; Keywords: languages clojure clojurescript lisp

;; Keywords: languages, lisp

;; Version: 5.7.0-snapshot

;; Package-Requires: ((emacs "24.4"))

;; Provides font-lock, indentation, and navigation for the Clojure

;; Provides font-lock, indentation, navigation and basic refactoring for the

;; programming language (http://clojure.org).

;; Clojure programming language (http://clojure.org).

;; Users of older Emacs (pre-22) should get version 1.4:

;; Using clojure-mode with paredit or smartparens is highly recommended.

;; http://github.com/clojure-emacs/clojure-mode/tree/1.4

;; Slime integration has been removed; see the 1.x releases if you need it.

;; Here are some example configurations:

;;   (add-hook 'clojure-mode-hook 'paredit-mode)

;;   (add-hook 'clojure-mode-hook #'paredit-mode)

;;   ;; require or autoload smartparens

;;   (add-hook 'clojure-mode-hook #'smartparens-strict-mode)

;; See inf-clojure (http://github.com/clojure-emacs/inf-clojure) for

;; basic interaction with Clojure subprocesses.

(require 'cl)

(require 'cl-lib)

(require 'tramp)

(require 'inf-lisp)

(require 'easymenu)

(require 'newcomment)

(require 'align)

(declare-function clojure-test-jump-to-implementation  "clojure-test-mode.el")

(require 'subr-x)

(defconst clojure-font-lock-keywords

(declare-function lisp-fill-paragraph  "lisp-mode" (&optional justify))

  (eval-when-compile

    `( ;; Definitions.

      (,(concat "(\\(?:clojure.core/\\)?\\("

                (regexp-opt '("defn" "defn-" "def" "defonce"

                              "defmulti" "defmethod" "defmacro"

                              "defstruct" "deftype" "defprotocol"

                              "defrecord" "deftest" "def\\[a-z\\]"))

                ;; Function declarations.

                "\\)\\>"

                ;; Any whitespace

                "[ \r\n\t]*"

                ;; Possibly type or metadata

                "\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"

                "\\(\\sw+\\)?")

       (1 font-lock-keyword-face)

       (2 font-lock-function-name-face nil t))

      ;; (fn name? args ...)

      (,(concat "(\\(?:clojure.core/\\)?\\(fn\\)[ \t]+"

                ;; Possibly type

                "\\(?:#?^\\sw+[ \t]*\\)?"

                ;; Possibly name

                "\\(t\\sw+\\)?" )

       (1 font-lock-keyword-face)

       (2 font-lock-function-name-face nil t))

      (,(concat "(\\(\\(?:[a-z\.-]+/\\)?def\[a-z\-\]*-?\\)"

                ;; Function declarations.

                "\\>"

                ;; Any whitespace

                "[ \r\n\t]*"

                ;; Possibly type or metadata

                "\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"

                "\\(\\sw+\\)?")

       (1 font-lock-keyword-face)

       (2 font-lock-function-name-face nil t))

      ;; Deprecated functions

      (,(concat

         "(\\(?:clojure.core/\\)?"

         (regexp-opt

          '("add-watcher" "remove-watcher" "add-classpath") t)

         "\\>")

       1 font-lock-warning-face)

      ;; Control structures

      (,(concat

         "(\\(?:clojure.core/\\)?"

         (regexp-opt

          '("let" "letfn" "do"

            "case" "cond" "condp"

            "for" "loop" "recur"

            "when" "when-not" "when-let" "when-first"

            "if" "if-let" "if-not"

            "." ".." "->" "->>" "doto"

            "and" "or"

            "dosync" "doseq" "dotimes" "dorun" "doall"

            "load" "import" "unimport" "ns" "in-ns" "refer"

            "try" "catch" "finally" "throw"

            "with-open" "with-local-vars" "binding"

            "gen-class" "gen-and-load-class" "gen-and-save-class"

            "handler-case" "handle") t)

         "\\>")

       1 font-lock-keyword-face)

      ;; Built-ins

      (,(concat

         "(\\(?:clojure.core/\\)?"

         (regexp-opt

          '("*" "*1" "*2" "*3" "*agent*"

        "*allow-unresolved-vars*" "*assert*" "*clojure-version*" "*command-line-args*" "*compile-files*"

        "*compile-path*" "*e" "*err*" "*file*" "*flush-on-newline*"

        "*in*" "*macro-meta*" "*math-context*" "*ns*" "*out*"

        "*print-dup*" "*print-length*" "*print-level*" "*print-meta*" "*print-readably*"

        "*read-eval*" "*source-path*" "*use-context-classloader*" "*warn-on-reflection*" "+"

        "-" "/"

        "<" "<=" "=" "==" ">"

        ">=" "accessor" "aclone"

        "agent" "agent-errors" "aget" "alength" "alias"

        "all-ns" "alter" "alter-meta!" "alter-var-root" "amap"

        "ancestors" "and" "apply" "areduce" "array-map" "as->"

        "aset" "aset-boolean" "aset-byte" "aset-char" "aset-double"

        "aset-float" "aset-int" "aset-long" "aset-short" "assert"

        "assoc" "assoc!" "assoc-in" "associative?" "atom"

        "await" "await-for" "await1" "bases" "bean"

        "bigdec" "bigint" "binding" "bit-and" "bit-and-not"

        "bit-clear" "bit-flip" "bit-not" "bit-or" "bit-set"

        "bit-shift-left" "bit-shift-right" "bit-test" "bit-xor" "boolean"

        "boolean-array" "booleans" "bound-fn" "bound-fn*" "butlast"

        "byte" "byte-array" "bytes" "case" "cast" "char"

        "char-array" "char-escape-string" "char-name-string" "char?" "chars"

        "chunk" "chunk-append" "chunk-buffer" "chunk-cons" "chunk-first"

        "chunk-next" "chunk-rest" "chunked-seq?" "class" "class?"

        "clear-agent-errors" "clojure-version" "coll?" "comment" "commute"

        "comp" "comparator" "compare" "compare-and-set!" "compile"

        "complement" "concat" "cond" "condp" "cond->" "cond->>" "conj"

        "conj!" "cons" "constantly" "construct-proxy" "contains?"

        "count" "counted?" "create-ns" "create-struct" "cycle"

        "dec" "decimal?" "declare" "definline" "defmacro"

        "defmethod" "defmulti" "defn" "defn-" "defonce"

        "defstruct" "delay" "delay?" "deliver" "deref"

        "derive" "descendants" "destructure" "disj" "disj!"

        "dissoc" "dissoc!" "distinct" "distinct?" "doall"

        "doc" "dorun" "doseq" "dosync" "dotimes"

        "doto" "double" "double-array" "doubles" "drop"

        "drop-last" "drop-while" "empty" "empty?" "ensure"

        "enumeration-seq" "eval" "even?" "every?"

        "extend" "extend-protocol" "extend-type" "extends?" "extenders" "ex-info" "ex-data"

        "false?" "ffirst" "file-seq" "filter" "filterv" "find" "find-doc"

        "find-ns" "find-var" "first" "flatten" "float" "float-array"

        "float?" "floats" "flush" "fn" "fn?"

        "fnext" "for" "force" "format" "future"

        "future-call" "future-cancel" "future-cancelled?" "future-done?" "future?"

        "gen-class" "gen-interface" "gensym" "get" "get-in"

        "get-method" "get-proxy-class" "get-thread-bindings" "get-validator" "group-by"

        "hash" "hash-map" "hash-set" "identical?" "identity" "if-let"

        "if-not" "ifn?" "import" "in-ns" "inc"

        "init-proxy" "instance?" "int" "int-array" "integer?"

        "interleave" "intern" "interpose" "into" "into-array"

        "ints" "io!" "isa?" "iterate" "iterator-seq"

        "juxt" "key" "keys" "keyword" "keyword?"

        "last" "lazy-cat" "lazy-seq" "let" "letfn"

        "line-seq" "list" "list*" "list?" "load"

        "load-file" "load-reader" "load-string" "loaded-libs" "locking"

        "long" "long-array" "longs" "loop" "macroexpand"

        "macroexpand-1" "make-array" "make-hierarchy" "map" "mapv" "map?"

        "map-indexed" "mapcat" "max" "max-key" "memfn" "memoize"

        "merge" "merge-with" "meta" "method-sig" "methods"

        "min" "min-key" "mod" "name" "namespace"

        "neg?" "newline" "next" "nfirst" "nil?"

        "nnext" "not" "not-any?" "not-empty" "not-every?"

        "not=" "ns" "ns-aliases" "ns-imports" "ns-interns"

        "ns-map" "ns-name" "ns-publics" "ns-refers" "ns-resolve"

        "ns-unalias" "ns-unmap" "nth" "nthnext" "num"

        "number?" "odd?" "or" "parents" "partial"

        "partition" "partition-all" "partition-by" "pcalls" "peek" "persistent!" "pmap"

        "pop" "pop!" "pop-thread-bindings" "pos?" "pr"

        "pr-str" "prefer-method" "prefers" "primitives-classnames" "print"

        "print-ctor" "print-doc" "print-dup" "print-method" "print-namespace-doc"

        "print-simple" "print-special-doc" "print-str" "printf" "println"

        "println-str" "prn" "prn-str" "promise" "proxy"

        "proxy-call-with-super" "proxy-mappings" "proxy-name" "proxy-super" "push-thread-bindings"

        "pvalues" "quot" "rand" "rand-int" "range"

        "ratio?" "rational?" "rationalize" "re-find" "re-groups"

        "re-matcher" "re-matches" "re-pattern" "re-seq" "read"

        "read-line" "read-string" "reify" "reduce" "reduce-kv" "ref" "ref-history-count"

        "ref-max-history" "ref-min-history" "ref-set" "refer" "refer-clojure"

        "release-pending-sends" "rem" "remove" "remove-method" "remove-ns"

        "repeat" "repeatedly" "replace" "replicate"

        "require" "reset!" "reset-meta!" "resolve" "rest"

        "resultset-seq" "reverse" "reversible?" "rseq" "rsubseq"

        "satisfies?" "second" "select-keys" "send" "send-off" "send-via" "seq"

        "seq?" "seque" "sequence" "sequential?" "set"

        "set-agent-send-executor!" "set-agent-send-off-executor!"

        "set-validator!" "set?" "short" "short-array" "shorts"

        "shutdown-agents" "slurp" "some" "some->" "some->>" "sort" "sort-by"

        "sorted-map" "sorted-map-by" "sorted-set" "sorted-set-by" "sorted?"

        "special-form-anchor" "special-symbol?" "spit" "split-at" "split-with" "str"

        "stream?" "string?" "struct" "struct-map" "subs"

        "subseq" "subvec" "supers" "swap!" "symbol"

        "symbol?" "sync" "syntax-symbol-anchor" "take" "take-last"

        "take-nth" "take-while" "test" "the-ns" "time"

        "to-array" "to-array-2d" "trampoline" "transient" "tree-seq"

        "true?" "type" "unchecked-add" "unchecked-dec" "unchecked-divide"

        "unchecked-inc" "unchecked-multiply" "unchecked-negate" "unchecked-remainder" "unchecked-subtract"

        "underive" "unquote" "unquote-splicing" "update-in" "update-proxy"

        "use" "val" "vals" "var-get" "var-set"

        "var?" "vary-meta" "vec" "vector" "vector?"

        "when" "when-first" "when-let" "when-not" "while"

        "with-bindings" "with-bindings*" "with-in-str" "with-loading-context" "with-local-vars"

        "with-meta" "with-open" "with-out-str" "with-precision"

        "with-redefs" "with-redefs-fn" "xml-seq" "zero?" "zipmap"

        ) t)

         "\\>")

       1 font-lock-builtin-face)

      ;;Other namespaces in clojure.jar

      (,(concat

         "(\\(?:\.*/\\)?"

         (regexp-opt

          '(;; clojure.inspector

        "atom?" "collection-tag" "get-child" "get-child-count" "inspect"

        "inspect-table" "inspect-tree" "is-leaf" "list-model" "list-provider"

        ;; clojure.main

        "load-script" "main" "repl" "repl-caught" "repl-exception"

        "repl-prompt" "repl-read" "skip-if-eol" "skip-whitespace" "with-bindings"

        ;; clojure.set

        "difference" "index" "intersection" "join" "map-invert"

        "project" "rename" "rename-keys" "select" "union"

        ;; clojure.stacktrace

        "e" "print-cause-trace" "print-stack-trace" "print-throwable" "print-trace-element"

        ;; clojure.template

        "do-template" "apply-template"

        ;; clojure.test

        "*initial-report-counters*" "*load-tests*" "*report-counters*" "*stack-trace-depth*" "*test-out*"

        "*testing-contexts*" "*testing-vars*" "are" "assert-any" "assert-expr"

        "assert-predicate" "compose-fixtures" "deftest" "deftest-" "file-position"

        "function?" "get-possibly-unbound-var" "inc-report-counter" "is" "join-fixtures"

        "report" "run-all-tests" "run-tests" "set-test" "successful?"

        "test-all-vars" "test-ns" "test-var" "testing" "testing-contexts-str"

        "testing-vars-str" "try-expr" "use-fixtures" "with-test" "with-test-out"

        ;; clojure.walk

        "keywordize-keys" "macroexpand-all" "postwalk" "postwalk-demo" "postwalk-replace"

        "prewalk" "prewalk-demo" "prewalk-replace" "stringify-keys" "walk"

        ;; clojure.xml

        "*current*" "*sb*" "*stack*" "*state*" "attrs"

        "content" "content-handler" "element" "emit" "emit-element"

        ;; clojure.zip

        "append-child" "branch?" "children" "down" "edit"

        "end?" "insert-child" "insert-left" "insert-right" "left"

        "leftmost" "lefts" "make-node" "next" "node"

        "path" "prev" "remove" "replace" "right"

        "rightmost" "rights" "root" "seq-zip" "up"

        ) t)

         "\\>")

       1 font-lock-builtin-face)

      ;; Constant values (keywords), including as metadata e.g. ^:static

      ("\\<^?:\\(\\sw\\|\\s_\\)+\\(\\>\\|\\_>\\)" 0 font-lock-constant-face)

      ;; Meta type hint #^Type or ^Type

      ("\\(#?^\\)\\(\\(\\sw\\|\\s_\\)+\\)"

       (1 font-lock-preprocessor-face)

       (2 font-lock-type-face))

      ;;Java interop highlighting

      ("\\<\\.-?[a-z][a-zA-Z0-9]*\\>" 0 font-lock-preprocessor-face) ;; .foo .barBaz .qux01 .-flibble .-flibbleWobble

      ("\\<[A-Z][a-zA-Z0-9_]*[a-zA-Z0-9/$_]+\\>" 0 font-lock-preprocessor-face) ;; Foo Bar$Baz Qux_ World_OpenUDP

      ("\\<[a-zA-Z]+\\.[a-zA-Z0-9._]*[A-Z]+[a-zA-Z0-9/.$]*\\>" 0 font-lock-preprocessor-face) ;; Foo/Bar foo.bar.Baz foo.Bar/baz

      ("[a-z]*[A-Z]+[a-z][a-zA-Z0-9$]*\\>" 0 font-lock-preprocessor-face) ;; fooBar

      ("\\<[A-Z][a-zA-Z0-9$]*\\.\\>" 0 font-lock-type-face) ;; Foo. BarBaz. Qux$Quux. Corge9.

      ;; Highlight grouping constructs in regular expressions

      (clojure-mode-font-lock-regexp-groups

       (1 'font-lock-regexp-grouping-construct prepend))))

  "Default expressions to highlight in Clojure mode.")

  "A mode for Clojure"

  "Major mode for editing Clojure code."

(defcustom clojure-font-lock-comment-sexp nil

(defconst clojure-mode-version "5.7.0-snapshot"

  "Set to non-nil in order to enable font-lock of (comment...)

  "The current version of `clojure-mode'.")

forms.  This option is experimental.  Changing this will require a

restart (ie. M-x clojure-mode) of existing clojure mode buffers."

  :type 'boolean

  :group 'clojure

  :safe 'booleanp)

(defcustom clojure-load-command  "(clojure.core/load-file \"%s\")\n"

  "*Format-string for building a Clojure expression to load a file.

This format string should use `%s' to substitute a file name

and should result in a Clojure expression that will command the inferior

Clojure to load that file."

  :type 'string

  :group 'clojure

  :safe 'stringp)

(defcustom clojure-inf-lisp-command "lein repl"

(defface clojure-keyword-face

  "The command used by `inferior-lisp-program'."

  '((t (:inherit font-lock-constant-face)))

  :type 'string

  "Face used to font-lock Clojure keywords (:something)."

  :group 'clojure

  :package-version '(clojure-mode . "3.0.0"))

  :safe 'stringp)

(defface clojure-character-face

  '((t (:inherit font-lock-string-face)))

  "Face used to font-lock Clojure character literals."

  :package-version '(clojure-mode . "3.0.0"))

(defface clojure-interop-method-face

  '((t (:inherit font-lock-preprocessor-face)))

  "Face used to font-lock interop method names (camelCase)."

  :package-version '(clojure-mode . "3.0.0"))

(defcustom clojure-indent-style :always-align

  "Indentation style to use for function forms and macro forms.

There are two cases of interest configured by this variable.

- Case (A) is when at least one function argument is on the same

  line as the function name.

- Case (B) is the opposite (no arguments are on the same line as

  the function name).  Note that the body of macros is not

  affected by this variable, it is always indented by

  `lisp-body-indent' (default 2) spaces.

Note that this variable configures the indentation of function

forms (and function-like macros), it does not affect macros that

already use special indentation rules.

The possible values for this variable are keywords indicating how

to indent function forms.

    `:always-align' - Follow the same rules as `lisp-mode'.  All

    args are vertically aligned with the first arg in case (A),

    and vertically aligned with the function name in case (B).

    For instance:

        (reduce merge

                some-coll)

        (reduce

         merge

         some-coll)

    `:always-indent' - All args are indented like a macro body.

        (reduce merge

          some-coll)

        (reduce

          merge

          some-coll)

    `:align-arguments' - Case (A) is indented like `lisp', and

    case (B) is indented like a macro body.

        (reduce merge

                some-coll)

        (reduce

          merge

          some-coll)"

  :safe #'keywordp

  :type '(choice (const :tag "Same as `lisp-mode'" :always-align)

                 (const :tag "Indent like a macro body" :always-indent)

                 (const :tag "Indent like a macro body unless first arg is on the same line"

                        :align-arguments))

  :package-version '(clojure-mode . "5.2.0"))

(defcustom clojure-defun-style-default-indent nil

(define-obsolete-variable-alias 'clojure-defun-style-default-indent

  "Default indenting of function and macro forms using defun rules unless

  'clojure-indent-style "5.2.0")

otherwise defined via `put-clojure-indent`, `define-clojure-indent`, etc."

  :type 'boolean

  :group 'clojure

  :safe 'booleanp)

  "Set to non-nil to enable backtracking/context sensitive indentation."

  "When non-nil, enable context sensitive indentation."

(defcustom clojure-omit-space-between-tag-and-delimiters (list ?\[ ?\{)

(defcustom clojure-docstring-fill-column fill-column

  "List of opening delimiter characters allowed to appear

  "Value of `fill-column' to use when filling a docstring."

immediately after a reader literal tag with no space, as

  :type 'integer

in :db/id[:db.part/user]"

  :safe 'integerp)

(defcustom clojure-docstring-fill-prefix-width 2

  "Width of `fill-prefix' when filling a docstring.

The default value conforms with the de facto convention for

Clojure docstrings, aligning the second line with the opening

double quotes on the third column."

  :type 'integer

  :safe 'integerp)

(defcustom clojure-omit-space-between-tag-and-delimiters '(?\[ ?\{)

  "Allowed opening delimiter characters after a reader literal tag.

For example, \[ is allowed in :db/id[:db.part/user]."

               (every 'characterp value))))

               (cl-every 'characterp value))))

(defvar clojure-mode-map

(defcustom clojure-build-tool-files '("project.clj" "build.boot" "build.gradle")

  "A list of files, which identify a Clojure project's root.

Out-of-the box `clojure-mode' understands lein, boot and gradle."

  :type '(repeat string)

  :package-version '(clojure-mode . "5.0.0")

  :safe (lambda (value)

          (and (listp value)

               (cl-every 'stringp value))))

(defcustom clojure-refactor-map-prefix (kbd "C-c C-r")

  "Clojure refactor keymap prefix."

  :type 'string

  :package-version '(clojure-mode . "5.6.0"))

(defvar clojure-refactor-map

    (set-keymap-parent map lisp-mode-shared-map)

    (define-key map (kbd "C-t") #'clojure-thread)

    (define-key map (kbd "C-M-x")   'lisp-eval-defun)

    (define-key map (kbd "t") #'clojure-thread)

    (define-key map (kbd "C-x C-e") 'lisp-eval-last-sexp)

    (define-key map (kbd "C-u") #'clojure-unwind)

    (define-key map (kbd "C-c C-e") 'lisp-eval-last-sexp)

    (define-key map (kbd "u") #'clojure-unwind)

    (define-key map (kbd "C-c C-l") 'clojure-load-file)

    (define-key map (kbd "C-f") #'clojure-thread-first-all)

    (define-key map (kbd "C-c C-r") 'lisp-eval-region)

    (define-key map (kbd "f") #'clojure-thread-first-all)

    (define-key map (kbd "C-c C-t") 'clojure-jump-between-tests-and-code)

    (define-key map (kbd "C-l") #'clojure-thread-last-all)

    (define-key map (kbd "C-c C-z") 'clojure-display-inferior-lisp-buffer)

    (define-key map (kbd "l") #'clojure-thread-last-all)

    (define-key map (kbd "C-c M-q") 'clojure-fill-docstring)

    (define-key map (kbd "C-a") #'clojure-unwind-all)

    (define-key map (kbd "C-:") 'clojure-toggle-keyword-string)

    (define-key map (kbd "a") #'clojure-unwind-all)

    (define-key map (kbd "C-p") #'clojure-cycle-privacy)

    (define-key map (kbd "p") #'clojure-cycle-privacy)

    (define-key map (kbd "C-(") #'clojure-convert-collection-to-list)

    (define-key map (kbd "(") #'clojure-convert-collection-to-list)

    (define-key map (kbd "C-'") #'clojure-convert-collection-to-quoted-list)

    (define-key map (kbd "'") #'clojure-convert-collection-to-quoted-list)

    (define-key map (kbd "C-{") #'clojure-convert-collection-to-map)

    (define-key map (kbd "{") #'clojure-convert-collection-to-map)

    (define-key map (kbd "C-[") #'clojure-convert-collection-to-vector)

    (define-key map (kbd "[") #'clojure-convert-collection-to-vector)

    (define-key map (kbd "C-#") #'clojure-convert-collection-to-set)

    (define-key map (kbd "#") #'clojure-convert-collection-to-set)

    (define-key map (kbd "C-i") #'clojure-cycle-if)

    (define-key map (kbd "i") #'clojure-cycle-if)

    (define-key map (kbd "C-w") #'clojure-cycle-when)

    (define-key map (kbd "w") #'clojure-cycle-when)

    (define-key map (kbd "C-o") #'clojure-cycle-not)

    (define-key map (kbd "o") #'clojure-cycle-not)

    (define-key map (kbd "n i") #'clojure-insert-ns-form)

    (define-key map (kbd "n h") #'clojure-insert-ns-form-at-point)

    (define-key map (kbd "n u") #'clojure-update-ns)

    (define-key map (kbd "n s") #'clojure-sort-ns)

    (define-key map (kbd "s i") #'clojure-introduce-let)

    (define-key map (kbd "s m") #'clojure-move-to-let)

    (define-key map (kbd "s f") #'clojure-let-forward-slurp-sexp)

    (define-key map (kbd "s b") #'clojure-let-backward-slurp-sexp)

  "Keymap for Clojure mode.  Inherits from `lisp-mode-shared-map'.")

  "Keymap for Clojure refactoring commands.")

(fset 'clojure-refactor-map clojure-refactor-map)

(easy-menu-define clojure-mode-menu clojure-mode-map

(defvar clojure-mode-map

  "Menu for Clojure mode."

  (let ((map (make-sparse-keymap)))

  '("Clojure"

    (define-key map (kbd "C-:") #'clojure-toggle-keyword-string)

    ["Eval Function Definition" lisp-eval-defun]

    (define-key map (kbd "C-c SPC") #'clojure-align)

    ["Eval Last Sexp" lisp-eval-last-sexp]

    (define-key map clojure-refactor-map-prefix 'clojure-refactor-map)

    ["Eval Region" lisp-eval-region]

    (easy-menu-define clojure-mode-menu map "Clojure Mode Menu"

    "--"

      '("Clojure"

    ["Run Inferior Lisp" clojure-display-inferior-lisp-buffer]

        ["Toggle between string & keyword" clojure-toggle-keyword-string]

    ["Display Inferior Lisp Buffer" clojure-display-inferior-lisp-buffer]

        ["Align expression" clojure-align]

    ["Load File" clojure-load-file]

        ["Cycle privacy" clojure-cycle-privacy]

    "--"

        ["Cycle if, if-not" clojure-cycle-if]

    ["Toggle between string & keyword" clojure-toggle-keyword-string]

        ["Cycle when, when-not" clojure-cycle-when]

    ["Fill Docstring" clojure-fill-docstring]

        ["Cycle not" clojure-cycle-not]

    ["Jump Between Test and Code" clojure-jump-between-tests-and-code]))

        ("ns forms"

         ["Insert ns form at the top" clojure-insert-ns-form]

         ["Insert ns form here" clojure-insert-ns-form-at-point]

         ["Update ns form" clojure-update-ns]

         ["Sort ns form" clojure-sort-ns])

        ("Convert collection"

         ["Convert to list" clojure-convert-collection-to-list]

         ["Convert to quoted list" clojure-convert-collection-to-quoted-list]

         ["Convert to map" clojure-convert-collection-to-map]

         ["Convert to vector" clojure-convert-collection-to-vector]

         ["Convert to set" clojure-convert-collection-to-set])

        ("Refactor -> and ->>"

         ["Thread once more" clojure-thread]

         ["Fully thread a form with ->" clojure-thread-first-all]

         ["Fully thread a form with ->>" clojure-thread-last-all]

         "--"

         ["Unwind once" clojure-unwind]

         ["Fully unwind a threading macro" clojure-unwind-all])

        ("Let expression"

         ["Introduce let" clojure-introduce-let]

         ["Move to let" clojure-move-to-let]

         ["Forward slurp form into let" clojure-let-forward-slurp-sexp]

         ["Backward slurp form into let" clojure-let-backward-slurp-sexp])

        ("Documentation"

         ["View a Clojure guide" clojure-view-guide]

         ["View a Clojure reference section" clojure-view-reference-section]

         ["View the Clojure cheatsheet" clojure-view-cheatsheet]

         ["View the Clojure Grimoire" clojure-view-grimoire]

         ["View the Clojure style guide" clojure-view-style-guide])

        "--"

        ["Report a clojure-mode bug" clojure-mode-report-bug]

        ["Clojure-mode version" clojure-mode-display-version]))

    map)

  "Keymap for Clojure mode.")

    ;; Make hash a usual word character

    (modify-syntax-entry ?@ "'" table)

    (modify-syntax-entry ?# "_ p" table)

    table)

    table))

  "Syntax table for Clojure mode.

Inherits from `emacs-lisp-mode-syntax-table'.")

(defconst clojure--prettify-symbols-alist

  '(("fn"  . ?λ)))

(defvar-local clojure-expected-ns-function nil

  "The function used to determine the expected namespace of a file.

`clojure-mode' ships a basic function named `clojure-expected-ns'

that does basic heuristics to figure this out.

CIDER provides a more complex version which does classpath analysis.")

(defun clojure-mode-display-version ()

  "Display the current `clojure-mode-version' in the minibuffer."

  (interactive)

  (message "clojure-mode (version %s)" clojure-mode-version))

(defvar clojure-prev-l/c-dir/file nil

(defconst clojure-mode-report-bug-url "https://github.com/clojure-emacs/clojure-mode/issues/new"

  "Record last directory and file used in loading or compiling.

  "The URL to report a `clojure-mode' issue.")

This holds a cons cell of the form `(DIRECTORY . FILE)'

describing the last `clojure-load-file' or `clojure-compile-file' command.")

(defvar clojure-test-ns-segment-position -1

(defun clojure-mode-report-bug ()

  "Which segment of the ns is \"test\" inserted in your test name convention.

  "Report a bug in your default browser."

  (interactive)

  (browse-url clojure-mode-report-bug-url))

Customize this depending on your project's conventions. Negative

(defconst clojure-guides-base-url "https://clojure.org/guides/"

numbers count from the end:

  "The base URL for official Clojure guides.")

  leiningen.compile -> leiningen.test.compile (uses 1)

(defconst clojure-guides '(("Getting Started" . "getting_started")

  clojure.http.client -> clojure.http.test.client (uses -1)")

                           ("FAQ" . "faq")

                           ("spec" . "spec")

                           ("Destructuring" . "destructuring")

                           ("Threading Macros" . "threading_macros")

                           ("Comparators" . "comparators")

                           ("Reader Conditionals" . "reader_conditionals"))

  "A list of all official Clojure guides.")

(defconst clojure-mode-version "2.1.0"

(defun clojure-view-guide ()

  "The current version of `clojure-mode'.")

  "Open a Clojure guide in your default browser.

(defun clojure-mode-display-version ()

The command will prompt you to select one of the available guides."

  "Display the current `clojure-mode-version' in the minibuffer."

  (message "clojure-mode (version %s)" clojure-mode-version))

  (let ((guide (completing-read "Select a guide: " (mapcar #'car clojure-guides))))

    (when guide

      (let ((guide-url (concat clojure-guides-base-url (cdr (assoc guide clojure-guides)))))

        (browse-url guide-url)))))

(defconst clojure-reference-base-url "https://clojure.org/reference/"

  "The base URL for the official Clojure reference.")

(defconst clojure-reference-sections '(("The Reader" . "reader")

                                       ("The REPL and main" . "repl_and_main")

                                       ("Evaluation" . "evaluation")

                                       ("Special Forms" . "special_forms")

                                       ("Macros" . "macros")

                                       ("Other Functions" . "other_functions")

                                       ("Data Structures" . "data_structures")

                                       ("Datatypes" . "datatypes")

                                       ("Sequences" . "sequences")

                                       ("Transients" . "transients")

                                       ("Transducers" . "transducers")

                                       ("Multimethods and Hierarchies" . "multimethods")

                                       ("Protocols" . "protocols")

                                       ("Metadata" . "metadata")

                                       ("Namespaces" . "namespaces")

                                       ("Libs" . "libs")

                                       ("Vars and Environments" . "vars")

                                       ("Refs and Transactions" . "refs")

                                       ("Agents" . "agents")

                                       ("Atoms" . "atoms")

                                       ("Reducers" . "reducers")

                                       ("Java Interop" . "java_interop")

                                       ("Compilation and Class Generation" . "compilation")

                                       ("Other Libraries" . "other_libraries")

                                       ("Differences with Lisps" . "lisps")))

;; For compatibility with Emacs < 24, derive conditionally

(defun clojure-view-reference-section ()

(defalias 'clojure-parent-mode

  "Open a Clojure reference section in your default browser.

  (if (fboundp 'prog-mode) 'prog-mode 'fundamental-mode))

The command will prompt you to select one of the available sections."

  (interactive)

  (let ((section (completing-read "Select a reference section: " (mapcar #'car clojure-reference-sections))))

    (when section

      (let ((section-url (concat clojure-reference-base-url (cdr (assoc section clojure-reference-sections)))))

        (browse-url section-url)))))

(defconst clojure-cheatsheet-url "http://clojure.org/api/cheatsheet"

  "The URL of the official Clojure cheatsheet.")

(defun clojure-view-cheatsheet ()

  "Open the Clojure cheatsheet in your default browser."

  (interactive)

  (browse-url clojure-cheatsheet-url))

(defconst clojure-grimoire-url "https://www.conj.io/"

  "The URL of the Grimoire community documentation site.")

(defun clojure-view-grimoire ()

  "Open the Clojure Grimoire in your default browser."

  (interactive)

  (browse-url clojure-grimoire-url))

(defconst clojure-style-guide-url "https://github.com/bbatsov/clojure-style-guide"

  "The URL of the Clojure style guide.")

(defun clojure-view-style-guide ()

  "Open the Clojure style guide in your default browser."

  (interactive)

  (browse-url clojure-style-guide-url))

  "Prevent paredit from inserting unneeded spaces."

  "Prevent paredit from inserting useless spaces.

  (if (derived-mode-p 'clojure-mode)

See `paredit-space-for-delimiter-predicates' for the meaning of

ENDP and DELIM."

  (or endp

      (not (memq delim '(?\" ?{ ?\( )))

      (not (or (derived-mode-p 'clojure-mode)

               (derived-mode-p 'cider-repl-mode)))

        (if (and (or (char-equal delim ?\()

        (cond ((eq (char-after) ?#)

                     (char-equal delim ?\")

               (and (not (bobp))

                     (char-equal delim ?{))

                    (or (char-equal ?w (char-syntax (char-before)))

                 (not endp))

                        (char-equal ?_ (char-syntax (char-before))))))

            (if (char-equal (char-after) ?#)

              ((and (eq delim ?\()

                (and (not (bobp))

                    (eq (char-after) ??)

                     (or (char-equal ?w (char-syntax (char-before)))

                    (eq (char-before) ?#))

                         (char-equal ?_ (char-syntax (char-before)))))

               nil)

              t)

              (t)))))

          t))

    t))

  "Do not insert a space between a reader-literal tag and an

  "Prevent inserting a space after a reader-literal tag?

  opening delimiter in the list

  clojure-omit-space-between-tag-and-delimiters. Allows you to

When a reader-literal tag is followed be an opening delimiter

  write things like #db/id[:db.part/user] without inserting a

listed in `clojure-omit-space-between-tag-and-delimiters', this

  space between the tag and the opening bracket."

function returns t.

This allows you to write things like #db/id[:db.part/user]

without inserting a space between the tag and the opening

bracket.

See `paredit-space-for-delimiter-predicates' for the meaning of

ENDP and DELIMITER."

;;;###autoload

(declare-function paredit-open-curly "ext:paredit")

(define-derived-mode clojure-mode clojure-parent-mode "Clojure"

(declare-function paredit-close-curly "ext:paredit")

  "Major mode for editing Clojure code - similar to Lisp mode.

(declare-function paredit-convolute-sexp "ext:paredit")

Commands:

Delete converts tabs to spaces as it moves back.

(defun clojure--replace-let-bindings-and-indent (orig-fun &rest args)

Blank lines separate paragraphs.  Semicolons start comments.

  "Advise ORIG-FUN to replace let bindings.

\\{clojure-mode-map}

Note that `run-lisp' may be used either to start an inferior Lisp job

Sexps are replace by their bound name if a let form was

or to switch back to an existing one.

convoluted.

Entry to this mode calls the value of `clojure-mode-hook'

ORIG-FUN should be `paredit-convolute-sexp'.

if that value is non-nil."

  (setq-local imenu-create-index-function

ARGS are passed to ORIG-FUN, as with all advice."

              (lambda ()

  (save-excursion

                (imenu--generic-function '((nil clojure-match-next-def 0)))))

    (backward-sexp)

    (when (looking-back clojure--let-regexp)

      (clojure--replace-sexps-with-bindings-and-indent))))

(defun clojure-paredit-setup (&optional keymap)

  "Make \"paredit-mode\" play nice with `clojure-mode'.

If an optional KEYMAP is passed the changes are applied to it,

instead of to `clojure-mode-map'.

Also advice `paredit-convolute-sexp' when used on a let form as drop in

replacement for `cljr-expand-let`."

  (when (>= paredit-version 21)

    (let ((keymap (or keymap clojure-mode-map)))

      (define-key keymap "{" #'paredit-open-curly)

      (define-key keymap "}" #'paredit-close-curly))

    (add-to-list 'paredit-space-for-delimiter-predicates

                 #'clojure-space-for-delimiter-p)

    (add-to-list 'paredit-space-for-delimiter-predicates

                 #'clojure-no-space-after-tag)

    (advice-add 'paredit-convolute-sexp :after #'clojure--replace-let-bindings-and-indent)))

(defun clojure-mode-variables ()

  "Set up initial buffer-local variables for Clojure mode."

  (add-to-list 'imenu-generic-expression '(nil clojure-match-next-def 0))

  (lisp-mode-variables nil)

  (setq-local paragraph-ignore-fill-prefix t)

  (setq-local outline-regexp ";;;\\(;* [^ \t\n]\\)\\|(")

  (setq-local outline-level 'lisp-outline-level)

  (setq-local comment-start ";")

  (setq-local comment-start-skip ";+ *")

  (setq-local comment-add 1) ; default to `;;' in comment-region

  (setq-local comment-column 40)

  (setq-local comment-use-syntax t)

  (setq-local multibyte-syntax-as-symbol t)

  (setq-local electric-pair-skip-whitespace 'chomp)

  (setq-local electric-pair-open-newline-between-pairs nil)

  (setq-local fill-paragraph-function #'clojure-fill-paragraph)

  (setq-local adaptive-fill-function #'clojure-adaptive-fill-function)

  (setq-local normal-auto-fill-function #'clojure-auto-fill-function)

  (setq-local lisp-indent-function 'clojure-indent-function)

  (setq-local indent-line-function #'clojure-indent-line)

  (when (< emacs-major-version 24)

  (setq-local indent-region-function #'clojure-indent-region)

    (setq-local forward-sexp-function 'clojure-forward-sexp))

  (setq-local lisp-indent-function #'clojure-indent-function)

  (setq-local inferior-lisp-program clojure-inf-lisp-command)

  (setq-local clojure-expected-ns-function #'clojure-expected-ns)

  (clojure-mode-font-lock-setup)

If it doesn't, issue a warning if `clojure-verify-major-mode' is

  (setq-local open-paren-in-column-0-is-defun-start nil)

non-nil."

  (add-hook 'paredit-mode-hook

  (when (and clojure-verify-major-mode

            (lambda ()

             (stringp (buffer-file-name)))

              (when (>= paredit-version 21)

    (let* ((case-fold-search t)

                (define-key clojure-mode-map "{" 'paredit-open-curly)

           (problem (cond ((and (string-match "\\.clj\\'" (buffer-file-name))

                (define-key clojure-mode-map "}" 'paredit-close-curly)

                                (not (eq major-mode 'clojure-mode)))

                (add-to-list 'paredit-space-for-delimiter-predicates

                           'clojure-mode)

                             'clojure-space-for-delimiter-p)

                          ((and (string-match "\\.cljs\\'" (buffer-file-name))

                (add-to-list 'paredit-space-for-delimiter-predicates

                                (not (eq major-mode 'clojurescript-mode)))

                             'clojure-no-space-after-tag)))))

                           'clojurescript-mode)

                          ((and (string-match "\\.cljc\\'" (buffer-file-name))

(defun clojure-display-inferior-lisp-buffer ()

                                (not (eq major-mode 'clojurec-mode)))

  "Display a buffer bound to `inferior-lisp-buffer'."

                           'clojurec-mode)

  (interactive)

                          ((and (string-match "\\.cljx\\'" (buffer-file-name))

  (if (and inferior-lisp-buffer (get-buffer inferior-lisp-buffer))

                                (not (eq major-mode 'clojurex-mode)))

      (pop-to-buffer inferior-lisp-buffer t)

                           'clojurex-mode))))

      (run-lisp inferior-lisp-program)))

      (when problem

        (message "[WARNING] %s activated `%s' instead of `%s' in this buffer.

(defun clojure-load-file (file-name)

This could cause problems.

  "Load a Clojure file FILE-NAME into the inferior Clojure process."

\(See `clojure-verify-major-mode' to disable this message.)"

  (interactive (comint-get-source "Load Clojure file: "

                 (if (eq major-mode real-this-command)

                                  clojure-prev-l/c-dir/file

                     "You have"

                                  '(clojure-mode) t))

                   "Something in your configuration")

  (comint-check-source file-name) ; Check to see if buffer needs saved.

                 major-mode

  (setq clojure-prev-l/c-dir/file (cons (file-name-directory file-name)

                 problem)))))

                                        (file-name-nondirectory file-name)))

  (comint-send-string (inferior-lisp-proc)

(add-hook 'clojure-mode-hook #'clojure--check-wrong-major-mode)

                      (format clojure-load-command file-name))

  (switch-to-lisp t))

(defsubst clojure-in-docstring-p ()

  "Check whether point is in a docstring."

  (let ((ppss (syntax-ppss)))

    ;; are we in a string?

    (when (nth 3 ppss)

      ;; check font lock at the start of the string

      (eq (get-text-property (nth 8 ppss) 'face)

          'font-lock-doc-face))))

(defsubst clojure-docstring-fill-prefix ()

  "The prefix string used by `clojure-fill-paragraph'.

It is simply `clojure-docstring-fill-prefix-width' number of spaces."

  (make-string clojure-docstring-fill-prefix-width ? ))

(defun clojure-adaptive-fill-function ()

  "Clojure adaptive fill function.

This only takes care of filling docstring correctly."

  (when (clojure-in-docstring-p)

    (clojure-docstring-fill-prefix)))

(defun clojure-fill-paragraph (&optional justify)

  "Like `fill-paragraph', but can handle Clojure docstrings.

If JUSTIFY is non-nil, justify as well as fill the paragraph."

  (if (clojure-in-docstring-p)

      (let ((paragraph-start

             (concat paragraph-start

                     "\\|\\s-*\\([(:\"[]\\|~@\\|`(\\|#'(\\)"))

            (paragraph-separate

             (concat paragraph-separate "\\|\\s-*\".*[,\\.]$"))

            (fill-column (or clojure-docstring-fill-column fill-column))

            (fill-prefix (clojure-docstring-fill-prefix)))

        ;; we are in a string and string start pos (8th element) is non-nil

        (let* ((beg-doc (nth 8 (syntax-ppss)))

               (end-doc (save-excursion

                          (goto-char beg-doc)

                          (or (ignore-errors (forward-sexp) (point))

                              (point-max)))))

          (save-restriction

            (narrow-to-region beg-doc end-doc)

            (fill-paragraph justify))))

    (let ((paragraph-start (concat paragraph-start

                                   "\\|\\s-*\\([(:\"[]\\|`(\\|#'(\\)"))

          (paragraph-separate

           (concat paragraph-separate "\\|\\s-*\".*[,\\.[]$")))

      (or (fill-comment-paragraph justify)

          (fill-paragraph justify))

      ;; Always return `t'

      t)))

(defun clojure-auto-fill-function ()

  "Clojure auto-fill function."

  ;; Check if auto-filling is meaningful.

  (let ((fc (current-fill-column)))

    (when (and fc (> (current-column) fc))

      (let ((fill-column (if (clojure-in-docstring-p)

                             clojure-docstring-fill-column

                           fill-column))

            (fill-prefix (clojure-adaptive-fill-function)))

        (do-auto-fill)))))

  "Scans the buffer backwards for the next top-level definition.

  "Scans the buffer backwards for the next \"top-level\" definition.

  (when (re-search-backward "^(def\sw*" nil t)

  ;; we have to take into account namespace-definition forms

  ;; e.g. s/defn

  (when (re-search-backward "^[ \t]*(\\([a-z0-9.-]+/\\)?\\(def\\sw*\\)" nil t)

          (forward-sexp)

          (ignore-errors

          (or (if (char-equal ?[ (char-after (point)))

            (forward-sexp))

                              (backward-sexp))

          (or (when (char-equal ?\[ (char-after (point)))

                  (if (char-equal ?) (char-after (point)))

                (backward-sexp))

              (when (char-equal ?\) (char-after (point)))

          (destructuring-bind (def-beg . def-end) (bounds-of-thing-at-point 'sexp)

          (cl-destructuring-bind (def-beg . def-end) (bounds-of-thing-at-point 'sexp)

(defun clojure-mode-font-lock-setup ()

(eval-and-compile

  (defconst clojure--sym-forbidden-rest-chars "][\";\'@\\^`~\(\)\{\}\\,\s\t\n\r"

    "A list of chars that a Clojure symbol cannot contain.

See definition of 'macros': URL `http://git.io/vRGLD'.")

  (defconst clojure--sym-forbidden-1st-chars (concat clojure--sym-forbidden-rest-chars "0-9:")

    "A list of chars that a Clojure symbol cannot start with.

See the for-loop: URL `http://git.io/vRGTj' lines: URL

`http://git.io/vRGIh', URL `http://git.io/vRGLE' and value

definition of 'macros': URL `http://git.io/vRGLD'.")

  (defconst clojure--sym-regexp

    (concat "[^" clojure--sym-forbidden-1st-chars "][^" clojure--sym-forbidden-rest-chars "]*")

    "A regexp matching a Clojure symbol or namespace alias.

Matches the rule `clojure--sym-forbidden-1st-chars' followed by

any number of matches of `clojure--sym-forbidden-rest-chars'."))

(defconst clojure-font-lock-keywords

  (eval-when-compile

    `( ;; Top-level variable definition

      (,(concat "(\\(?:clojure.core/\\)?\\("

                (regexp-opt '("def" "defonce"))

                ;; variable declarations

                "\\)\\>"

                ;; Any whitespace

                "[ \r\n\t]*"

                ;; Possibly type or metadata

                "\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"

                "\\(\\sw+\\)?")

       (1 font-lock-keyword-face)

       (2 font-lock-variable-name-face nil t))

      ;; Type definition

      (,(concat "(\\(?:clojure.core/\\)?\\("

                (regexp-opt '("defstruct" "deftype" "defprotocol"

                              "defrecord"))

                ;; type declarations

                "\\)\\>"

                ;; Any whitespace

                "[ \r\n\t]*"

                ;; Possibly type or metadata

                "\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"

                "\\(\\sw+\\)?")

       (1 font-lock-keyword-face)

       (2 font-lock-type-face nil t))

      ;; Function definition (anything that starts with def and is not

      ;; listed above)

      (,(concat "(\\(?:" clojure--sym-regexp "/\\)?"

                "\\(def[^ \r\n\t]*\\)"

                ;; Function declarations

                "\\>"

                ;; Any whitespace

                "[ \r\n\t]*"

                ;; Possibly type or metadata

                "\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"

                "\\(\\sw+\\)?")

       (1 font-lock-keyword-face)

       (2 font-lock-function-name-face nil t))

      ;; (fn name? args ...)

      (,(concat "(\\(?:clojure.core/\\)?\\(fn\\)[ \t]+"

                ;; Possibly type

                "\\(?:#?^\\sw+[ \t]*\\)?"

                ;; Possibly name

                "\\(\\sw+\\)?" )

       (1 font-lock-keyword-face)

       (2 font-lock-function-name-face nil t))

      ;; lambda arguments - %, %&, %1, %2, etc

      ("\\<%[&1-9]?" (0 font-lock-variable-name-face))

      ;; Special forms

      (,(concat

         "("

         (regexp-opt

          '("def" "do" "if" "let" "let*" "var" "fn" "fn*" "loop" "loop*"

            "recur" "throw" "try" "catch" "finally"

            "set!" "new" "."

            "monitor-enter" "monitor-exit" "quote") t)

         "\\>")

       1 font-lock-keyword-face)

      ;; Built-in binding and flow of control forms

      (,(concat

         "(\\(?:clojure.core/\\)?"

         (regexp-opt

          '("letfn" "case" "cond" "cond->" "cond->>" "condp"

            "for" "when" "when-not" "when-let" "when-first" "when-some"

            "if-let" "if-not" "if-some"

            ".." "->" "->>" "as->" "doto" "and" "or"

            "dosync" "doseq" "dotimes" "dorun" "doall"

            "ns" "in-ns"

            "with-open" "with-local-vars" "binding"

            "with-redefs" "with-redefs-fn"

            "declare") t)

         "\\>")

       1 font-lock-keyword-face)

      ;; Macros similar to let, when, and while

      (,(rx symbol-start

            (or "let" "when" "while") "-"

            (1+ (or (syntax word) (syntax symbol)))

            symbol-end)

       0 font-lock-keyword-face)

      (,(concat

         "\\<"

         (regexp-opt

          '("*1" "*2" "*3" "*agent*"

            "*allow-unresolved-vars*" "*assert*" "*clojure-version*"

            "*command-line-args*" "*compile-files*"

            "*compile-path*" "*data-readers*" "*default-data-reader-fn*"

            "*e" "*err*" "*file*" "*flush-on-newline*"

            "*in*" "*macro-meta*" "*math-context*" "*ns*" "*out*"

            "*print-dup*" "*print-length*" "*print-level*"

            "*print-meta*" "*print-readably*"

            "*read-eval*" "*source-path*"

            "*unchecked-math*"

            "*use-context-classloader*" "*warn-on-reflection*")

          t)

         "\\>")

       0 font-lock-builtin-face)

      ;; Dynamic variables - *something* or @*something*

      ("\\(?:\\<\\|/\\)@?\\(\\*[a-z-]*\\*\\)\\>" 1 font-lock-variable-name-face)

      ;; Global constants - nil, true, false

      (,(concat

         "\\<"

         (regexp-opt

          '("true" "false" "nil") t)

         "\\>")

       0 font-lock-constant-face)

      ;; Character literals - \1, \a, \newline, \u0000

      ("\\\\\\([[:punct:]]\\|[a-z0-9]+\\>\\)" 0 'clojure-character-face)

      ;; foo/ Foo/ @Foo/ /FooBar

      (,(concat "\\(?:\\<:?\\|\\.\\)@?\\(" clojure--sym-regexp "\\)\\(/\\)")

       (1 font-lock-type-face) (2 'default))

      ;; Constant values (keywords), including as metadata e.g. ^:static

      ("\\<^?\\(:\\(\\sw\\|\\s_\\)+\\(\\>\\|\\_>\\)\\)" 1 'clojure-keyword-face append)

      ;; Java interop highlighting

      ;; CONST SOME_CONST (optionally prefixed by /)

      ("\\(?:\\<\\|/\\)\\([A-Z]+\\|\\([A-Z]+_[A-Z1-9_]+\\)\\)\\>" 1 font-lock-constant-face)

      ;; .foo .barBaz .qux01 .-flibble .-flibbleWobble

      ("\\<\\.-?[a-z][a-zA-Z0-9]*\\>" 0 'clojure-interop-method-face)

      ;; Foo Bar$Baz Qux_ World_OpenUDP Foo. Babylon15.

      ("\\(?:\\<\\|\\.\\|/\\|#?^\\)\\([A-Z][a-zA-Z0-9_]*[a-zA-Z0-9$_]+\\.?\\>\\)" 1 font-lock-type-face)

      ;; foo.bar.baz

      ("\\<^?\\([a-z][a-z0-9_-]+\\.\\([a-z][a-z0-9_-]*\\.?\\)+\\)" 1 font-lock-type-face)

      ;; (ns namespace) - special handling for single segment namespaces

      (,(concat "(\\<ns\\>[ \r\n\t]*"

                ;; Possibly metadata

                "\\(?:\\^?{[^}]+}[ \r\n\t]*\\)*"

                ;; namespace

                "\\([a-z0-9-]+\\)")

       (1 font-lock-type-face nil t))

      ;; fooBar

      ("\\(?:\\<\\|/\\)\\([a-z]+[A-Z]+[a-zA-Z0-9$]*\\>\\)" 1 'clojure-interop-method-face)

      ;; #_ and (comment ...) macros.

      (clojure--search-comment-macro 1 font-lock-comment-face t)

      ;; Highlight `code` marks, just like `elisp'.

      (,(rx "`" (group-n 1 (optional "#'")

                         (+ (or (syntax symbol) (syntax word)))) "`")

       (1 'font-lock-constant-face prepend))

      ;; Highlight escaped characters in strings.

      (clojure-font-lock-escaped-chars 0 'bold prepend)

      ;; Highlight grouping constructs in regular expressions

      (clojure-font-lock-regexp-groups

       (1 'font-lock-regexp-grouping-construct prepend))))

  "Default expressions to highlight in Clojure mode.")

(defun clojure-font-lock-syntactic-face-function (state)

  "Find and highlight text with a Clojure-friendly syntax table.

This function is passed to `font-lock-syntactic-face-function',

which is called with a single parameter, STATE (which is, in

turn, returned by `parse-partial-sexp' at the beginning of the

highlighted region)."

  (if (nth 3 state)

      ;; This might be a (doc)string or a |...| symbol.

      (let ((startpos (nth 8 state)))

        (if (eq (char-after startpos) ?|)

            ;; This is not a string, but a |...| symbol.

            nil

          (let* ((listbeg (nth 1 state))

                 (firstsym (and listbeg

                                (save-excursion

                                  (goto-char listbeg)

                                  (and (looking-at "([ \t\n]*\\(\\(\\sw\\|\\s_\\)+\\)")

                                       (match-string 1)))))

                 (docelt (and firstsym

                              (function-get (intern-soft firstsym)

                                            lisp-doc-string-elt-property))))

            (if (and docelt

                     ;; It's a string in a form that can have a docstring.

                     ;; Check whether it's in docstring position.

                     (save-excursion

                       (when (functionp docelt)

                         (goto-char (match-end 1))

                         (setq docelt (funcall docelt)))

                       (goto-char listbeg)

                       (forward-char 1)

                       (ignore-errors

                         (while (and (> docelt 0) (< (point) startpos)

                                     (progn (forward-sexp 1) t))

                           ;; ignore metadata and type hints

                           (unless (looking-at "[ \n\t]*\\(\\^[A-Z:].+\\|\\^?{.+\\)")

                             (setq docelt (1- docelt)))))

                       (and (zerop docelt) (<= (point) startpos)

                            (progn (forward-comment (point-max)) t)

                            (= (point) (nth 8 state)))))

                font-lock-doc-face

              font-lock-string-face))))

    font-lock-comment-face))

(defun clojure-font-lock-setup ()

               'clojure-font-lock-extend-region-def t)

               #'clojure-font-lock-extend-region-def t)

  (when clojure-font-lock-comment-sexp

    (add-to-list 'font-lock-extend-region-functions

                 'clojure-font-lock-extend-region-comment t)

    (make-local-variable 'clojure-font-lock-keywords)

    (add-to-list 'clojure-font-lock-keywords

                 'clojure-font-lock-mark-comment t)

    (setq-local open-paren-in-column-0-is-defun-start nil))

          (("+-*/.<>=!?$%_&~^:@" . "w")) ; syntax alist

          (("+-*/.<>=!?$%_&:" . "w")) ; syntax alist

           . lisp-font-lock-syntactic-face-function))))

           . clojure-font-lock-syntactic-face-function))))

  "Find the position range between the top-most def* and the

  "Range between the top-most def* and the fourth element after POINT.

fourth element afterwards using POINT.  Note that this means there's no

Note that this means that there is no guarantee of proper font

guarantee of proper font locking in def* forms that are not at

locking in def* forms that are not at top level."

top level."

  (condition-case nil

  (ignore-errors

      (beginning-of-defun)

    (beginning-of-defun))

    (error nil))

      (condition-case nil

      (ignore-errors

          (progn

        ;; move forward as much as possible until failure (or success)

            ;; move forward as much as possible until failure (or success)

        (forward-char)

            (forward-char)

        (dotimes (_ 4)

            (dotimes (i 4)

          (forward-sexp)))

              (forward-sexp)))

        (error nil))

  "Move fontification boundaries to always include the first four

  "Set region boundaries to include the first four elements of def* forms."

elements of a def* forms."

        (destructuring-bind (def-beg . def-end) def

        (cl-destructuring-bind (def-beg . def-end) def

        (destructuring-bind (def-beg . def-end) def

        (cl-destructuring-bind (def-beg . def-end) def

(defun clojure-mode-font-lock-regexp-groups (bound)

(defun clojure--font-locked-as-string-p (&optional regexp)

  "Highlight grouping constructs in regular expression.

  "Non-nil if the char before point is font-locked as a string.

If REGEXP is non-nil, also check whether current string is

BOUND denotes the maximum number of characters (relative to the point) to check."

preceeded by a #."

  (catch 'found

  (let ((face (get-text-property (1- (point)) 'face)))

    (while (re-search-forward (concat

    (and (or (and (listp face)

                               ;; A group may start using several alternatives:

                  (memq 'font-lock-string-face face))

                               "\\(\\(?:"

             (eq 'font-lock-string-face face))

                               ;; 1. (? special groups

         (or (clojure-string-start t)

                               "(\\?\\(?:"

             (unless regexp

                               ;; a) non-capturing group (?:X)

               (clojure-string-start nil))))))

                               ;; b) independent non-capturing group (?>X)

                               ;; c) zero-width positive lookahead (?=X)

(defun clojure-font-lock-escaped-chars (bound)

                               ;; d) zero-width negative lookahead (?!X)

  "Highlight \escaped chars in strings.

                               "[:=!>]\\|"

BOUND denotes a buffer position to limit the search."

                               ;; e) zero-width positive lookbehind (?<=X)

  (let ((found nil))

                               ;; f) zero-width negative lookbehind (?<!X)

    (while (and (not found)

                               "<[=!]\\|"

                (re-search-forward "\\\\." bound t))

                               ;; g) named capturing group (?<name>X)

                               "<[[:alnum:]]+>"

                               "\\)\\|" ;; end of special groups

                               ;; 2. normal capturing groups (

                               ;; 3. we also highlight alternative

                               ;; separarators |, and closing parens )

                               "[|()]"

                               "\\)\\)") bound t)

      (let ((face (get-text-property (1- (point)) 'face)))

        (when (and (or (and (listp face)

                            (memq 'font-lock-string-face face))

                       (eq 'font-lock-string-face face))

                   (clojure-string-start t))

          (throw 'found t))))))

(defun clojure-find-block-comment-start (limit)

  "Search for (comment...) or #_ style block comments.

Places point at the beginning of the expression.

LIMIT denotes the maximum number of characters (relative to the point) to check."

  (let ((pos (re-search-forward "\\((comment\\>\\|#_\\)" limit t)))

    (when pos

      (forward-char (- (length (match-string 1))))

      pos)))

(defun clojure-font-lock-extend-region-comment ()

      (setq found (clojure--font-locked-as-string-p)))

  "Move fontification boundaries to always contain entire (comment ..) and #_ sexp.

    found))

Does not work if you have a  whitespace between ( and comment, but that is omitted to make

this run faster."

  (let ((changed nil))

    (goto-char font-lock-beg)

    (condition-case nil (beginning-of-defun) (error nil))

    (let ((pos (clojure-find-block-comment-start font-lock-end)))

      (when pos

        (when (< (point) font-lock-beg)

          (setq font-lock-beg (point)

                changed t))

        (condition-case nil (forward-sexp) (error nil))

        (when (> (point) font-lock-end)

          (setq font-lock-end (point)

                changed t))))

    changed))

(defun clojure-font-lock-mark-comment (limit)

(defun clojure-font-lock-regexp-groups (bound)

  "Mark all (comment ..) and #_ forms with `font-lock-comment-face'.

  "Highlight grouping constructs in regular expression.

LIMIT denotes the maximum number of characters (relative to the point) to check."

BOUND denotes the maximum number of characters (relative to the

  (let (pos)

point) to check."

    (while (and (< (point) limit)

  (let ((found nil))

                (setq pos (clojure-find-block-comment-start limit)))

    (while (and (not found)

      (when pos

                (re-search-forward (eval-when-compile

        (condition-case nil

                                     (concat

            (add-text-properties (point)

                                      ;; A group may start using several alternatives:

                                 (progn

                                      "\\(\\(?:"

                                   (forward-sexp)

                                      ;; 1. (? special groups

                                   (point))

                                      "(\\?\\(?:"

                                 '(face font-lock-comment-face multiline t))

                                      ;; a) non-capturing group (?:X)

          (error (forward-char 8))))))

                                      ;; b) independent non-capturing group (?>X)

  nil)

                                      ;; c) zero-width positive lookahead (?=X)

                                      ;; d) zero-width negative lookahead (?!X)

                                      "[:=!>]\\|"

                                      ;; e) zero-width positive lookbehind (?<=X)

                                      ;; f) zero-width negative lookbehind (?<!X)

                                      "<[=!]\\|"

                                      ;; g) named capturing group (?<name>X)

                                      "<[[:alnum:]]+>"

                                      "\\)\\|" ;; end of special groups

                                      ;; 2. normal capturing groups (

                                      ;; 3. we also highlight alternative

                                      ;; separarators |, and closing parens )

                                      "[|()]"

                                      "\\)\\)"))

                                   bound t))

      (setq found (clojure--font-locked-as-string-p 'regexp)))

    found))

;;; Vertical alignment

(defcustom clojure-align-forms-automatically nil

(defun clojure-forward-sexp (n)

  "If non-nil, vertically align some forms automatically.

  "Treat record literals like #user.Foo[1] and #user.Foo{:size 1}

Automatically means it is done as part of indenting code.  This

as a single sexp so that slime will send them properly. Arguably

applies to binding forms (`clojure-align-binding-forms'), to cond

this behavior is unintuitive for the user pressing (eg) C-M-f

forms (`clojure-align-cond-forms') and to map literals.  For

himself, but since these are single objects I think it's right."

instance, selecting a map a hitting \\<clojure-mode-map>`\\[indent-for-tab-command]'

  (let ((dir (if (> n 0) 1 -1))

will align the values like this:

        (forward-sexp-function nil)) ; force the built-in version

    {:some-key 10

    (while (not (zerop n))

     :key2     20}"

      (forward-sexp dir)

  :package-version '(clojure-mode . "5.1")

      (when (save-excursion ; move back to see if we're in a record literal

  :safe #'booleanp

              (and

  :type 'boolean)

               (condition-case nil

                   (progn (backward-sexp) 't)

(defcustom clojure-align-binding-forms

                 ('scan-error nil))

  '("let" "when-let" "when-some" "if-let" "if-some" "binding" "loop"

               (looking-at "#\\w")))

    "doseq" "for" "with-open" "with-local-vars" "with-redefs")

        (forward-sexp dir)) ; if so, jump over it

  "List of strings matching forms that have binding forms."

      (setq n (- n dir)))))

  :package-version '(clojure-mode . "5.1")

  :safe #'listp

  :type '(repeat string))

(defcustom clojure-align-cond-forms '("condp" "cond" "cond->" "cond->>" "case" "are")

  "List of strings identifying cond-like forms."

  :package-version '(clojure-mode . "5.1")

  :safe #'listp

  :type '(repeat string))

(defun clojure--position-for-alignment ()

  "Non-nil if the sexp around point should be automatically aligned.

This function expects to be called immediately after an

open-brace or after the function symbol in a function call.

First check if the sexp around point is a map literal, or is a

call to one of the vars listed in `clojure-align-cond-forms'.  If

it isn't, return nil.  If it is, return non-nil and place point

immediately before the forms that should be aligned.

For instance, in a map literal point is left immediately before

the first key; while, in a let-binding, point is left inside the

binding vector and immediately before the first binding

construct."

  ;; Are we in a map?

  (or (and (eq (char-before) ?{)

           (not (eq (char-before (1- (point))) ?\#)))

      ;; Are we in a cond form?

      (let* ((fun    (car (member (thing-at-point 'symbol) clojure-align-cond-forms)))

             (method (and fun (clojure--get-indent-method fun)))

             ;; The number of special arguments in the cond form is

             ;; the number of sexps we skip before aligning.

             (skip   (cond ((numberp method) method)

                           ((null method) 0)

                           ((sequencep method) (elt method 0)))))

        (when (and fun (numberp skip))

          (clojure-forward-logical-sexp skip)

          (comment-forward (point-max))

          fun)) ; Return non-nil (the var name).

      ;; Are we in a let-like form?

      (when (member (thing-at-point 'symbol)

                    clojure-align-binding-forms)

        ;; Position inside the binding vector.

        (clojure-forward-logical-sexp)

        (backward-sexp)

        (when (eq (char-after) ?\[)

          (forward-char 1)

          (comment-forward (point-max))

          ;; Return non-nil.

          t))))

(defun clojure--find-sexp-to-align (end)

  "Non-nil if there's a sexp ahead to be aligned before END.

Place point as in `clojure--position-for-alignment'."

  ;; Look for a relevant sexp.

  (let ((found))

    (while (and (not found)

                (search-forward-regexp

                 (concat "{\\|(" (regexp-opt

                                  (append clojure-align-binding-forms

                                          clojure-align-cond-forms)

                                  'symbols))

                 end 'noerror))

      (let ((ppss (syntax-ppss)))

        ;; If we're in a string or comment.

        (unless (or (elt ppss 3)

                    (elt ppss 4))

          ;; Only stop looking if we successfully position

          ;; the point.

          (setq found (clojure--position-for-alignment)))))

    found))

(defun clojure--search-whitespace-after-next-sexp (&optional bound _noerror)

  "Move point after all whitespace after the next sexp.

Set the match data group 1 to be this region of whitespace and

return point.

BOUND is bounds the whitespace search."

  (unwind-protect

      (ignore-errors

        (clojure-forward-logical-sexp 1)

        (search-forward-regexp "\\([,\s\t]*\\)" bound)

        (pcase (syntax-after (point))

          ;; End-of-line, try again on next line.

          (`(12) (clojure--search-whitespace-after-next-sexp bound))

          ;; Closing paren, stop here.

          (`(5 . ,_) nil)

          ;; Anything else is something to align.

          (_ (point))))

    (when (and bound (> (point) bound))

      (goto-char bound))))

(defun clojure-align (beg end)

  "Vertically align the contents of the sexp around point.

If region is active, align it.  Otherwise, align everything in the

current \"top-level\" sexp.

When called from lisp code align everything between BEG and END."

  (interactive (if (use-region-p)

                   (list (region-beginning) (region-end))

                 (save-excursion

                   (let ((end (progn (end-of-defun)

                                     (point))))

                     (clojure-backward-logical-sexp)

                     (list (point) end)))))

  (setq end (copy-marker end))

  (save-excursion

    (goto-char beg)

    (while (clojure--find-sexp-to-align end)

      (let ((sexp-end (save-excursion

                        (backward-up-list)

                        (forward-sexp 1)

                        (point-marker)))

            (clojure-align-forms-automatically nil)

            (count 1))

        ;; For some bizarre reason, we need to `align-region' once for each

        ;; group.

        (save-excursion

          (while (search-forward-regexp "^ *\n" sexp-end 'noerror)

            (cl-incf count)))

        (dotimes (_ count)

          (align-region (point) sexp-end nil

                        '((clojure-align (regexp . clojure--search-whitespace-after-next-sexp)

                                         (group . 1)

                                         (separate . "^ *$")

                                         (repeat . t)))

                        nil))

        ;; Reindent after aligning because of #360.

        (indent-region (point) sexp-end)))))

;;; Indentation

(defun clojure-indent-region (beg end)

  "Like `indent-region', but also maybe align forms.

Forms between BEG and END are aligned according to

`clojure-align-forms-automatically'."

  (prog1 (let ((indent-region-function nil))

           (indent-region beg end))

    (when clojure-align-forms-automatically

      (condition-case nil

          (clojure-align beg end)

        (scan-error nil)))))

  "This function is the normal value of the variable `lisp-indent-function'.

  "When indenting a line within a function call, indent properly.

It is used when indenting a line within a function call, to see if the

called function says anything special about how to indent the line.