         (if (or (not (symbol? op))
                 (specials op))
           form
-          (let [clj-macro (maybe-macro op env)]
-            (if (and clj-macro
-                     ;; (not (resolve-var op env))
-                     (not (-> env :locals (get op))))
-              (with-bindings (merge {#'c.c/*ns* (create-ns *ns*)}
-                                    (when-not (thread-bound? #'*ns*)
-                                      {#'*ns* *ns*}))
-                (let [ret (apply clj-macro form env (rest form))] ; (m &form &env & args)
-                  (if (and (seq? ret)
-                           (= 'js* (first ret)))
-                    (vary-meta ret merge
-                               (when (-> clj-macro meta :cljs.core/numeric)
-                                 {:tag 'number}))
-                    ret)))
-              (desugar-host-expr form env)))))
-      (desugar-host-expr form env))))
+          (if-let [clj-macro (and (not (-> env :locals (get op)))
+                                  (maybe-macro op env))]
+            (with-bindings (merge {#'c.c/*ns* (create-ns *ns*)}
+                                  (when-not (thread-bound? #'*ns*)
+                                    {#'*ns* *ns*}))
+              (let [ret (apply clj-macro form env (rest form))] ; (m &form &env & args)
+                (if (and (seq? ret)
+                         (= 'js* (first ret)))
+                  (vary-meta ret merge
+                             (when (-> clj-macro meta :cljs.core/numeric)
+                               {:tag 'number}))
+                  ret)))
+            (with-meta (desugar-host-expr form env) (meta form)))))
+      (with-meta (desugar-symbol form env) (meta form)))))
 
 (defn create-var
   [sym {:keys [ns]}]

    "cljs.core"
    ns))

(defn ns-resolve [ns sym]
  (let [ns (if (string? ns)
             (symbol ns)

  (let [ns (fix-ns (namespace form))
        n (name form)
        form (symbol ns n)]
    (if (dotted-symbol? form env)
      (let [idx (.indexOf n ".")
            sym (symbol ns (.substring n 0 idx))]
        (list '. sym (symbol (str "-" (.substring n (inc idx) (count n))))))

      form)))

(defn desugar-host-expr [form env]
  (if (symbol? (first form))
    (let [[op & expr] form
          opname (name op)
          opns   (namespace op)]
      (cond

       ;; (.foo bar ..) -> (. bar foo ..)
       (= (first opname) \.)
       (let [[target & args] expr
             args (list* (symbol (subs opname 1)) args)]
         (list '. target (if (= 1 (count args))
                           (first args) args)))

       ;; (foo. ..) -> (new foo ..)
       (= (last opname) \.)
       (let [op-s (str op)]
         (list* 'new (symbol (subs op-s 0 (dec (count op-s)))) expr))

       ;; (var.foo ..) -> (. var foo ..)
       (dotted-symbol? op env)
       (let [idx (.indexOf opname ".")
             sym (symbol opns (.substring opname 0 idx))]
         (list '. sym (list* (symbol (.substring opname (inc idx) (count opname))) expr)))

       :else (list* (fix-symbol op) expr)))
    form))

(defn macroexpand-1 [form env]
  (env/ensure (global-env)
