anchor.diff:      (return-from shcl/core/shell-grammar:parse-simple-command
         (call-next-method)))
   
  -  (let ((*command-words* (make-extensible-vector)))
  +  (let ((*command-words* (fset:empty-seq)))
       (call-next-method)))
   
   (deftype command-word (real-type)
  
positive.code:           (do-iterator (command command-iterator)
              (declare (ignore command)))
          (shcl/core/parser:parse-failure (err)
            (add-error (shcl/core/parser:parse-failure-error-object err))))
        all-errors)))
  
  (defun valid-types-for-next-token (leading-tokens)
    (let ((all-errors (completion-relevant-parse-errors-for-leading-tokens leading-tokens)))
      (concatmap-iterator all-errors 'parse-error-expected-types)))
  
  (defun completion-suggestions-for-tokens (leading-tokens token-to-complete context)
    (let* ((unique-table (make-unique-table))
           (raw-type-iter (valid-types-for-next-token leading-tokens))
           (type-iter (concatmap-iterator raw-type-iter
                                          (lambda (type)
                                            (expand-type type unique-table)))))
      (concatmap-iterator type-iter
                          (lambda (type)
                            (completion-suggestions type token-to-complete context)))))
  
  (defun completion-suggestions-for-input (input-text cursor-point readtable)
    "Compute possible completions.
  
negative.code:                               (list sigil-token)))))
           (shcl/core/shell-grammar:*intermediate-parse-error-hook*
            shcl/core/shell-grammar:*intermediate-parse-error-hook*)
           (seen-errors (make-hash-table :test 'eq))
           (suggestions (fset:empty-set)))
      (labels
          ((add-error (err)
             (when (and (parse-error-involves-sigil-token-p err sigil-token)
                        (not (nth-value 1 (gethash err seen-errors))))
               (setf (gethash err seen-errors) t)
               (let* ((expected-types (parse-error-expected-types err))
                      (all-expected-types (concatmap-iterator expected-types (type-expander)))
                      (suggestion-producer (lambda (type)
                                             (completion-suggestions type token-to-complete context)))
                      (err-suggestions (concatmap-iterator all-expected-types suggestion-producer)))
                 ;; Consume suggestions eagerly so they are computed in
                 ;; the dynamic context where the error was produced
                 (do-iterator (suggestion err-suggestions)
                   (fset:adjoinf suggestions suggestion))))))
        (add-hook
         'shcl/core/shell-grammar:*intermediate-parse-error-hook*
         #'add-error)
  