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

[Kelly Dean <kelly@prtime.org>]

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?