bug#51982: Erroneous handling of local variables in byte-compiled nested lambdas

[Mattias Engdegård]

> Yes, and I can confirm that both transformations (let* -> let and the 
> inverse) seem to generate almost or exactly identical bytecode for lexbind 
> code. If you can find an example where it's worse, I'd like to know.

And by "yes" I mean "no", since the identical bytecode is only true in the 
absence of mutation which, as always, throws a spanner in the works. For 
example, while

(let ((x (sin y)) (y (cos x)))
  (+ x y))))
->
(let* ((x0 (sin y)) (y (cos x)) (x x0))
  (+ x y))))

is a transformation with identical bytecode, mutating one of the variables:

(let ((x (sin y)) (y (cos x)))
  (setq x (1+ x))
  (+ x y))))
->
(let* ((x0 (sin y)) (y (cos x)) (x x0))
  (setq x (1+ x))
  (+ x y))))

will prevent the intermediate from being eliminated. Not a disaster by any 
means but not good enough as a general method of translation.