`make-local-variable` Behaves Differently depending on Whether Variable is Special

Question

Two examples (both are in the *scratch* buffer and under lexical scoping rule):

1. _

   (setq xx :default)
   
   (let ((xx :let))
     (with-current-buffer (get-buffer-create "tmp")
       (make-local-variable 'xx)
       ;; set the value of xx, buffer-locally
       (setq xx :tmp)) ; exit from "tmp"
     xx) ; ==> :tmp
   ;; I think that: after exiting from "tmp",
   ;; xx would restore its previous value
   ;; bound by `let`.
   ;; But in fact, it didn't evaluate to :let.
   
   (with-current-buffer "tmp"
     xx) ; ==> :default
   ;; It seems that even though `let`-binding was
   ;; created in "*scratch*", it removed the 
   ;; binding of the buffer-local variable
   ;; in the buffer "tmp" so that this form didn't
   ;; evaluate to :tmp.
   

2. _

   (defvar yy :default)
   
   (let ((yy :let))
     (with-current-buffer (get-buffer-create "tmp")
       (make-local-variable 'yy)
       (setq yy :tmp))
     yy) ; ==> :let
   ;; yy restored its value created by `let`-bing
   ;; after switching back to the original buffer.
   ;; This is intuitive.
   
   (with-current-buffer "tmp"
     yy) ; ==> :tmp
   ;; `let`-binding didn't remove the binding created
   ;; by (setq yy :tmp).
   ;; It behaved differently from the previous example.
   

These comments show my two kinds of understanding, neither is self-consistent. And they are contradictory to each other.

Why are the results different for these two examples?
example-1: :tmp :default
example-2: :let :tmp

Is there any section, in the manual, explaining the above behaviors?
I did not find it.

Answer 1

Variables with dynamic scope can have global and buffer-local values, which are associated with the canonical symbol for the variable.

The global vs buffer-local concepts are irrelevant to lexically-scoped variables, which have "indefinite extent" within the lexical scope of the code in question, and (crucially) are not tied to the symbol of the same name.

As (make-local-variable 'xx) acts on the symbol xx, it has no bearing on any lexical variable xx in that code. (The same comment applies to any function which accesses a variable via a symbol argument.)

It will still cause a dynamically-scoped variable of that name to be buffer-local to the temp buffer, but the (setq xx :tmp) is setting the lexical variable. If you were to (set 'xx :tmp) OTOH, you'd be setting the dynamic buffer-local variable via the symbol.

C-hig (elisp)Lexical Binding is the node to read.