Why is Elisp's defvar weird? And is eval_sub broken?

[Kelly Dean]

desktop.el has these top-level definitions:
(defvar desktop-first-buffer)
(defvar desktop-buffer-ok-count)
(defvar desktop-buffer-fail-count)

The docstring for defvar says:
⌜Define SYMBOL as a variable, and return SYMBOL.
...
The `defvar' form also declares the variable as "special",
so that it is always dynamically bound even if `lexical-binding' is t.
...
If INITVALUE is missing, SYMBOL's value is not set.

If SYMBOL has a local binding, then this form affects the local
binding.⌝

But that's wrong. If INITVALUE is missing, and lexical-binding is t (as is the 
case in desktop.el), then not only is the value not set, but also the variable 
is _not_ declared special, even if the defvar is at top level.

That means that even after loading desktop.el, if you let-bind the three 
variables above in a function defined in a file other than desktop.el, and 
lexical-binding is t in that other file, then those variables will be bound 
lexically, not dynamically.

This was causing an inexplicable bug in my code that uses functions from 
desktop.el, that I could figure out how to fix only by using setq instead of 
«let» for those variables. Then today I happened to read the source code for 
defvar and discovered what's really going on. I can fix my bug without setq, by 
instead using defvar (without INITVALUE) before «let». If the docstring for 
defvar were true (i.e. top-level defvar declares special (even if INITVALUE is 
missing)), then I wouldn't need to use defvar before the «let», because 
desktop.el would have already made those variables special. It's no problem for 
me to use defvar before the «let», but the docstring should say what defvar 
really does, so people know it's necessary in this case.

Also, CL doesn't behave this way. E.g. In Elisp (in Emacs 24.4):
(setq lexical-binding t)
(let ((foo 'bar)) (defvar foo) foo) → bar
(let ((foo 'baz)) (makunbound 'foo) foo) → baz

But in CL:
(let ((foo 'bar)) (defvar foo) foo) → bar
(let ((foo 'baz)) (makunbound 'foo) foo) → error: foo is unbound

In Elisp, both let-bindings are lexical, but in CL, the second let-binding is 
dynamic.

What's the purpose of Elisp behaving this way? Is it just to enable local use 
of dynamic variables (for implicit arguments and return values of functions) 
without having to clutter the globals with otherwise-unneeded special 
variables? If so, a cleaner way to do it would be with a dynamic-let special 
form, rather than a weirdly-behaving defvar.

Also, in Elisp:
(setq lexical-binding t)
(let ((foo 0))
  (defvar foo)
  (let ((foo 1))
    foo)) → 0

That's because eval_sub in eval.c looks up the variable in the lexical 
environment using only Fassq, without first using Fmemq to check for a local 
dynamic binding. Is that behavior actually correct?