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

       (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))
                                           (:field info))
                                       (update-in info [:name] (comp go-public munge name))
                                       (:ns info)
                                       (update-in info [:name] #(str (:ns info) "."
                                                                     (-> % name munge go-public)))
                                       :else info)))))))))
(defmethod emit* :meta
  [{:keys [expr meta env]}]


(defmethod emit* :var
  [{:keys [info env tag] :as arg}]
  (let [ns (and (symbol? (:name info)) (some-> info :name namespace symbol))
        info (cond-> info (and *go-dot* (:type info)) (update-in [:name] #(symbol (str ns) (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
