Sure

Author: chrisrink10

src/basilisp/core.lpy

@@ -6961,7 +6961,7 @@
                                                                                           (dissoc! m k)))
                                                                                       (transient (.- self -proxy-mappings)))
                                                                              (persistent!))]
-                                                   (set! (.- self -proxy-mappings) updated-mappings)
+                                                   (. self (_set_proxy_mappings updated-mappings))
                                                    nil))
                       "_proxy_mappings"        nil}
 
@@ -7053,7 +7053,6 @@
       (. proxy (_update-proxy-mappings mappings))
       proxy)))
 
-;; TODO: kwargs on supertypes
 ;; TODO: check interface/superclass method membership
 (defmacro proxy
   "Create a new proxy class instance.
@@ -7082,26 +7081,39 @@
        ([arg1] ...)
        ([arg1 & others] ...))
 
+  .. note::
+
+     Proxy override methods can be defined with Python keyword argument support since
+     they are just standard Basilisp functions. See :ref:`basilisp_functions_with_kwargs`
+     for more information.
+
   .. warning::
 
      The ``proxy`` macro does not verify that the provided override implementations
      arities match those of the method being overridden."
   [class-and-interfaces args & fs]
   (let [formatted-single (fn [method-name [arg-vec & body]]
-                           [(munge method-name)
-                            (apply list 'fn method-name (vec (concat ['this] arg-vec)) body)])
+                           (apply list
+                                  'fn
+                                  method-name
+                                  (with-meta (vec (concat ['this] arg-vec)) (meta arg-vec))
+                                  body))
         formatted-multi  (fn [method-name & arities]
-                           [(munge method-name)
-                            (apply list
-                                   'fn
-                                   method-name
-                                   (map (fn [[arg-vec & body]]
-                                          (apply list (vec (concat ['this] arg-vec)) body))
-                                        arities))])
-        methods          (map (fn [[method-name & body]]
-                                (if (vector? (first body))
-                                  (formatted-single method-name body)
-                                  (apply formatted-multi method-name body)))
+                           (apply list
+                                  'fn
+                                  method-name
+                                  (map (fn [[arg-vec & body]]
+                                         (apply list
+                                                (with-meta (vec (concat ['this] arg-vec)) (meta arg-vec))
+                                                body))
+                                       arities)))
+        methods          (map (fn [[method-name & body :as form]]
+                                [(munge method-name)
+                                 (with-meta
+                                   (if (vector? (first body))
+                                     (formatted-single method-name body)
+                                     (apply formatted-multi method-name body))
+                                   (meta form))])
                               fs)
         method-map       (reduce* (fn [m [method-name method]]
                                     (if-let [existing-method (get m method-name)]

tests/basilisp/test_proxies.lpy

@@ -37,9 +37,10 @@
 
 (deftest proxy-test
   (testing "disallows duplicate method overrides"
-    (proxy [Describable] []
-      (describe-me [] "I'm a proxy")
-      (describe-me [] "Proxy")))
+    (is (thrown? basilisp.lang.compiler/CompilerException
+                 (eval '(proxy [Describable] []
+                          (describe-me [] "I'm a proxy")
+                          (describe-me [] "Proxy"))))))
 
   (testing "multi-arity interface methods"
     (let [p (proxy [ConcreteToString] [1]