bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Andreas Röhler]

(defun foo ()
   (interactive)
   (let ((iact (called-interactively-p 'any)))
     (message "%s" iact)))


Code above returns t when run in an otherwise empty buffer.
However when evaluated inside

https://github.com/emacs-berlin/syntactic-close/blob/master/syntactic-close.el

it returns nil. Checked at the beginning resp. end of this file.

emacs -Q
GNU Emacs 25.1.90.1 (i686-pc-linux-gnu, GTK+ Version 3.14.5) of 2016-11-29

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Michael Heerdegen]

Andreas Röhler <andreas.roehler@easy-emacs.de> writes:

> (defun foo ()
>   (interactive)
>   (let ((iact (called-interactively-p 'any)))
>     (message "%s" iact)))
>
>
> Code above returns t when run in an otherwise empty buffer.
> However when evaluated inside
>
> https://github.com/emacs-berlin/syntactic-close/blob/master/syntactic-close.el
>
> it returns nil. Checked at the beginning resp. end of this file.

What does "when evaluated inside" mean?  Can you give a more concrete
recipe?


Regards,

Michael.

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Andreas Röhler]

On 05.12.2016 17:18, Michael Heerdegen wrote:
> Andreas Röhler <andreas.roehler@easy-emacs.de> writes:
>
>> (defun foo ()
>>    (interactive)
>>    (let ((iact (called-interactively-p 'any)))
>>      (message "%s" iact)))
>>
>>
>> Code above returns t when run in an otherwise empty buffer.
>> However when evaluated inside
>>
>> https://github.com/emacs-berlin/syntactic-close/blob/master/syntactic-close.el
>>
>> it returns nil. Checked at the beginning resp. end of this file.
> What does "when evaluated inside" mean?
Writing the example-code in the file and evaluate it.

BTW it's about messaging the value of `iact', not the return value.
Use-case is to see inside nested functions if the initial call was 
interactive, by handing over that argument `iact'.

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Michael Heerdegen]

Andreas Röhler <andreas.roehler@easy-emacs.de> writes:

> > What does "when evaluated inside" mean?
> Writing the example-code in the file and evaluate it.

How do you evaluate "it"?  That obviously makes a difference for
`called-interactively-p'.  By invoking the command (how do you invoke
it), or differently?


Michael.

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Andreas Röhler]

On 05.12.2016 17:58, Michael Heerdegen wrote:
> Andreas Röhler <andreas.roehler@easy-emacs.de> writes:
>
>>> What does "when evaluated inside" mean?
>> Writing the example-code in the file and evaluate it.
> How do you evaluate "it"?  That obviously makes a difference for
> `called-interactively-p'.  By invoking the command (how do you invoke
> it), or differently?
>

Okay, should have said: invoking after evaluating it.

Installed the command and did M-x foo RET afterwards.
Then it should message the value of `iact'.

M-x foo RET in one file says t, in the other nil.

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Michael Heerdegen]

Andreas Röhler <andreas.roehler@easy-emacs.de> writes:

> Okay, should have said: invoking after evaluating it.
>
> Installed the command and did M-x foo RET afterwards.
> Then it should message the value of `iact'.
>
> M-x foo RET in one file says t, in the other nil.

Ok, I cloned your repo, opened emacs -Q, evaluated the `foo' command
definition, visited "syntactic-close.el" there and typed M-x foo RET.
It says "t" for me.


Michael.

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Andreas Röhler]

[-- Attachment #1: Type: text/plain, Size: 637 bytes --]



On 05.12.2016 18:39, Michael Heerdegen wrote:
> Andreas Röhler <andreas.roehler@easy-emacs.de> writes:
>
>> Okay, should have said: invoking after evaluating it.
>>
>> Installed the command and did M-x foo RET afterwards.
>> Then it should message the value of `iact'.
>>
>> M-x foo RET in one file says t, in the other nil.
> Ok, I cloned your repo, opened emacs -Q, evaluated the `foo' command
> definition, visited "syntactic-close.el" there and typed M-x foo RET.
> It says "t" for me.
>
>
> Michael.

Ahh, only happens when run under edebug.  Whilst with edebug in an 
otherwise empty buffer is fine in contrast.
Adding a png.



[-- Attachment #2: edebug-foo.png --]
[-- Type: image/png, Size: 126599 bytes --]

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Noam Postavsky]

found 25117 24.3
tag 25117 confirmed
retitle 25117 25.1.90; `called-interactively-p' from edebug with
lexical-binding always gives nil
quit

On Mon, Dec 5, 2016 at 1:23 PM, Andreas Röhler
<andreas.roehler@easy-emacs.de> wrote:
>
> Ahh, only happens when run under edebug.  Whilst with edebug in an otherwise
> empty buffer is fine in contrast.

The difference is lexical-binding: t, also happens at least as far back as 24.3.

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Andreas Röhler]

[-- Attachment #1: Type: text/plain, Size: 653 bytes --]



On 05.12.2016 20:08, Noam Postavsky wrote:
> found 25117 24.3
> tag 25117 confirmed
> retitle 25117 25.1.90; `called-interactively-p' from edebug with
> lexical-binding always gives nil
> quit
>
> On Mon, Dec 5, 2016 at 1:23 PM, Andreas Röhler
> <andreas.roehler@easy-emacs.de> wrote:
>> Ahh, only happens when run under edebug.  Whilst with edebug in an otherwise
>> empty buffer is fine in contrast.
> The difference is lexical-binding: t, also happens at least as far back as 24.3.

Not sure about that. Checked with and without lexical-binding. Seems not 
making the difference. See png attached - with emacs -Q checked earlier 
and same result.

[-- Attachment #2: lex-foo.png --]
[-- Type: image/png, Size: 73863 bytes --]

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Noam Postavsky]

On Mon, Dec 5, 2016 at 2:38 PM, Andreas Röhler
<andreas.roehler@easy-emacs.de> wrote:
>>
>> The difference is lexical-binding: t, also happens at least as far back as
>> 24.3.
>
>
> Not sure about that. Checked with and without lexical-binding. Seems not
> making the difference. See png attached - with emacs -Q checked earlier and
> same result.

The text doesn't make the difference, it's the buffer-local value of
the lexical-binding variable that matters.

Having the text in the file affects the value indirectly, see
https://www.gnu.org/software/emacs/manual/html_node/emacs/Specifying-File-Variables.html

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Andreas Röhler]

On 05.12.2016 20:34, Noam Postavsky wrote:
> On Mon, Dec 5, 2016 at 2:38 PM, Andreas Röhler
> <andreas.roehler@easy-emacs.de> wrote:
>>> The difference is lexical-binding: t, also happens at least as far back as
>>> 24.3.
>>
>> Not sure about that. Checked with and without lexical-binding. Seems not
>> making the difference. See png attached - with emacs -Q checked earlier and
>> same result.
> The text doesn't make the difference, it's the buffer-local value of
> the lexical-binding variable that matters.
>
> Having the text in the file affects the value indirectly, see
> https://www.gnu.org/software/emacs/manual/html_node/emacs/Specifying-File-Variables.html

Hmm, don't understand. The lexical-binding is t in both files, set in 
first line. But example foo behaves differently.

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Noam Postavsky]

On Mon, Dec 5, 2016 at 2:52 PM, Andreas Röhler
<andreas.roehler@easy-emacs.de> wrote:
>
>
> On 05.12.2016 20:34, Noam Postavsky wrote:
>>
>> On Mon, Dec 5, 2016 at 2:38 PM, Andreas Röhler
>> <andreas.roehler@easy-emacs.de> wrote:
>>>>
>>>> The difference is lexical-binding: t, also happens at least as far back
>>>> as
>>>> 24.3.
>>>
>>>
>>> Not sure about that. Checked with and without lexical-binding. Seems not
>>> making the difference. See png attached - with emacs -Q checked earlier
>>> and
>>> same result.
>>
>> The text doesn't make the difference, it's the buffer-local value of
>> the lexical-binding variable that matters.
>>
>> Having the text in the file affects the value indirectly, see
>>
>> https://www.gnu.org/software/emacs/manual/html_node/emacs/Specifying-File-Variables.html
>
>
> Hmm, don't understand. The lexical-binding is t in both files, set in first
> line. But example foo behaves differently.

My guess is that you typed in "lexical-binding: t" after you opened
"eil.el". Try it again after running M-x normal-mode in that buffer

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Andreas Röhler]

On 05.12.2016 20:51, Noam Postavsky wrote:
> On Mon, Dec 5, 2016 at 2:52 PM, Andreas Röhler
> <andreas.roehler@easy-emacs.de> wrote:
>>
>> On 05.12.2016 20:34, Noam Postavsky wrote:
>>> On Mon, Dec 5, 2016 at 2:38 PM, Andreas Röhler
>>> <andreas.roehler@easy-emacs.de> wrote:
>>>>> The difference is lexical-binding: t, also happens at least as far back
>>>>> as
>>>>> 24.3.
>>>>
>>>> Not sure about that. Checked with and without lexical-binding. Seems not
>>>> making the difference. See png attached - with emacs -Q checked earlier
>>>> and
>>>> same result.
>>> The text doesn't make the difference, it's the buffer-local value of
>>> the lexical-binding variable that matters.
>>>
>>> Having the text in the file affects the value indirectly, see
>>>
>>> https://www.gnu.org/software/emacs/manual/html_node/emacs/Specifying-File-Variables.html
>>
>> Hmm, don't understand. The lexical-binding is t in both files, set in first
>> line. But example foo behaves differently.
> My guess is that you typed in "lexical-binding: t" after you opened
> "eil.el".

Yes, typed and M-x eval-buffer.

>   Try it again after running M-x normal-mode in that buffer

Okay, when opening with lb to t inside already, under edebug the error 
shows up here too. Thanks!

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Lars Ingebrigtsen]

