elisp def

ELISP-DEF

Pergi ke definisi simbol pada titik. Mendukung definisi global, definisi lokal, dan bahkan kode makro-berat!

elisp-def secara statis menganalisis kode Anda, dan kembali ke heuristik di mana itu tidak mungkin. Ini harus bekerja 99% dari waktu, jadi silakan mengajukan bug jika tidak dapat menemukan definisi untuk kode Anda.

Instalasi

Instal dari Melpa, lalu tambahkan yang berikut ini ke konfigurasi Emacs Anda:

( dolist (hook '(emacs-lisp-mode-hook ielm-mode-hook))
  ( add-hook hook # 'elisp-def-mode ))

Definisi Global

elisp-def akan menemukan definisi fungsi global dan variabel global pada titik.

( defun demo/foo ()
  1 )

( defun demo/bar ()
  ; ; M-x eval-buffer, then elisp-def on this:
  (demo/foo))

Ini juga akan menggunakan informasi edebug untuk menemukan definisi fungsi, sehingga ia menemukan definisi lebih sering daripada XREF.

Kesadaran Lisp-2

elisp-def memahami perbedaan antara simbol dan fungsi dan melompat ke definisi yang benar.

( require 'cc-mode )

; ; `c-version' is both a variable and a function.

( defun demo/foo ()
  ; ; `elisp-def` will find the function here.
  ( c-version ))

( defun demo/foo ()
  ; ; `elisp-def` will find the variable here.
  ( setq c-version t ))

Kesadaran makro

elisp-def memahami makro, sehingga dapat secara akurat mendeteksi referensi fungsi.

( require 'dash )

( defvar demo/foo nil )

( defun demo/foo ( x )
  x)

( defun demo/bar ()
  (-> > 123
       ; ; `elisp-def' knows that this is a function, even though there are
       ; ; no parens.
       demo/foo))

Ini juga dapat memahami makro yang mendefinisikan fungsi atau variabel.

( define-derived-mode demo/foo-mode fundamental-mode " demo " )

; ; `elisp-def' will expand macros to discover where major mode hooks
; ; are defined.
demo/foo-mode-hook

( cl-defstruct demo/point x y)

; ; `elisp-def' can find this function even though the defstruct
; ; call doesn't contain this symbol name.
(make-demo/point 1 2 )

Temukan perpustakaan

elisp-def akan menemukan perpustakaan, menampilkan deklarasi provide jika memungkinkan.

 ; ; `elisp-def' will open python.el here.
( require 'python )

; ; Unlike `xref-find-definition' , `elisp-def' will not confuse this
; ; library name with the macro named `use-package' .
( require 'use-package )

; ; `elisp-def' will even find python.el here, because the macro
; ; expands to a call to `require' .
( use-package python
  :config
  ( setq python-indent-guess-indent-offset-verbose nil ))

Binding lokal

elisp-def memahami binding dan parameter lokal.

( defun demo/foo ( bar )
  ( let ((foo 1 ))
    ; ; `elisp-def' on the FOO below will move point to the let
    ; ; binding.
    ( setq foo 2 )
    ; ; `elisp-def' on the BAR below will move point to the function
    ; ; parameters line.
    ( setq bar 3 )))

( defun demo/bar ()
  ( let* ((foo 1 )
         (bar 2 )
         (foo 3 )
         ; ; `elisp-def' on the second FOO on the following line will
         ; ; move point to the relevant binding, which is the line
         ; ; immediately above.
         (foo ( + foo 1 ))
         (foo 5 ))
    nil ))

Ini bahkan berfungsi dengan makro yang memperkenalkan binding.

( require 'dash )
( eval-when-compile
  ( require 'cl-lib ))

( defun demo/foo ( items )
  ( cl-destructuring-bind ( first second) items
    ; ; `elisp-def' knowns that FIRST is bound on line above.
    ( message " first is %s " first))
  (-let [( first . rest) items]
    ; ; `elisp-def' knowns that FIRST is bound on line above.
    ( message " first is %s " first)))

Ergonomi

elisp-def memungkinkan Anda untuk menempatkan titik pada simbol yang dikutip, simbol docString atau simbol backquoted.

( defun demo/foo ( x )
  ; ; `elisp-def' on X in the docstring will find the parameter.
  " Adds one to X and returns it. "
  ( 1+ x))

( defun demo/bar ()
  ; ; `elisp-def' can find demo/foo even when point is on the #.
  ( funcall # 'demo/foo 1 )
  ; ; `elisp-def' on demo/foo below will find the function.
  ; ;
  ; ; See `demo/foo' for more information.
  nil )

( defun demo/baz ( foo )
  ; ; `elisp-def' understands that @ is not part of foo here.
  `(blah ,@foo ))

Ketika menemukan simbol, Elisp-Def juga akan menyoroti untuk sementara waktu untuk visibilitas.

Peringatan

elisp-def terbatas dalam kemampuannya untuk menganalisis simbol yang dikutip.

 ; ; `elisp-def' is able to find these quoted symbols because they're
; ; only globally bound in one namespace.
( mapcar 'symbol-name '(foo bar baz))
( add-to-list 'auto-mode-alist '( " \ .java \ ' " . java-mode))

( require 'cc-mode )
( defun demo/calls-fn ( sym )
  ( funcall sym))

; ; Since `c-version' is both a function and a variable, and we're not
; ; using a sharp-quote #'c-version, we have to prompt the user.
(demo/calls-fn 'c-version )

( defun demo/foo ( c-version )
  ; ; Here we have no idea whether we're using `c-version' as a
  ; ; function (e.g. funcall), as a variable (e.g. set) or as a
  ; ; parameter (e.g. eval).
  (bar 'c-version nil ))

elisp-def tidak dapat menemukan definisi dalam makro dengan Variabel let* SEMANCICS dan Duplikasi.

( require 'dash )

( defun demo/foo ()
  (-let ((x 1 )
         (x 2 ))
    ; ; `elisp-def' on X below will move to the first X binding, rather
    ; ; than the second.
    x))

elisp-def juga tidak dapat menangani makro yang menulis ulang bentuk sedemikian rupa sehingga simbol menghilang sepenuhnya.

( eval-when-compile ( require 'cl-lib ))

( cl-labels ((foo (x y) ( + x y)))
  ; ; `cl-labels' completely rewrites this body to (--cl-foo-- 1 2), so
  ; ; `elisp-def' can't find the definition of FOO.
  (foo 1 2 ))

Terima kasih/inspirasi

• elisp-slime-nav-find-elisp-thing-at-point DARI ELISP-SLIME-NAV
• xref-find-definitions DI emacs-lisp-mode (Bagian dari EMACS Core)
• semantic-ia-fast-jump dari semantic/ia.el (termasuk dalam emacs)

Orang -orang baik di #emacs untuk menjawab pertanyaan saya tentang Elisp Esoterica, khususnya Wasamasa.

Perpustakaan pujian untuk penyelesaian Clojure memiliki gagasan konteks yang sangat mirip dengan bagaimana ELISP-DEF mengekstrak dan menganalisis bentuk.

Hacklang memiliki gagasan serupa tentang placeholder untuk menganalisis penyelesaian pada suatu titik dalam kode.

Lisensi

Gplv3+.

Saya menyediakan kode di repositori untuk Anda di bawah lisensi open source. Karena ini adalah repositori pribadi saya, lisensi yang Anda terima untuk kode saya berasal dari saya dan bukan majikan saya.