        (binding [*go-return-tag* (when (go-needs-coercion? tag *go-return-tag*)
                                    *go-return-tag*)]
          (emit-wrap env (emits (munge (cond ;; this runs munge in a different order from most other things.
-                                       (or (= ana/*cljs-ns*  (:ns info))
+                                       (or (= ana/*cljs-ns* ns)
                                            (:field info))
                                        (update-in info [:name] (comp go-public munge name))
-                                       (:ns info)
-                                       (update-in info [:name] #(str (:ns info) "."
-                                                                     (-> % name munge go-public)))
+                                       ns
+                                       (update-in info [:name] #(str ns "." (-> % name munge go-public)))
                                        :else info)))))))))
 (defmethod emit* :meta
   [{:keys [expr meta env]}]


(defmethod emit* :var
  [{:keys [info env tag] :as arg}]
  (let [info (cond-> info (and *go-dot* (:type info)) (update-in [:name] go-type-fqn))
        statement? (= :statement (:context env))]
    ; We need a way to write bindings out to source maps and javascript
    ; without getting wrapped in an emit-wrap calls, otherwise we get

    (binding [*go-return-tag* nil
              *go-dot* true]
      (emit-wrap env
        (emits "(&" (if (= 'goog (-> ctor :info :ns))
                      (normalize-goog-ctor ctor)
                      ctor) "{"
                      (comma-sep
                       (concat
                        (if-let [types (seq (map (comp :tag meta) fields))]
