diff --git a/pkgs/racket-test-core/tests/racket/macro.rktl b/pkgs/racket-test-core/tests/racket/macro.rktl
index f35fe23962..4b751819ba 100644
--- a/pkgs/racket-test-core/tests/racket/macro.rktl
+++ b/pkgs/racket-test-core/tests/racket/macro.rktl
@@ -740,6 +740,9 @@
       (datum-case (dynamic-require ''check-transformer-lift 'd) (begin define-values ok)
         [(begin (define-values (lifted) 5) ok) #t]
         [x (datum x)]))
+(syntax-test #'(datum-case '(1 "x" -> y) (->) [(a b -> c) (define q 1)])
+             #rx"macro.rktl:.*no expression after a sequence of internal definitions")
+
 
 ;; ----------------------------------------
 ;; Check `#%variable-reference' expansion to make sure
diff --git a/pkgs/racket-test-core/tests/racket/stx.rktl b/pkgs/racket-test-core/tests/racket/stx.rktl
index e7fb519312..3ae21b5f1c 100644
--- a/pkgs/racket-test-core/tests/racket/stx.rktl
+++ b/pkgs/racket-test-core/tests/racket/stx.rktl
@@ -142,6 +142,13 @@
       (syntax-case #'#&(1 2 3) ()
                    [#&(x ...) #'(0 x ... 4)]))
 
+(syntax-test #'(syntax-case (syntax x) [x (define x 1)]))
+(syntax-test #'(syntax-case (syntax x) () [x (define x 1)])
+             #rx"stx.rktl:.*no expression after a sequence of internal definitions")
+(syntax-test #'(syntax-case* (syntax x) () eq? [x (define x 1)])
+             #rx"stx.rktl:.*no expression after a sequence of internal definitions")
+
+
 ;; ----------------------------------------
 
 (test #t syntax-original? #'here)
diff --git a/racket/collects/racket/private/stxloc.rkt b/racket/collects/racket/private/stxloc.rkt
index b11275697b..0e0082a699 100644
--- a/racket/collects/racket/private/stxloc.rkt
+++ b/racket/collects/racket/private/stxloc.rkt
@@ -6,26 +6,34 @@
   (#%require "qq-and-or.rkt" "stxcase.rkt" "define-et-al.rkt"
              (for-syntax '#%kernel "stxcase.rkt" "sc.rkt"))
 
+  (begin-for-syntax
+    (define-values (transform-to-syntax-case**)
+      (lambda (stx sc arg-is-stx? expr kws lit-comp s-exp? clauses)
+        ((λ (ans) (datum->syntax #'here ans stx))
+         (list* 'syntax-case** sc arg-is-stx? expr kws lit-comp s-exp?
+                clauses)))))
+  
   ;; Like regular syntax-case, but with free-identifier=? replacement
   (-define-syntax syntax-case*
     (lambda (stx)
       (syntax-case** #f #t stx () free-identifier=? #f
-	[(sc stxe kl id=? clause ...)
-	 (syntax (syntax-case** sc #f stxe kl id=? #f clause ...))])))
+	[(sc stxe kl id=? . clause)
+         (transform-to-syntax-case** stx #'sc #f #'stxe #'kl #'id=? #f #'clause)])))
 
   ;; Regular syntax-case
   (-define-syntax syntax-case
     (lambda (stx)
       (syntax-case** #f #t stx () free-identifier=? #f
-	[(sc stxe kl clause ...)
-	 (syntax (syntax-case** sc #f stxe kl free-identifier=? #f clause ...))])))
+	[(sc stxe kl . clause)
+         (transform-to-syntax-case** stx #'sc #f #'stxe #'kl #'free-identifier=? #f
+                                     #'clause)])))
 
   ;; Like `syntax-case, but on plain datums
   (-define-syntax datum-case
     (lambda (stx)
       (syntax-case** #f #t stx () free-identifier=? #f
-	[(sc stxe kl clause ...)
-	 (syntax (syntax-case** sc #f stxe kl eq? #t clause ...))])))
+	[(sc stxe kl . clause)
+	 (transform-to-syntax-case** stx #'sc #f #'stxe #'kl #'eq? #t #'clause)])))
 
   (-define (relocate loc stx)
     (if (or (syntax-source loc)