      :try try
      :finally finally
      :name mname
-     :catch catch}))
+     :catch catch
+     :children (vec (mapcat block-children
+                            [try catch finally]))}))
 
 (defmethod parse 'def
   [op env form name]

                 ns-info (compile-file cljs-file output-file)]
             (recur (rest cljs-files) (conj output-files (assoc ns-info :file-name (.getPath output-file)))))
           output-files)))))

(defmulti children
  "Returns the children [exprs..] of an expression object. This will
   facilitate code walking without knowing the details of the op set."
  :op)

(defmethod children :if [ast]
  [(:test ast) (:then ast) (:else ast)])

(defmethod children :throw [ast]
  [(:throw ast)])

(defn- block-children [block]
  (let [statements (when-let [statements (:statements block)]
                     (vec statements))
        ret (when-let [ret (:ret block)]
              [ret])
        children (into statements ret)]
    (when-not (empty? children)
      children)))

(defmethod children :try* [ast]
  (vec (mapcat block-children
               [(:try ast)
                (:catch ast)
                (:finally ast)])))

(defmethod children :def [ast]
  (when-let [init (:init ast)]
    [init]))

(defmethod children :fn [ast]
  (vec (mapcat block-children (:methods ast))))

(defmethod children :do [ast]
  (block-children ast))

(defmethod children :let [ast]
  (let [inits (vec (map :init (:bindings ast)))]
    (into inits
          (block-children ast))))

(defmethod children :recur [ast]
  (:exprs ast))

(defmethod children :new [ast]
  (into [(:ctor ast)]
        (:args ast)))

(defmethod children :set! [ast]
  [(:target ast)
   (:val ast)])

(defmethod children :dot [ast]
  (into [(:target ast)]
        (:args ast)))

(defmethod children :js [ast]
  (vec (:args ast)))

(defmethod children :invoke [ast]
  (into [(:f ast)]
        (:args ast)))

(defmethod children :map [ast]
  (vec (interleave (:keys ast) (:vals ast))))
  
(defmethod children :vector [ast]
  (:items ast))

(defmethod children :set [ast]
  (:items ast))

(defmethod children :meta [ast]
  [(:meta ast) (:expr ast)])

(defmethod children :default [ast]
  nil)

(comment
  ;; compile-root

                               *loop-lets* (cons {:names (vec (map :name bes))} *loop-lets*))]
          (analyze-block (assoc env :context (if (= :expr context) :return context)) exprs))]
    {:env encl-env :op :let :loop is-loop
     :bindings bes :statements statements :ret ret :form form
     :children (into (vec (map :init bes))
                     (conj (vec statements) ret))}))

(defmethod parse 'let*
  [op encl-env form _]
