(import (rnrs))
(define-syntax doit
  (lambda (stx)
    (define def '(define a 123))
    (syntax-case stx ()
      ((k)
       (datum->syntax (syntax k) def)))))
(doit)
(write a)
(newline)

works; so, given:

(library (lib)
  (export
    alpha make-alpha alpha-a
    beta  make-beta  beta-b
    gamma make-gamma)
  (import (rnrs))
  (define-record-type alpha
    (fields (mutable a)))
  (define-record-type beta
    (parent alpha)
    (fields (mutable b)))
  (define-record-type gamma
    (parent beta)))

I want to automatically generate an equivalent of:

(import (rnrs)
  (lib))

(define gamma-a alpha-a)
(define gamma-b beta-b)

I do:

(import (rnrs)
  (for (lib) expand run))

(define-syntax make-record-accessor-aliases
  (syntax-rules ()
    ((_ ?record-name)
     (let-syntax
         ((A (lambda (stx)

               (define (make-record-accessor-aliases k rtd)
                 (let ((rtd-name (symbol->string (record-type-name rtd))))
                   (let process-parent ((parent-rtd (record-type-parent rtd))
                                        (result     '()))
                     (if parent-rtd
                         (let* ((slots  (record-type-field-names parent-rtd))
                                (len    (vector-length slots)))
                           (let make-def ((i    0)
                                          (defs '()))
                             (if (= i len)
                                 (process-parent (record-type-parent parent-rtd)
                                                 (append defs result))
                               (make-def (+ 1 i)
                                         (cons
                 (make-accessor k rtd-name
                 parent-rtd slots i)
                                               defs)))))
                       (begin
                         ;; (write result)
                         ;; (newline)
                         result)))))

               (define (make-accessor k rtd-name parent-rtd slots i)
                 (let ((accessor-name
                         (slot-name->accessor-name rtd-name
                                                   (vector-ref slots i)))
                       (accessor-proc
                         (record-accessor parent-rtd i)))
                   (datum->syntax k
                      `(define ,accessor-name ',accessor-proc))))

               (define (slot-name->accessor-name rtd-name slot-name)
                 (string->symbol (string-append rtd-name "-"
                                     (symbol->string slot-name))))

               (syntax-case stx ()
                 ((k)
                  (with-syntax (((B (... ...))
                                 (make-record-accessor-aliases
                                    (syntax k)
                                    (record-type-descriptor ?record-name))))
                    (syntax (begin B (... ...)))))))))
       (A)))))

(make-record-accessor-aliases gamma)
(define o (make-gamma 1 2))

which evaluates with no errors, but then:

(gamma-a o)

raises  a  "gamma-a unbound  identifier"  error.   I do  not
understand the difference between  the two cases; I tried to
structure the  second case as the  INCLUDE syntax example[1]
in the R6RS document, but I cannot spot the difference.

Suggestions?