Ticket #584: define-external-no-optimization.patch

compiler.scm

@@ -1140 +1140 @@
                         ((##core#foreign-callback-wrapper)
                          (let-values ([(args lam) (split-at (cdr x) 4)])
                            (let* ([lam (car lam)]
-                                  [name (cadr (first args))]
+                                  [raw-c-name (cadr (first args))]
+                                  [name (##sys#alias-global-hook raw-c-name #t dest)]
                                   [rtype (cadr (third args))]
                                   [atypes (cadr (fourth args))]
                                   [vars (second lam)] )
-                             (if (valid-c-identifier? name)
+                             (if (valid-c-identifier? raw-c-name)
                                  (set! callback-names (cons name callback-names))
                                  (quit "name `~S' of external definition is not a valid C identifier"
-                                       name) )
+                                       raw-c-name) )
                              (when (or (not (proper-list? vars)) 
                                        (not (proper-list? atypes))
                                        (not (= (length vars) (length atypes))) )

tests/compiler-tests.scm

@@ -137 +137 @@
 ((foreign-safe-lambda* void () 
    "print_foo(\"bar\");"))
 
+;; Unused arguments in foreign callback wrappers are not optimized away
+(module bla (foo)
+
+(import chicken scheme foreign)
+
+(define-external
+  (blabla (int a) (c-string b) (int c) (int d) (c-string e) (int f))
+  int
+  f)
+
+(define (foo) ((foreign-safe-lambda* int () "C_return(blabla(1, \"2\", 3, 4, \"5\", 6));")))
+)
+
+(import bla)
+(assert (= (foo) 6))
 
 ;;; compiler-syntax for map/for-each must be careful when the
 ;   operator may have side-effects (currently only lambda exprs and symbols