elisp def
1.0.0
Accédez à la définition du symbole au point. Prend en charge les définitions globales, les définitions locales et même le code macro-lourd!
elisp-def analyse statiquement votre code et retombe à l'heuristique là où cela n'est pas possible. Cela devrait fonctionner 99% du temps, veuillez donc déposer des bogues s'il ne peut pas trouver de définitions de votre code.
Installez à partir de Melpa, puis ajoutez ce qui suit à votre configuration EMACS:
( dolist (hook '(emacs-lisp-mode-hook ielm-mode-hook))
( add-hook hook # 'elisp-def-mode )) elisp-def trouvera la définition des fonctions globales et des variables globales au point.
( defun demo/foo ()
1 )
( defun demo/bar ()
; ; M-x eval-buffer, then elisp-def on this:
(demo/foo))Il utilisera également les informations EDEBUG pour trouver des définitions de fonction, donc il trouve des définitions plus souvent que Xref.
elisp-def comprend la différence entre les symboles et les fonctions et saute vers la définition correcte.
( 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 comprend les macros, il peut donc détecter avec précision les références de fonction.
( 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))Il peut également comprendre les macros qui définissent les fonctions ou les variables.
( 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 trouvera des bibliothèques, affichant les déclarations provide si possible.
; ; `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 comprend les liaisons et les paramètres locaux.
( 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 ))Cela fonctionne même avec des macros qui introduisent les liaisons.
( 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 vous permet de mettre le point sur des symboles cités, des symboles docstring ou des symboles backquotés.
( 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 ))Lorsqu'il trouve le symbole, Elisp-Def le mettra également en évidence temporairement pour la visibilité.
elisp-def est limité dans sa capacité à analyser les symboles cités.
; ; `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 ne peut pas trouver de définitions dans les macros avec la sémantique let* et les variables dupliquées.
( 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 ne peut pas non plus gérer les macros qui réécrivent les formes de telle sorte que le symbole disparaît entièrement.
( 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 d'Elisp-slime-navxref-find-definitions en emacs-lisp-mode (partie du noyau EMACS)semantic-ia-fast-jump de semantic/ia.el (inclus dans EMACS) Les beaux gens sur #emacs pour avoir répondu à mes questions sur Elisp Esoterica, en particulier Wasamasa.
La bibliothèque de compliments pour l'achèvement de Clojure a une notion de contexte qui est très similaire à la façon dont Elisp-DEF extrait et analyse les formulaires.
Hacklang a une notion similaire d'un espace réservé pour analyser les compléments à un point du code.
Gplv3 +.
Je vous fournit du code dans le référentiel sous une licence open source. Parce que c'est mon référentiel personnel, la licence que vous recevez à mon code est de moi et non de mon employeur.
