optimizer: another ((begin ... proc) x) to (begin ... (proc x))

The tranformation this time applies before optimization of the rator
and complements Gustavo's variant, which applies after optimization of
the rator.

pkgs/racket-pkgs/racket-test/tests/racket/optimize.rktl

@@ -1021,6 +1021,35 @@
               (begin 
                 (read)
                 (+ z z))))
+(test-comp '(lambda (g z)
+              (let ([get (lambda ()
+                           (begin
+                             (read)
+                             (lambda (x) (+ z z))))])
+                ((get) g)))
+           '(lambda (g z)
+              (begin
+                (read)
+                (+ z z))))
+(test-comp '(lambda ()
+              (let ([a (display "a")]
+                    [g (lambda (x) x)])
+                (list
+                 ((begin
+                    (display "b")
+                    g)
+                  a)
+                 g
+                 g)))
+           '(lambda ()
+              (let ([a (display "a")]
+                    [g (lambda (x) x)])
+                (list
+                 (begin
+                   (display "b")
+                   a)
+                 g
+                 g))))
 
 (test-comp '(lambda (w z)
               (let ([x (cons w z)])

racket/src/racket/src/optimize.c

@@ -2161,6 +2161,16 @@ static Scheme_Object *check_app_let_rator(Scheme_Object *app, Scheme_Object *rat
     return scheme_optimize_expr((Scheme_Object *)head, info, context);
   }
 
+  /* Convert ((begin .... E) arg ...) to (begin .... (E arg ...)). */
+  if (SAME_TYPE(SCHEME_TYPE(rator), scheme_sequence_type)) {
+    Scheme_Sequence *seq = (Scheme_Sequence *)rator;
+
+    reset_rator(app, seq->array[seq->count - 1]);
+    seq->array[seq->count-1] = app;
+
+    return scheme_optimize_expr((Scheme_Object *)seq, info, context);
+  }
+
   return NULL;
 }