anchor.diff:  (defclass sigil-token ()
     ())
   
  -(defmethod shcl/core/lexer:token-value ((sigil sigil-token))
  +(defmethod token-value ((sigil sigil-token))
     nil)
   
   (defun completion-suggestions-for-tokens (leading-tokens token-to-complete context)
     (let* ((*collect-tab-complete-info* t)
            (sigil-token (make-instance 'sigil-token))
  -         (command-iterator (shcl/core/shell-grammar:command-iterator
  +         (command-iterator (command-iterator
                               (lookahead-iterator-wrapper
                                (concatenate-iterables
                                 leading-tokens
                                 (list sigil-token)))))
  -         (shcl/core/shell-grammar:*intermediate-parse-error-hook*
  -          shcl/core/shell-grammar:*intermediate-parse-error-hook*)
  +         (*intermediate-parse-error-hook* *intermediate-parse-error-hook*)
            (seen-errors (make-hash-table :test 'eq))
            (suggestions (fset:empty-set)))
       (labels
  
positive.code:                ;; 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)
        (handler-case
            (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))))
        suggestions)))
  
  (defun completion-suggestions-for-input (input-text cursor-point readtable)
  
negative.code: 
  (defun all-binary-commands ()
    (let ((result-vector (make-extensible-vector)))
      (do-iterator (path (colon-list-iterator $path))
        (when (equal "" path)
          (setf path "."))
        (vector-push-extend (executables-in-directory path) result-vector))
      (concatenate-iterable-collection result-vector)))
  
  (defmethod completion-suggestions concatenate-iterables
      ((desired (eql (find-class 'simple-word)))
       (token simple-word)
       context)
    (unless *command-words*
      (return-from completion-suggestions))
  