anchor.diff:  
   This function returns an iterator of strings.  Each string represents
   text that could replace the token under point."
  -  (let ((token-iterator (shcl/core/lexer:token-iterator
  -                         (make-instance 'shcl/core/positional-stream:positional-input-stream
  +  (let ((token-iterator (token-iterator
  +                         (make-instance 'positional-input-stream
                                           :underlying-stream (make-string-input-stream input-text))
                            :readtable readtable))
           (tokens (make-extensible-vector))
           end-found)
       (do-iterator (token token-iterator)
  -      (let* ((token-start (shcl/core/positional-stream:position-record-offset
  -                           (shcl/core/lexer:token-position token)))
  -             (token-end (+ token-start (length (shcl/core/lexer:token-value token)))))
  +      (let* ((token-start (position-record-offset (token-position token)))
  +             (token-end (+ token-start (length (token-value token)))))
           (when (<= token-start cursor-point)
             (vector-push-extend token tokens))
           (when (>= token-end cursor-point)
  
positive.code: (defclass sigil-token ()
    ())
  
  (defmethod shcl/core/lexer: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
                              (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*)
           (seen-errors (make-hash-table :test 'eq))
           (suggestions (fset:empty-set)))
      (labels
  
negative.code:   *empty-iterator*)
  
  (defmethod completion-suggestions concatenate-iterables
      ((desired literal-token-class) token context)
    (let ((desired-string (literal-token-string desired))
          (token-value (token-value token)))
      (if (starts-with-p desired-string token-value)
          (list-iterator (list desired-string))
          *empty-iterator*)))
  
  (defun directory-p (at-fd path)
    (handler-case
        (receive-ref-counted-fd
            (file (retained-fd-openat at-fd path o-rdonly))
          (s-isdir (slot-value (fstat (fd-wrapper-value file)) 'st-mode)))
      (syscall-error ()
        nil)))
  
  (defun executable-p (at-fd path)
    (handler-case
        (progn
          (faccessat (fd-wrapper-value at-fd) path x-ok at-eaccess)
          t)
      (syscall-error ()
        nil)))
  
  (defmacro do-executables-in-dir-fd ((executable-name dir-fd &optional result) &body body)
  