elisp def
1.0.0
Gehen Sie zur Definition des Symbols am Punkt. Unterstützt globale Definitionen, lokale Definitionen und sogar makroauflastende Code!
elisp-def analysiert Ihren Code statisch und fällt auf Heuristiken zurück, wo das nicht möglich ist. Es sollte zu 99% der Zeit funktionieren. Bitte stellen Sie Fehler ein, wenn es keine Definitionen für Ihren Code finden kann.
Installieren Sie von melpa und fügen Sie Ihre EMACS -Konfiguration Folgendes hinzu:
( dolist (hook '(emacs-lisp-mode-hook ielm-mode-hook))
( add-hook hook # 'elisp-def-mode )) elisp-def findet die Definition globaler Funktionen und globalen Variablen am Punkt.
( defun demo/foo ()
1 )
( defun demo/bar ()
; ; M-x eval-buffer, then elisp-def on this:
(demo/foo))Es werden auch Edebug -Informationen verwendet, um Funktionsdefinitionen zu finden, sodass Definitionen häufiger als XREF finden.
elisp-def versteht den Unterschied zwischen Symbolen und Funktionen und springt zur richtigen Definition.
( 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 )) elisp-def versteht Makros, sodass die Funktionsreferenzen genau erkennen können.
( 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))Es kann auch Makros verstehen, die Funktionen oder Variablen definieren.
( 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 ) elisp-def findet Bibliotheken und zeigt nach Möglichkeit die provide an.
; ; `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 )) elisp-def versteht lokale Bindungen und Parameter.
( 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 ))Dies funktioniert sogar mit Makros, die Bindungen einführen.
( 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))) elisp-def können Sie zitierte Symbole, DocString-Symbole oder Backquoted-Symbole angeben.
( 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 ))Wenn es das Symbol findet, wird es auch ELISP-Def vorübergehend für die Sichtbarkeit hervorheben.
elisp-def ist in seiner Fähigkeit begrenzt, zitierte Symbole zu analysieren.
; ; `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 kann Definitionen in Makros nicht mit let* -Semantik und doppelten Variablen finden.
( 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 kann auch Makros nicht bewältigen, die Formen neu schreiben, so dass das Symbol vollständig verschwindet.
( 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 ))elisp-slime-nav-find-elisp-thing-at-point von Elisp-Slime-Navxref-find-definitions im emacs-lisp-mode (Teil des EMACS-Kerns)semantic-ia-fast-jump aus semantic/ia.el (enthalten in EMACs) Die guten Leute auf #emacs für die Beantwortung meiner Fragen zu Elisp Esoterica, insbesondere von Wassamasa.
Die Komplimentbibliothek für die Abschluss von Clojure hat einen Begriff des Kontextes, der sehr ähnlich ist, wie ELISP-Def-Extrakte und Analysen von Formularen extrahiert und analysiert.
Hacklang hat einen ähnlichen Begriff eines Platzhalters für die Analyse von Abschlüssen an einem Punkt im Code.
GPLV3+.
Ich stelle Ihnen unter einer Open -Source -Lizenz Code im Repository vor. Da dies mein persönliches Repository ist, ist die Lizenz, die Sie in meinem Code erhalten, von mir und nicht von meinem Arbeitgeber.