Andreas Röhler <andreas.roehler@easy-emacs.de> writes:

> Ahh, only happens when run under edebug.  Whilst with edebug in an
> otherwise empty buffer is fine in contrast.

This bug is still present in Emacs 27.

If I understand edebug.el correctly, this code is supposed to make
called-interactively-p work?

;; When edebugging a function, some of the sub-expressions are
;; wrapped in (edebug-enter (lambda () ..)), so we need to teach
;; called-interactively-p that calls within the inner lambda should refer to
;; the outside function.
(add-hook 'called-interactively-p-functions
          #'edebug--called-interactively-skip)
(defun edebug--called-interactively-skip (i frame1 frame2)
  (when (and (eq (car-safe (nth 1 frame1)) 'lambda)
             (eq (nth 1 (nth 1 frame1)) '())
             (eq (nth 1 frame2) 'edebug-enter))
    ;; `edebug-enter' calls itself on its first invocation.
    (if (eq (nth 1 (backtrace-frame i 'called-interactively-p))
            'edebug-enter)
        2 1)))

But I'm not familiar enough with `backtrace-frame' to say whether this,
like, makes sense.  Anybody?

The test case is edebug-defun this, and then `M-x foo'.  The
(called-interactively-p) form will return nil when you step through the
function.

(defun foo ()
  (interactive)
  (let ((iact (called-interactively-p 'any)))
    (message "%s" iact)))


-- 
(domestic pets only, the antidote for overdose, milk.)
   bloggy blog: http://lars.ingebrigtsen.no

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Michael Heerdegen]

Lars Ingebrigtsen <larsi@gnus.org> writes:

> If I understand edebug.el correctly, this code is supposed to make
> called-interactively-p work?
>
> ;; When edebugging a function, some of the sub-expressions are
> ;; wrapped in (edebug-enter (lambda () ..)), so we need to teach
> ;; called-interactively-p that calls within the inner lambda should refer to
> ;; the outside function.
> (add-hook 'called-interactively-p-functions
>           #'edebug--called-interactively-skip)
> (defun edebug--called-interactively-skip (i frame1 frame2)
>   (when (and (eq (car-safe (nth 1 frame1)) 'lambda)
>              (eq (nth 1 (nth 1 frame1)) '())
>              (eq (nth 1 frame2) 'edebug-enter))
>     ;; `edebug-enter' calls itself on its first invocation.
>     (if (eq (nth 1 (backtrace-frame i 'called-interactively-p))
>             'edebug-enter)
>         2 1)))

I think so, yes.

> But I'm not familiar enough with `backtrace-frame' to say whether this,
> like, makes sense.  Anybody?

It makes sense.  Stefan wrote that, but it seems it just doesn't yet handle
the (eq (car-safe (nth 1 frame1)) 'closure) case - Stefan?

> The test case is edebug-defun this, and then `M-x foo'.  The
> (called-interactively-p) form will return nil when you step through the
> function.
>
> (defun foo ()
>   (interactive)
>   (let ((iact (called-interactively-p 'any)))
>     (message "%s" iact)))


Michael.

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Stefan Monnier]

>> But I'm not familiar enough with `backtrace-frame' to say whether this,
>> like, makes sense.  Anybody?
>
> It makes sense.  Stefan wrote that, but it seems it just doesn't yet handle
> the (eq (car-safe (nth 1 frame1)) 'closure) case - Stefan?

Sounds right, yes.  It should be a small matter of accepting `closure`
additionally to `lambda` (and then account for the fact that the arg
list is one step further in that case).


        Stefan

bug#25117: 25.1.90; Result of called-interactively-p differs WRT file contents

[Michael Heerdegen]

Stefan Monnier <monnier@iro.umontreal.ca> writes:

> Sounds right, yes.  It should be a small matter of accepting `closure`
> additionally to `lambda` (and then account for the fact that the arg
> list is one step further in that case).

I tried that locally, but it's broken worse, and it's broken also for
the dynamical binding mode case.

Seems edebug-enter has to be replaced with edebug-default-enter (or are
both cases possible?).  Even then, i.e. when
edebug--called-interactively-skip returns 2 (and I ran everything with
compiled files) `called-interactively-p' still returns nil.  I gave up
for now.

Michael.

bug#25117: 25.1.90; `called-interactively-p' from edebug with lexical-binding always gives nil

[Lars Ingebrigtsen]

I've tried reproducing it in Emacs 29 with the following file:

;;; -*- lexical-binding: t -*-

(defun foo ()
  (interactive)
  (let ((iact (called-interactively-p 'any)))
    (message "Interactive: %s" iact)))

This fails (when run under edebug) in Emacs 27.2, but succeeds in Emacs
29, so it looks like this has been fixed at some point, and I'm
therefore closing this bug report.

-- 
(domestic pets only, the antidote for overdose, milk.)
   bloggy blog: http://lars.ingebrigtsen.no