eval-when not giving me what I hoped for

[Matt Wette]

I am trying to get a macro to expand at compile time using eval-when, but it’s 
not giving me what I expect:

        (eval-when (expand) (make-regexp pat)) …

gets expanded to:

        (if #f #f)

I would like to see something like 

        #<regexp 1098a2d40>

Any help would be appreciated. — Matt

I get the same (if #f #f) result whether I use (expand) or (compile).

Below is 
1) my macro (missing the helpers all-const-string? and rx-let)
2) the macro I use to compile to il-tree and then back to scheme 
3) the demo code 
4) the output from expand

=== my macro ==========================
(define-syntax regexp-case
  (lambda (x)
    (syntax-case x (else)
      ((_ str ((pat v ...) exp ...) ... (else else-exp ...))
       (with-syntax (((id ...) (generate-temporaries #'(pat ...))))
         (all-const-string? #'(pat ...))
         #'(let ((id (eval-when (expand) (make-regexp pat))) ...)
             (cond
              ((regexp-exec id str) =>
               (lambda (m) (rx-let m (v ...) exp ...)))
              ...
              (else else-exp ...)))))
      ((_ str ((pat v ...) exp ...) ...)
       (with-syntax (((id ...) (generate-temporaries #'(pat ...))))
         (all-const-string? #'(pat ...))
         #'(let ((id (eval-when (expand) (make-regexp pat))) ...)
             (cond
              ((regexp-exec id str) =>
               (lambda (m) (rx-let m (v ...) exp ...)))
              ...
              (else
               (scm-error #f "regexp-case"
                          "no match found: ~S" (list str)
                          #f)))))))))

=== the expand macro =======================
#:use-module (srfi srfi-11)
#:use-module (system base compile)

(define* (expand-form e #:key (opts '()))
  (let-values (((exp env) (decompile
                           (compile e #:from 'scheme
                                    #:to 'tree-il
                                    #:env (current-module))
                           #:from 'tree-il
                           #:to 'scheme
                           #:opts opts)))
    exp))

(define-syntax-rule (expand _expression_)
  (expand-form '_expression_))

=== orig test case ================
  (regexp-case str
    (("^([a-z]+)\\(([0-9]+)\\)$" v i)
     (list v i))
    (("^([a-z]+)$" v)
     (list v "1")))

=== output from expand =============

(let ((t-768 (if #f #f))
      (t-769 (if #f #f)))
  (let ((t (regexp-exec t-768 str)))
    (if t
      (let ((m t))
        (let ((v (match:substring m 1))
              (i (match:substring m 2)))
          (list v i)))
      (let ((t (regexp-exec t-769 str)))
        (if t
          (let* ((m t) (v (match:substring m 1)))
            (list v "1"))
          (scm-error
            #f
            "regexp-case"
            "no match found: ~S"
            (list str)
            #f))))))