From: Eric Ludlam <ericludlam@gmail.com>
To: Stefan Monnier <monnier@iro.umontreal.ca>,
Eric Ludlam <eric@siege-engine.com>
Cc: Emacs Development <emacs-devel@gnu.org>
Subject: Re: completion-at-point + semantic : erroneous error
Date: Sat, 12 Oct 2019 07:56:57 -0400 [thread overview]
Message-ID: <9cf7e484-9a86-ab1c-b04f-9dc3e7c91974@gmail.com> (raw)
In-Reply-To: <jwvzhi7ura7.fsf-monnier+emacs@gnu.org>
On 10/11/19 1:34 PM, Stefan Monnier wrote:
>> PS: It would also be good to replace uses of
>> define-overloadable-function with cl-defmethod, although the mapping
>> from one to the other is not immediate.
> The patch below is an attempt to do that for
> semantic-analyze-possible-completions. I'd be interested to hear your
> opinion on this (especially the with-mode-local part).
>
Hi Stefan,
As a followup, I started using the shorter version of your patch, and
found there are additional errors thrown from
semantic-analyze-possible-completions-default (what will be a method in
your patch). I had to eliminate those errors to fully clean up the
original problem that started this thread.
I used catch/throw to solve the problem (see below: patch is against the
original semantic/analyze/complete.el, not your patched version with
methods.)
As an added wrinkle on the `should it be interactive' front, there is a
keybinding in semantic.el for semantic-analyze-possible-completions that
would need to be dealt with.
Eric
diff --git a/lisp/cedet/semantic/analyze/complete.el
b/lisp/cedet/semantic/analyze/complete.el
index b471c0d1a1..b8820b927f 100644
--- a/lisp/cedet/semantic/analyze/complete.el
+++ b/lisp/cedet/semantic/analyze/complete.el
@@ -93,7 +93,8 @@ semantic-analyze-possible-completions
context
(semantic-analyze-current-context context)))
(ans (if (not context)
- (error "Nothing to complete")
+ (when (called-interactively-p 'any)
+ (error "Nothing to complete"))
(:override))))
;; If interactive, display them.
(when (called-interactively-p 'any)
@@ -132,155 +133,159 @@ semantic-analyze-possible-completions-default
(do-unique (not (memq 'no-unique flags)))
)
- (when (not do-longprefix)
- ;; If we are not doing the long prefix, shorten all the key
- ;; elements.
- (setq prefix (list (car (reverse prefix)))
- prefixtypes nil))
-
- ;; Calculate what our prefix string is so that we can
- ;; find all our matching text.
- (setq completetext (car (reverse prefix)))
- (if (semantic-tag-p completetext)
- (setq completetext (semantic-tag-name completetext)))
-
- (if (and (not completetext) (not desired-type))
- (error "Nothing to complete"))
-
- (if (not completetext) (setq completetext ""))
-
- ;; This better be a reasonable type, or we should fry it.
- ;; The prefixtypes should always be at least 1 less than
- ;; the prefix since the type is never looked up for the last
- ;; item when calculating a sequence.
- (setq completetexttype (car (reverse prefixtypes)))
- (when (or (not completetexttype)
- (not (and (semantic-tag-p completetexttype)
- (eq (semantic-tag-class completetexttype) 'type))))
- ;; What should I do here? I think this is an error condition.
- (setq completetexttype nil)
- ;; If we had something that was a completetexttype but it wasn't
- ;; valid, then express our dismay!
- (when (> (length prefix) 1)
- (let* ((errprefix (car (cdr (reverse prefix)))))
- (error "Cannot find types for `%s'"
- (cond ((semantic-tag-p errprefix)
- (semantic-format-tag-prototype errprefix))
- (t
- (format "%S" errprefix)))))
- ))
-
- ;; There are many places to get our completion stream for.
- ;; Here we go.
- (if completetexttype
-
- (setq c (semantic-find-tags-for-completion
- completetext
- (semantic-analyze-scoped-type-parts completetexttype scope)
- ))
-
- ;; No type based on the completetext. This is a free-range
- ;; var or function. We need to expand our search beyond this
- ;; scope into semanticdb, etc.
- (setq c (nconc
- ;; Argument list and local variables
- (semantic-find-tags-for-completion completetext localvar)
- ;; The current scope
- (semantic-find-tags-for-completion completetext (when scope
(oref scope fullscope)))
- ;; The world
- (semantic-analyze-find-tags-by-prefix completetext))
- )
- )
-
- (let ((loopc c)
- (dtname (semantic-tag-name desired-type)))
-
- ;; Save off our first batch of completions
- (setq origc c)
-
- ;; Reset c.
- (setq c nil)
-
- ;; Loop over all the found matches, and categorize them
- ;; as being possible features.
- (while (and loopc do-typeconstraint)
-
- (cond
- ;; Strip operators
- ((semantic-tag-get-attribute (car loopc) :operator-flag)
- nil
- )
-
- ;; If we are completing from within some prefix,
- ;; then we want to exclude constructors and destructors
- ((and completetexttype
- (or (semantic-tag-get-attribute (car loopc) :constructor-flag)
- (semantic-tag-get-attribute (car loopc) :destructor-flag)))
- nil
- )
-
- ;; If there is a desired type, we need a pair of restrictions
- (desired-type
+ (catch 'cant-complete
+ (when (not do-longprefix)
+ ;; If we are not doing the long prefix, shorten all the key
+ ;; elements.
+ (setq prefix (list (car (reverse prefix)))
+ prefixtypes nil))
+
+ ;; Calculate what our prefix string is so that we can
+ ;; find all our matching text.
+ (setq completetext (car (reverse prefix)))
+ (if (semantic-tag-p completetext)
+ (setq completetext (semantic-tag-name completetext)))
+
+ (if (and (not completetext) (not desired-type))
+ (throw 'cant-complete nil)
+ ;;(error "Nothing to complete")
+ )
+
+ (if (not completetext) (setq completetext ""))
+
+ ;; This better be a reasonable type, or we should fry it.
+ ;; The prefixtypes should always be at least 1 less than
+ ;; the prefix since the type is never looked up for the last
+ ;; item when calculating a sequence.
+ (setq completetexttype (car (reverse prefixtypes)))
+ (when (or (not completetexttype)
+ (not (and (semantic-tag-p completetexttype)
+ (eq (semantic-tag-class completetexttype) 'type))))
+ ;; What should I do here? I think this is an error condition.
+ (setq completetexttype nil)
+ ;; If we had something that was a completetexttype but it wasn't
+ ;; valid, then express our dismay!
+ (when (> (length prefix) 1)
+ (throw 'cant-complete nil)
+;;; (let* ((errprefix (car (cdr (reverse prefix)))))
+;;; (error "Cannot find types for `%s'"
+;;; (cond ((semantic-tag-p errprefix)
+;;; (semantic-format-tag-prototype errprefix))
+;;; (t
+;;; (format "%S" errprefix)))))
+ ))
+
+ ;; There are many places to get our completion stream for.
+ ;; Here we go.
+ (if completetexttype
+
+ (setq c (semantic-find-tags-for-completion
+ completetext
+ (semantic-analyze-scoped-type-parts completetexttype scope)
+ ))
+
+ ;; No type based on the completetext. This is a free-range
+ ;; var or function. We need to expand our search beyond this
+ ;; scope into semanticdb, etc.
+ (setq c (nconc
+ ;; Argument list and local variables
+ (semantic-find-tags-for-completion completetext localvar)
+ ;; The current scope
+ (semantic-find-tags-for-completion completetext (when
scope (oref scope fullscope)))
+ ;; The world
+ (semantic-analyze-find-tags-by-prefix completetext))
+ )
+ )
+
+ (let ((loopc c)
+ (dtname (semantic-tag-name desired-type)))
+
+ ;; Save off our first batch of completions
+ (setq origc c)
+
+ ;; Reset c.
+ (setq c nil)
+
+ ;; Loop over all the found matches, and categorize them
+ ;; as being possible features.
+ (while (and loopc do-typeconstraint)
(cond
- ;; Ok, we now have a completion list based on the text we found
- ;; we want to complete on. Now filter that stream against the
- ;; type we want to search for.
- ((string= dtname (semantic-analyze-type-to-name
(semantic-tag-type (car loopc))))
- (setq c (cons (car loopc) c))
+ ;; Strip operators
+ ((semantic-tag-get-attribute (car loopc) :operator-flag)
+ nil
)
- ;; Now anything that is a compound type which could contain
- ;; additional things which are of the desired type
- ((semantic-tag-type (car loopc))
- (let ((att (semantic-analyze-tag-type (car loopc) scope))
- )
- (if (and att (semantic-tag-type-members att))
- (setq c (cons (car loopc) c))))
+ ;; If we are completing from within some prefix,
+ ;; then we want to exclude constructors and destructors
+ ((and completetexttype
+ (or (semantic-tag-get-attribute (car loopc) :constructor-flag)
+ (semantic-tag-get-attribute (car loopc) :destructor-flag)))
+ nil
)
- ) ; cond
- ); desired type
-
- ;; No desired type, no other restrictions. Just add.
- (t
- (setq c (cons (car loopc) c)))
-
- ); cond
-
- (setq loopc (cdr loopc)))
-
- (when desired-type
- ;; Some types, like the enum in C, have special constant values that
- ;; we could complete with. Thus, if the target is an enum, we can
- ;; find possible symbol values to fill in that value.
- (let ((constants
- (semantic-analyze-type-constants desired-type)))
- (if constants
- (progn
- ;; Filter
- (setq constants
- (semantic-find-tags-for-completion
- completetext constants))
- ;; Add to the list
- (setq c (nconc c constants)))
- )))
- )
-
- (when desired-class
- (setq c (semantic-analyze-tags-of-class-list c desired-class)))
-
- (if do-unique
- (if c
- ;; Pull out trash.
- ;; NOTE TO SELF: Is this too slow?
- (setq c (semantic-unique-tag-table-by-name c))
- (setq c (semantic-unique-tag-table-by-name origc)))
- (when (not c)
- (setq c origc)))
-
- ;; All done!
- c))
+ ;; If there is a desired type, we need a pair of restrictions
+ (desired-type
+
+ (cond
+ ;; Ok, we now have a completion list based on the text we found
+ ;; we want to complete on. Now filter that stream against the
+ ;; type we want to search for.
+ ((string= dtname (semantic-analyze-type-to-name
(semantic-tag-type (car loopc))))
+ (setq c (cons (car loopc) c))
+ )
+
+ ;; Now anything that is a compound type which could contain
+ ;; additional things which are of the desired type
+ ((semantic-tag-type (car loopc))
+ (let ((att (semantic-analyze-tag-type (car loopc) scope))
+ )
+ (if (and att (semantic-tag-type-members att))
+ (setq c (cons (car loopc) c))))
+ )
+
+ ) ; cond
+ ) ; desired type
+
+ ;; No desired type, no other restrictions. Just add.
+ (t
+ (setq c (cons (car loopc) c)))
+
+ ) ; cond
+
+ (setq loopc (cdr loopc)))
+
+ (when desired-type
+ ;; Some types, like the enum in C, have special constant values that
+ ;; we could complete with. Thus, if the target is an enum, we can
+ ;; find possible symbol values to fill in that value.
+ (let ((constants
+ (semantic-analyze-type-constants desired-type)))
+ (if constants
+ (progn
+ ;; Filter
+ (setq constants
+ (semantic-find-tags-for-completion
+ completetext constants))
+ ;; Add to the list
+ (setq c (nconc c constants)))
+ )))
+ )
+
+ (when desired-class
+ (setq c (semantic-analyze-tags-of-class-list c desired-class)))
+
+ (if do-unique
+ (if c
+ ;; Pull out trash.
+ ;; NOTE TO SELF: Is this too slow?
+ (setq c (semantic-unique-tag-table-by-name c))
+ (setq c (semantic-unique-tag-table-by-name origc)))
+ (when (not c)
+ (setq c origc)))
+
+ ;; All done!
+ c)))
(provide 'semantic/analyze/complete)
next prev parent reply other threads:[~2019-10-12 11:56 UTC|newest]
Thread overview: 15+ messages / expand[flat|nested] mbox.gz Atom feed top
2019-10-10 2:33 completion-at-point + semantic : erroneous error Eric Ludlam
2019-10-11 17:04 ` Stefan Monnier
2019-10-11 17:34 ` Stefan Monnier
2019-10-12 1:06 ` Eric Ludlam
2019-10-24 20:17 ` Stefan Monnier
2019-10-27 12:35 ` Eric Ludlam
2019-10-27 20:38 ` Stefan Monnier
2019-10-27 23:36 ` Eric Ludlam
2019-10-12 11:56 ` Eric Ludlam [this message]
2019-10-23 20:18 ` Stefan Monnier
2019-10-27 11:52 ` Eric Ludlam
2019-10-27 21:54 ` Stefan Monnier
2019-10-27 22:31 ` Eric Ludlam
2019-10-23 20:22 ` Stefan Monnier
2019-10-27 11:53 ` Eric Ludlam
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=9cf7e484-9a86-ab1c-b04f-9dc3e7c91974@gmail.com \
--to=ericludlam@gmail.com \
--cc=emacs-devel@gnu.org \
--cc=eric@siege-engine.com \
--cc=monnier@iro.umontreal.ca \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
Code repositories for project(s) associated with this external index
https://git.savannah.gnu.org/cgit/emacs.git
https://git.savannah.gnu.org/cgit/emacs/org-mode.git
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.