Change local type representation and remove var type

module/language/cps/compile-js.scm

@@ -74,36 +74,32 @@
        (make-continuation
         (cons (make-id self) ids)
         (match body
-          (($ $cont k _)
+          (($ $cont k cont)
-           (make-local (list (compile-cont body))
+           (make-local `((,(make-kid k) . ,(compile-cont cont)))
                        (make-continue (make-kid k) ids)))))))))
 
 (define (compile-term term)
   (match term
-    (($ $letk conts body)
+    (($ $letk (($ $cont ks conts) ...) body)
-     (make-local (map compile-cont conts) (compile-term body)))
+     (make-local (map (lambda (k cont)
+                        (cons (make-kid k)
+                              (compile-cont cont)))
+                      ks
+                      conts)
+                 (compile-term body)))
     (($ $continue k src exp)
      (compile-exp exp k))))
 
 (define (compile-cont cont)
   (match cont
-    (($ $cont k ($ $kargs names syms body))
+    (($ $kargs names syms body)
-     ;; use the name part?
+     (make-continuation (map make-id syms) (compile-term body)))
-     (make-var (make-kid k)
+    (($ $kreceive ($ $arity req _ (? symbol? rest) _ _) k2)
-               (make-continuation (map make-id syms)
+     (let ((ids (map make-id (append req (list rest)))))
-                                  (compile-term body))))
+       (make-continuation ids (make-continue (make-kid k2) ids))))
-    (($ $cont k ($ $kreceive ($ $arity req _ (? symbol? rest) _ _) k2))
+    (($ $kreceive ($ $arity req _ #f _ _) k2)
-     (make-var
+     (let ((ids (map make-id req)))
-      (make-kid k)
+       (make-continuation ids (make-continue (make-kid k2) ids))))))
-      (make-continuation (append (map make-id req) (list (make-id rest)))
-                         (make-continue (make-kid k2)
-                                        (append (map make-id req)
-                                                (list (make-id rest)))))))
-    (($ $cont k ($ $kreceive ($ $arity req _ #f _ _) k2))
-     (make-var (make-kid k)
-               (make-continuation (map make-id req)
-                                  (make-continue (make-kid k2)
-                                                 (map make-id req)))))))
 
 (define (compile-exp exp k)
  (match exp

module/language/js-il.scm

@@ -7,7 +7,6 @@
             make-params params
             make-continuation continuation
             make-local local
-            make-var var
             make-continue continue
             make-const const
             make-primcall primcall
@@ -55,7 +54,6 @@
 (define-js-type params self req opt rest kw allow-other-keys?)
 (define-js-type continuation params body)
 (define-js-type local bindings body) ; local scope
-(define-js-type var id exp)
 (define-js-type continue cont args)
 (define-js-type const value)
 (define-js-type primcall name args)
@@ -96,9 +94,12 @@
                     kws)
               ,allow-other-keys?))
     (($ local bindings body)
-     `(local ,(map unparse-js bindings) ,(unparse-js body)))
+     `(local ,(map (match-lambda
-    (($ var id exp)
+                    ((a . d)
-     `(var ,id ,(unparse-js exp)))
+                     (cons (unparse-js a)
+                           (unparse-js d))))
+                   bindings)
+             ,(unparse-js body)))
     (($ continue ($ kid k) args)
      `(continue ,k ,(map unparse-js args)))
     (($ branch test then else)

module/language/js-il/compile-javascript.scm

@@ -149,11 +149,13 @@
                           clauses)
                      (list (compile-jump-table clauses)))))
 
-    (($ il:local bindings body)
+    (($ il:local ((ids . bindings) ...) body)
-     (make-block (append (map compile-exp bindings) (list (compile-exp body)))))
+     (make-block
-
+      (append (map (lambda (id binding)
-    (($ il:var id exp)
+                     (make-var (rename-id id) (compile-exp binding)))
-     (make-var (rename-id id) (compile-exp exp)))
+                   ids
+                   bindings)
+              (list (compile-exp body)))))
 
     (($ il:continue k exps)
      (make-return (make-call (compile-id k) (map compile-exp exps))))

module/language/js-il/inlining.scm

@@ -31,12 +31,11 @@
        (analyse body))
 
       (($ local bindings body)
-       (for-each analyse bindings)
+       (for-each (match-lambda
+                  ((i . b) (analyse b)))
+                 bindings)
        (analyse body))
 
-      (($ var id exp)
-       (analyse exp))
-
       (($ continue ($ kid cont) args)
        (count-inc! cont)
        (for-each analyse args))
@@ -103,12 +102,12 @@
 
   (define (split-inlinable bindings)
     (partition (match-lambda
-                (($ var ($ kid id) _) (inlinable? id)))
+                ((($ kid id) . _) (inlinable? id)))
                bindings))
 
   (define (lookup kont substs)
     (match substs
-      ((($ var ($ kid id) exp) . rest)
+      (((($ kid id) . exp) . rest)
        (if (= id kont)
            exp
            (lookup kont rest)))
@@ -140,7 +139,7 @@
          (($ continuation kargs body)
           (if (not (= (length args) (length kargs)))
               (throw 'args-dont-match cont args kargs)
-              (make-local (map make-var kargs args)
+              (make-local (map cons kargs args)
                           ;; gah, this doesn't work
                           ;; identifiers need to be separated earlier
                           ;; not just as part of compilation
@@ -162,13 +161,12 @@
              (split-inlinable bindings))
          (lambda (new-substs uninlinable-bindings)
            (define substs* (append new-substs substs))
-           (make-local (map (lambda (x) (inline x substs*))
+           (make-local (map (match-lambda
+                             ((id . val)
+                              `(,id . ,(inline val substs*))))
                             uninlinable-bindings)
                        (inline body substs*)))))
 
-      (($ var id exp)
-       (make-var id (inline exp substs)))
-
       (($ seq body)
        (make-seq (map (lambda (x) (inline x substs))
                       body)))