remove :redef on protocol methods, they are never direct-linked

Author: frenchy64

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## NEXT
 
+- remove `:redef` on protocol methods, they are never direct-linked: https://ask.clojure.org/index.php/10967/are-protocol-methods-guaranteed-to-not-be-directly-linked?show=10990#a10990
+
 ## 1.2.0
 
 - [#95](https://github.com/dm3/clojure.java-time/issues/95) work around [CLJ-1796](https://clojure.atlassian.net/browse/CLJ-1796)

src/java_time/core.clj

@@ -4,86 +4,86 @@
            [java.time.chrono Chronology]))
 
 (defprotocol Amount
-  (^:redef zero? [a]
+  (zero? [a]
     "True if the amount is zero")
-  (^:redef negative? [a]
+  (negative? [a]
     "True if the amount is negative")
-  (^:redef negate [a]
+  (negate [a]
     "Negates a temporal amount:
 
       (negate (negate x)) == x")
-  (^:redef abs [a]
+  (abs [a]
     "Returns the absolute value of a temporal amount:
 
       (abs (negate x)) == (abs x)"))
 
 (defprotocol Supporting
-  (^:redef supports? [o p]
+  (supports? [o p]
     "True if the `o` entity supports the `p` property"))
 
 (defprotocol HasChronology
-  (^:redef ^java.time.chrono.Chronology chronology [o]
+  (^java.time.chrono.Chronology chronology [o]
     "The `Chronology` of the entity"))
 
 (defprotocol HasFields
-  (^:redef fields [o]
+  (fields [o]
     "Fields present in this temporal entity")
-  (^:redef field* [o k]
+  (field* [o k]
     "Internal use"))
 
 (defprotocol HasUnits
-  (^:redef units [o]
+  (units [o]
     "Units present in this temporal entity.")
-  (^:redef unit* [o k]
+  (unit* [o k]
     "Internal use"))
 
 (defprotocol HasProperties
-  (^:redef properties [o]
+  (properties [o]
     "Map of properties present in this temporal entity")
-  (^:redef property [o k]
+  (property [o k]
     "Property of this temporal entity under key `k`"))
 
 (defprotocol As
-  (^:redef as* [o k]
+  (as* [o k]
     "Value of property/unit identified by key/object `k` of the temporal
     entity `o`"))
 
 (defprotocol ReadableProperty
-  (^:redef value [p]
+  (value [p]
     "Value of the property"))
 
 (defprotocol ReadableRangeProperty
-  (^:redef range [p]
+  (range [p]
     "Range of values for this property")
-  (^:redef min-value [p]
+  (min-value [p]
     "Minimum value of this property")
-  (^:redef largest-min-value [p]
+  (largest-min-value [p]
     "Largest minimum value of this property")
-  (^:redef smallest-max-value [p]
+  (smallest-max-value [p]
     "Smallest maximum value of this property, e.g. 28th of February for months")
-  (^:redef max-value [p]
+  (max-value [p]
     "Maximum value of this property, e.g. 29th of February for months"))
 
 (defprotocol WritableProperty
-  (^:redef with-value [p v]
+  (with-value [p v]
     "Underlying temporal entity with the value of this property set to `v`"))
 
 (defprotocol WritableRangeProperty
-  (^:redef with-min-value [p]
+  (with-min-value [p]
     "Underlying temporal entity with the value set to the minimum available for
     this property")
-  (^:redef with-largest-min-value [p]
+  (with-largest-min-value [p]
     "Underlying temporal entity with the value set to the largest minimum
     available for this property")
-  (^:redef with-smallest-max-value [p]
+  (with-smallest-max-value [p]
     "Underlying temporal entity with the value set to the smallest maximum
     available for this property")
-  (^:redef with-max-value [p]
+  (with-max-value [p]
     "Underlying temporal entity with the value set to the maximum
     available for this property"))
 
 (defprotocol KnowsTimeBetween
-  (^:redef time-between [o e u]
+  (time-between [o e u]
     "Time between temporal entities `o` and `e` in unit `u`.
 
     ```
@@ -95,34 +95,34 @@
     ```"))
 
 (defprotocol KnowsIfLeap
-  (^:redef leap? [o]
+  (leap? [o]
     "True if the year of this entity is a leap year."))
 
 (defprotocol Truncatable
-  (^:redef truncate-to [o u]
+  (truncate-to [o u]
     "Truncates this entity to the specified time unit. Only works for units that
     divide into the length of standard day without remainder (up to `:days`)."))
 
 (defprotocol HasZone
-  (^:redef with-zone [o z]
+  (with-zone [o z]
     "Returns this temporal entity with the specified `ZoneId`"))
 
 (defprotocol Plusable
   "Internal"
-  (^:redef seq-plus [o os]))
+  (seq-plus [o os]))
 
 (defprotocol Minusable
   "Internal"
-  (^:redef seq-minus [o os]))
+  (seq-minus [o os]))
 
 (defprotocol Multipliable
-  (^:redef multiply-by [o v]
+  (multiply-by [o v]
     "Entity `o` multiplied by the value `v`"))
 
 (defprotocol Ordered
-  (^:redef single-before? [a b]
+  (single-before? [a b]
     "Internal use")
-  (^:redef single-after? [a b]
+  (single-after? [a b]
     "Internal use"))
 
 (defn as

src/java_time/graph.cljc

@@ -77,11 +77,11 @@
                          true))))))))))
 
 (defprotocol IConversionGraph
-  (^:redef get-conversion [_ src dst])
-  (^:redef assoc-conversion [_ src dst f cost])
-  (^:redef equivalent-targets [_ dst])
-  (^:redef possible-sources [_])
-  (^:redef possible-conversions [_ src]))
+  (get-conversion [_ src dst])
+  (assoc-conversion [_ src dst f cost])
+  (equivalent-targets [_ dst])
+  (possible-sources [_])
+  (possible-conversions [_ src]))
 
 (defn- expand [[a b]]
   (when-some [[bf & br] (seq b)] 

src/java_time/interval.clj

@@ -7,11 +7,11 @@
   (:import [java.time Instant Duration]))
 
 (defprotocol ^:private AnyInterval
-  (^:redef seq-move-start-by [i os]
+  (seq-move-start-by [i os]
     "Use `move-start-by` with vararags")
-  (^:redef seq-move-end-by [i os]
+  (seq-move-end-by [i os]
     "Use `move-end-by` with vararags")
-  (^:redef move-start-to [i new-start]
+  (move-start-to [i new-start]
    "Moves the start instant of the interval to the given instant (or something
    convertible to an instant):
 
@@ -26,7 +26,7 @@
    (move-start-to (interval 0 10000) (millis 15000))
    => DateTimeException...
    ```")
-  (^:redef move-end-to [i new-end]
+  (move-end-to [i new-end]
    "Moves the end of the interval to the given instant (or something
    convertible to an instant):
 
@@ -41,13 +41,13 @@
    (move-end-to (interval 0 10000) (millis -1))
    => DateTimeException...
    ```")
-  (^:redef start [i] "Gets the start instant of the interval")
-  (^:redef end [i] "Gets the end instant of the interval")
-  (^:redef contains? [i o] "True if the interval contains the given instant or interval")
-  (^:redef overlaps? [i oi] "True if this interval overlaps the other one")
-  (^:redef abuts? [i oi] "True if this interval abut with the other one")
-  (^:redef overlap [i oi] "Gets the overlap between this interval and the other one or `nil`")
-  (^:redef gap [i oi] "Gets the gap between this interval and the other one or `nil`"))
+  (start [i] "Gets the start instant of the interval")
+  (end [i] "Gets the end instant of the interval")
+  (contains? [i o] "True if the interval contains the given instant or interval")
+  (overlaps? [i oi] "True if this interval overlaps the other one")
+  (abuts? [i oi] "True if this interval abut with the other one")
+  (overlap [i oi] "Gets the overlap between this interval and the other one or `nil`")
+  (gap [i oi] "Gets the gap between this interval and the other one or `nil`"))
 
 ;;;;;;;;;;;;; ReadableInterval
 

src/java_time/temporal.clj

@@ -135,7 +135,7 @@
 ;;;;; FACTORY
 
 (defprotocol PropertyFactory
-  (^:redef mk-property [factory entity prop-key prop-obj]))
+  (mk-property [factory entity prop-key prop-obj]))
 
 (def default-field-property-factory
   (reify PropertyFactory

src/java_time/zone.clj

@@ -316,15 +316,15 @@
       (.toZonedDateTime cal))))
 
 (defprotocol HasOffset
-  (^:redef with-offset [o offset]
+  (with-offset [o offset]
     "Sets the offset to the specified value ensuring that the local time stays
     the same.
 
       (offset-time 10 30 0 0 +2)
       => #<java.time.OffsetTime 10:30+02:00>
       (with-offset *1 +3)
       => #<java.time.OffsetTime 10:30+03:00>")
-  (^:redef with-offset-same-instant [o offset]
+  (with-offset-same-instant [o offset]
     "Sets the offset to the specified value ensuring that the result has the same instant, e.g.:
 
       (offset-time 10 30 0 0 +2)