Make loading faster by eliminating require blocks

lisp/langs/icejam-lang-clang.el

@@ -2,8 +2,6 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
-
 (declare-function column-enforce-n "column-enforce-mode" (number))
 
 (defun icejam-lang-activate-clang-mode ()

lisp/langs/icejam-lang-clojure.el

@@ -2,16 +2,14 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
-(require 'icejam-transient)
-
 (declare-function column-enforce-n "column-enforce-mode" (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
 
 (use-package clojure-mode :defer t :ensure t)
 
 (use-package cider
   :requires clojure-mode
-  :commands cider-jack-in
+  :commands (cider-mode cider-jack-in)
   :defer t
   :ensure t
   :config (setq cider-annotate-completion-function t))

lisp/langs/icejam-lang-dart.el

@@ -1,8 +1,7 @@
 ;;; dart -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
-(require 'icejam-prog-mode)
+(declare-function lsp 'lsp-mode)
 
 (use-package dart-mode :ensure t :defer t)
 (use-package lsp-dart :defer t :ensure t :requires (dart-mode lsp))

lisp/langs/icejam-lang-dhall.el

@@ -1,9 +1,7 @@
 ;;; dhall -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
+(declare-function lsp 'lsp-mode)
 
 (use-package dhall-mode :ensure t :defer t :requires (lsp))
 

lisp/langs/icejam-lang-elisp.el

@@ -1,13 +1,13 @@
 ;;; languages/elisp -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-(require 'icejam-prog-mode)
-(require 'icejam-transient)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-elisp-capfs 'icejam-complete-at-point)
+(declare-function icejam-set-indent 'icejam-prog-mode)
 
-(declare-function column-enforce-n "column-enforce-mode" (number))
 (add-to-list 'auto-mode-alist '("/Eask\\'" . emacs-lisp-mode))
 
-(use-package lispy :ensure t :defer t)
+(use-package lispy :ensure t :defer t :commands (lispy-mode))
 
 (defun icejam-activate-emacs-lisp-mode ()
   "Goodies for editing Emacs files."
@@ -15,13 +15,7 @@
   (icejam-set-indent 2) ;; Default indentation of 2 characters
   (column-enforce-n 80) ;; Use 80 char limit.
   (lispy-mode t)        ;; Modal editing for Lisp
-
-  (setq-local completion-at-point-functions
-              (list (cape-capf-super #'elisp-completion-at-point
-                                     #'yasnippet-capf)
-                    #'cape-dabbrev
-                    #'cape-file
-                    #'cape-elisp-symbol)))
+  (icejam-set-elisp-capfs))
 
 (add-hook 'emacs-lisp-mode-hook 'icejam-activate-emacs-lisp-mode)
 (add-hook 'ielm-mode-hook 'icejam-set-elisp-capfs)

lisp/langs/icejam-lang-elixir.el

@@ -2,16 +2,22 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
-(require 'icejam-flycheck)
-(require 'icejam-transient)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function -> 'dash)
+(declare-function lsp 'lsp-mode)
+(declare-function yas--table-get-create 'yasnippet)
+(declare-function yas--remove-template-by-uuid 'yasnippet)
 
-(declare-function lsp "lsp-mode" nil)
-(declare-function column-enforce-n "column-enforce-mode" (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
+(eval-when-compile (defvar icejam-language-transient-alist))
 
 ;; Only load the elixir-format from elixir mode.
 (use-package elixir-format :defer t
-  :ensure (:type git :host github :repo "elixir-editors/emacs-elixir" :files ("elixir-format.el")))
+  :ensure (:type git
+                 :host github
+                 :repo "elixir-editors/emacs-elixir"
+                 :files ("elixir-format.el")))
 
 (use-package elixir-ts-mode :ensure t :defer t :after (elixir-format lsp-mode lsp-ui))
 
@@ -21,12 +27,12 @@
       (concat (propertize "Code actions for " 'face 'transient-heading)
               (propertize (format "%s" major-mode) 'face 'transient-key)
               (propertize ":\n" 'face 'transient-heading)))
-    ("m" "LSP iMenu"                           lsp-ui-imenu)
-    ("r" "Reload buffer"                       icejam-revert-buffer-no-confirm)
+    ("m" "LSP iMenu" lsp-ui-imenu)
+    ("r" "Reload buffer" icejam-revert-buffer-no-confirm)
+    ("e" "Show errors" flymake-show-buffer-diagnostics)
     ("f" "Format buffer with Elixir formatter" elixir-format)
-    ("e" "Show errors"                         flymake-show-buffer-diagnostics)]]
-  [""
-   ("q" "Quit"                                 keyboard-quit)])
+
+    ("q" "Quit" keyboard-quit)]])
 
 (defun icejam-delete-elixir-snippets ()
   "This function deletes Elixir snippets I don't use."

lisp/langs/icejam-lang-erlang.el

@@ -2,11 +2,10 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
-
-(declare-function lsp "lsp-mode" nil)
-(declare-function column-enforce-n "column-enforce-mode" (number))
+(declare-function lsp 'lsp-mode)
+(declare-function column-enforce-n 'column-enforce-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package erlang
   :defer t
@@ -14,6 +13,7 @@
   :after (lsp lsp-ui))
 
 (defun icejam-activate-erlang-mode ()
+  "Start Erlang related editing process."
   (icejam-set-indent 4)
   (column-enforce-n 80)
 

lisp/langs/icejam-lang-fsharp.el

@@ -10,8 +10,10 @@
 
 ;;; Code:
 
-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
+(declare-function lsp-deferred 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package fsharp-mode
   :requires (lsp-mode lsp-ui)

lisp/langs/icejam-lang-gleam.el

@@ -9,9 +9,10 @@
 ;; Gleam language support
 
 ;;; Code:
-
-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function lsp 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package gleam-ts-mode :defer t :after (lsp)
   :ensure (:type git
@@ -25,7 +26,8 @@
   "All things Gleam."
   (icejam-set-indent 2)
   (column-enforce-n 100)
-  (lsp))
+  (lsp)
+  (icejam-set-lsp-capfs))
 
 (add-hook 'gleam-mode-hook 'icejam-lang-activate-gleam-mode)
 

lisp/langs/icejam-lang-golang.el

@@ -9,8 +9,10 @@
 ;; golang mode stuff
 
 ;;; Code:
-
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function lsp 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package go-mode
   :requires (lsp-mode lsp-ui)
@@ -21,9 +23,10 @@
   "Activate my own Golang mode settings."
   (icejam-set-indent 8)
   (column-enforce-n 100)
-  (lsp))
+  (lsp)
+  (icejam-set-lsp-capfs))
 
-(add-hook 'go-mode-hook 'icejam-activate-golang-mode)
+(add-hook 'go-mode-hook #'icejam-activate-golang-mode)
 
 (provide 'icejam-lang-golang)
 ;;; icejam-lang-golang.el ends here

lisp/langs/icejam-lang-haskell.el

@@ -10,8 +10,10 @@
 
 ;;; Code:
 
-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function lsp-deferred 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package haskell-mode
   :ensure t

lisp/langs/icejam-lang-javascript.el

@@ -2,9 +2,10 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
-(require 'icejam-flycheck)
-(require 'icejam-lsp)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function lsp-deferred 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package js2-mode :ensure t :defer t
   :after (web-mode lsp-mode lsp-ui))

lisp/langs/icejam-lang-kotlin.el

@@ -9,10 +9,10 @@
 ;; kotlin does a thing.
 
 ;;; Code:
-(require 'icejam-prog-mode)
-
-(declare-function lsp "lsp-mode" nil)
-(declare-function column-enforce-n "column-enforce-mode" (number))
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function lsp 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package kotlin-ts-mode
   :ensure t
@@ -28,7 +28,8 @@
   "All things Kotlin."
   (icejam-set-indent 2)
   (column-enforce-n 100)
-  (lsp))
+  (lsp)
+  (icejam-set-lsp-capfs))
 
 (add-hook 'kotlin-ts-mode-hook 'icejam-activate-kotlin-mode)
 

lisp/langs/icejam-lang-lean.el

@@ -2,15 +2,15 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
-(require 'icejam-lsp)
+(declare-function lsp-deferred 'lsp-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package lean4-mode
   :ensure (lean4-mode
-	   :type git
-	   :host github
-	   :repo "leanprover/lean4-mode"
-	   :files ("*.el" "data"))
+           :type git
+           :host github
+           :repo "leanprover/lean4-mode"
+           :files ("*.el" "data"))
   :requires (lsp)
   :defer t)
 
@@ -24,7 +24,7 @@
   ;; Capf override
   (icejam-set-lsp-capfs))
 
-(add-hook 'lean4-mode-hook 'icejam-activate-lean-mode)
+(add-hook 'lean4-mode-hook #'icejam-activate-lean-mode)
 
 (provide 'icejam-lang-lean)
 ;;; icejam-lang-lean.el ends here

lisp/langs/icejam-lang-markdown.el

@@ -2,7 +2,8 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
 
 ;; Markdown is a dependency of LSP mode. By wrapping it in unless we silence
 ;; a warning from the byte compiler.
@@ -14,6 +15,7 @@
   (setq-default markdown-command "pandoc"))
 
 (declare-function rxt--re-builder-switch-pcre-mode "pcre2el")
+(declare-function markdown-preview 'markdown-mode)
 
 (defun icejam-lang-activate-markdown-mode ()
   "Reconfigure markdown mode for your own purposes."
@@ -21,11 +23,11 @@
   (column-enforce-n 10000)
 
   ;; Markdown mode reuses my bindings, remove them.
-  (define-key markdown-mode-map (kbd "C-c <left>") nil)
-  (define-key markdown-mode-map (kbd "C-c <right>") nil)
-  (define-key markdown-mode-map (kbd "C-c <up>") nil)
-  (define-key markdown-mode-map (kbd "C-c <down>") nil)
-  (define-key markdown-mode-map (kbd "C-c C-v") 'markdown-preview))
+  (keymap-set markdown-mode-map "C-c <left>" nil)
+  (keymap-set markdown-mode-map "C-c <right>" nil)
+  (keymap-set markdown-mode-map "C-c <up>" nil)
+  (keymap-set markdown-mode-map "C-c <down>" nil)
+  (keymap-set markdown-mode-map "C-c C-v" #'markdown-preview))
 
 (add-hook 'markdown-mode-hook 'icejam-lang-activate-markdown-mode)
 (add-hook 'markdown-mode-hook 'display-line-numbers-mode)

lisp/langs/icejam-lang-ocaml.el

@@ -2,12 +2,14 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-transient)
-(require 'icejam-prog-mode)
 (declare-function lsp "lsp-mode" nil)
 
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
+(eval-when-compile (defvar icejam-language-transient-alist))
+
 (use-package merlin :defer t :ensure t)
-(use-package opam-switch-mode :defer t :ensure t)
+(use-package opam-switch-mode :defer t :ensure t :commands (opam-switch-mode))
 (use-package dune :defer t :ensure t)
 (use-package tuareg :defer t :ensure t)
 
@@ -48,7 +50,8 @@
   (icejam-set-indent 2)
   (opam-switch-mode t)
   (icejam-load-ocaml-site-packages)
-  (lsp))
+  (lsp)
+  (icejam-set-lsp-capfs))
 
 (add-hook 'tuareg-mode-hook 'icejam-activate-tuareg-mode)
 

lisp/langs/icejam-lang-php.el

@@ -9,15 +9,15 @@
 ;; php related settings
 
 ;;; Code:
-
-(require 'icejam-prog-mode)
-(require 'icejam-flycheck)
-(require 'icejam-transient)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
+(eval-when-compile (defvar icejam-language-transient-alist))
 
 (use-package php-mode :ensure t :defer t
   :requires (lsp-mode lsp-ui))
 
-(transient-define-prefix icejam-lang-php/context-menu ()
+(transient-define-prefix icejam-lang-php-context-menu ()
   "PHP Buffer Commands."
   [""
    ["LSP"
@@ -36,7 +36,7 @@
   (icejam-set-indent 4)
   (column-enforce-n 80)
 
-  (define-key php-mode-map (kbd "C-c l") 'icejam-lang-php/context-menu)
+  (keymap-set php-mode-map "C-c l" #'icejam-lang-php-context-menu)
 
   ;; Capf override
   (icejam-set-lsp-capfs))

lisp/langs/icejam-lang-purescript.el

@@ -9,7 +9,10 @@
 ;; Configuration for purescript.
 
 ;;; Code:
-(require 'icejam-prog-mode)
+
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package purescript-mode :ensure t :defer t
   :after (lsp-mode lsp-ui))

lisp/langs/icejam-lang-python.el

@@ -1,12 +1,10 @@
 ;;; python -- summary -*- lexical-binding: t; -*-
 ;;; Commentary:
 ;;; Code:
-
-(require 'icejam-prog-mode)
-(require 'icejam-transient)
-
-(declare-function lsp nil)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
+(declare-function lsp 'lsp-mode)
 (declare-function column-enforce-n "column-enforce-mode" (number))
+(eval-when-compile (defvar icejam-language-transient-alist))
 
 (transient-define-prefix icejam-python-lang-menu ()
   "Python Buffer Commands."

lisp/langs/icejam-lang-ruby.el

@@ -2,9 +2,12 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function lsp 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
+(eval-when-compile (defvar icejam-language-transient-alist))
 
-(use-package rspec-mode :ensure t :defer t)
+(use-package rspec-mode :ensure t :defer t :commands (rspec-install-snippets))
 (use-package ruby-end :ensure t :defer t)
 (use-package rbs-mode :ensure t :defer t)
 

lisp/langs/icejam-lang-rust.el

@@ -2,7 +2,11 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function lsp-deferred 'lsp-mode)
+
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package rust-mode
   :ensure t
@@ -22,7 +26,8 @@
   (column-enforce-n 99)
 
   ;; Run LSP
-  (lsp-deferred))
+  (lsp-deferred)
+  (icejam-set-lsp-capfs))
 
 (add-hook 'rust-mode-hook 'icejam-activate-rust-mode)
 (add-hook 'rust-mode-hook 'flycheck-rust-setup)

lisp/langs/icejam-lang-web.el

@@ -2,8 +2,7 @@
 ;;; Commentary:
 ;;; Code:
 
-(require 'icejam-lsp)
-(require 'icejam-flycheck)
+(declare-function lsp 'lsp-mode)
 
 (use-package web-mode :after (lsp flycheck) :ensure t :defer t)
 

lisp/langs/icejam-lang-ziglang.el

@@ -9,7 +9,10 @@
 ;; ziglang does a thing.
 
 ;;; Code:
-(require 'icejam-prog-mode)
+(declare-function column-enforce-n 'column-enforce-mode (number))
+(declare-function lsp 'lsp-mode)
+(declare-function icejam-set-indent 'icejam-prog-mode)
+(declare-function icejam-set-lsp-capfs 'icejam-complete-at-point)
 
 (use-package zig-mode :ensure t :defer t :requires (lsp))
 
@@ -21,7 +24,8 @@
 
   ;; Set indentation to 4 chars
   (icejam-set-indent 4)
-  (lsp))
+  (lsp)
+  (icejam-set-lsp-capfs))
 
 (add-hook 'zig-mode-hook 'icejam-activate-zig-mode)