anchor.diff:            (do-iterator (command command-iterator)
               (declare (ignore command)))
           (shcl/core/parser:parse-failure (err)
  +          ;; This really should have already been handled, but just in
  +          ;; case...
             (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)))))
  +      suggestions)))
   
   (defun completion-suggestions-for-input (input-text cursor-point readtable)
     "Compute possible completions.
  
positive.code: (defmethod shcl/core/lexer:token-value ((sigil sigil-token))
    nil)
  
  (defun completion-relevant-parse-errors-for-leading-tokens (leading-tokens)
    (let* ((*collect-tab-complete-info* t)
           (sigil-token (make-instance 'sigil-token))
           (command-iterator (shcl/core/shell-grammar:command-iterator
  
negative.code:       (error-p
         (shcl/core/parser:parser-error (wrap-expected-type value)))
        (t
         (fset:push-last *command-words* value)
         (shcl/core/parser:parser-value value)))))
  
  (defvar *empty-iterator*
  