anchor.diff:          (setf finally (ensure-block)))
         (as :try body catch finally)))
   
  +  ;; How about merge them...
     (def vardefs (no-in)
  -    (unless (token-type-p token :name) (unexpected token))
  -    (let ((name (token-value token)) val)
  -      (next)
  -      (when (tokenp token :operator :=)
  -        (next) (setf val (expression nil no-in)))
  -      (if (tokenp token :punc #\,)
  -          (progn (next) (cons (cons name val) (vardefs no-in)))
  -          (list (cons name val)))))
  +    (cond ((token-type-p token :name)
  +	   (let ((name (token-value token)) val)
  +	     (next)
  +	     (when (tokenp token :operator :=)
  +	       (next) (setf val (expression nil no-in)))
  +	     (if (tokenp token :punc #\,)
  +		 (progn (next) (cons (cons name val) (vardefs no-in)))
  +		 (list (cons name val)))))
  +	  ((tokenp token :punc #\[)
  +	   (progn (next) (array*)))
  +	  ((tokenp token :punc #\{)
  +	   (progn (next) (object*)))
  +	  (t
  +	   (unexpected token))))
   
     (def letdefs (no-in)
  -    (if (token-type-p token :name)
  -	(let ((name (token-value token)) val)
  -	  (next)
  -	  (when (tokenp token :operator :=)
  -	    (next) (setf val (expression nil no-in)))
  -	  (if (tokenp token :punc #\,)
  -	      (progn (next) (cons (cons name val) (letdefs no-in)))
  -	      (list (cons name val))))
  -	;; We are facing destructuring.
  -	(if (tokenp token :punc #\[)
  -	    (progn (next) (array*))
  -	    (if (tokenp token :punc #\{)
  -		(progn (next) (object*))
  -		(unexpected token)))))
  +    (cond ((token-type-p token :name)
  +	   (let ((name (token-value token)) val)
  +	     (next)
  +	     (when (tokenp token :operator :=)
  +	       (next) (setf val (expression nil no-in)))
  +	     (if (tokenp token :punc #\,)
  +		 (progn (next) (cons (cons name val) (letdefs no-in)))
  +		 (list (cons name val)))))
  +	   ;; We are facing destructuring.
  +	  ((tokenp token :punc #\[)
  +	   (progn (next) (array*)))
  +	  ((tokenp token :punc #\{)
  +	   (progn (next) (object*)))
  +	  (t
  +	   (unexpected token))))
   
     ;; FIXME: var [a, b] = XXX; is also valid in ES6.
     (def var* (&optional no-in)
  
positive.code:       (def argnames (loop for first = t then nil
  		       until (tokenp token :punc #\))
  		       unless first do (expect #\,)
  		       unless (token-type-p token :name) do (unexpected token)
  		       collect (prog1 (token-value token) (next))))
        (next)
        (expect #\{)
        (def body (let ((*in-function* t) (*label-scope* ()))
  
negative.code: 
  (defparameter +precedence+
    (let ((precs (make-hash-table)))
      ;; The => arrow function operator and ... spread operator are the last.
      (loop for ops in '((:...) (:=>) (:|\|\||) (:&&) (:|\||) (:^) (:&)
  		       (:== :=== :!= :!==) (:< :> :<= :>= :in :instanceof)
  		       (:>> :<< :>>>) (:+ :-) (:* :/ :%))
  