remove most dynamic call sites

Author: spacepluk

Clojure/Clojure.Source/clojure/clr/io.clj

@@ -13,7 +13,7 @@
     clojure.clr.io
     (:import 
      (System.IO 
-       Stream  BufferedStream 
+       Stream
        FileInfo  FileStream  MemoryStream
        FileMode FileShare FileAccess FileOptions
        BinaryReader BinaryWriter
@@ -39,16 +39,16 @@
   (as-uri [_] nil)
 
   String
-  (as-file [s] (FileInfo. s))
-  (as-uri [s] (Uri. s))
+  (as-file [^String s] (FileInfo. s))
+  (as-uri [^String s] (Uri. s))
 
   FileInfo
-  (as-file [f] f)
-  (as-uri [f] (Uri. (str "file://" (.FullName f))))
+  (as-file [^FileInfo f] f)
+  (as-uri [^FileInfo f] (Uri. (str "file://" (.FullName f))))
 
   Uri
-  (as-uri [u] u)
-  (as-file [u] 
+  (as-uri [^Uri u] u)
+  (as-file [^Uri u]
 	(if (.IsFile u)
 	  (as-file (.LocalPath u))
       (throw (ArgumentException. (str "Not a file: " u))))))
@@ -294,7 +294,7 @@
                      (file-mode :read opts) 
                      (file-access :read opts) 
                      (file-share opts) 
-                     (buffer-size opts) 
+                     ^int (buffer-size opts) 
                      (file-options opts)) 
          opts))
     :make-output-stream (fn [^FileInfo x opts] 
@@ -303,7 +303,7 @@
                      (file-mode :write opts) 
                      (file-access :write opts) 
                      (file-share opts) 
-                     (buffer-size opts) 
+                     ^int (buffer-size opts) 
                      (file-options opts)) 
          opts))))
 

Clojure/Clojure.Source/clojure/core.clj

@@ -346,7 +346,7 @@
   "Throws a ClassCastException if x is not a c, else returns x."
   {:added "1.0"
    :static true}
-  [^Type c x]   ;;; changed Class to Type
+  [^Type c ^Object x]   ;;; changed Class to Type
    (if (clojure.lang.Util/identical x nil) nil (if (. c (IsInstanceOfType x)) x (throw  (InvalidCastException. (.ToString (.GetType x)))))))  ;;;  original (. c (cast x)))     
 
 (defn vector
@@ -826,9 +826,9 @@
   compares numbers and collections in a type-independent manner. x
   must implement Comparable"
   {
-   :inline (fn [x y] `(. clojure.lang.Util compare ~x ~y))
+   :inline (fn [^Object x ^Object y] `(clojure.lang.Util/compare ~x ~y))
    :added "1.0"}
-  [x y] (. clojure.lang.Util (compare x y)))
+  [^Object x ^Object y] (clojure.lang.Util/compare x y))
 
 (defmacro and
   "Evaluates exprs one at a time, from left to right. If a form
@@ -1766,7 +1766,7 @@
 (defmacro defmethod
   "Creates and installs a new method of multimethod associated with dispatch-value. "
   {:added "1.0"}
-  [multifn dispatch-val & fn-tail]
+  [^clojure.lang.MultiFn multifn dispatch-val & fn-tail]
   `(. ~(with-meta multifn {:tag 'clojure.lang.MultiFn}) addMethod ~dispatch-val (fn ~@fn-tail)))
 
 (defn remove-all-methods
@@ -1780,15 +1780,15 @@
   "Removes the method of multimethod associated	with dispatch-value."
   {:added "1.0"
    :static true}
- [multifn dispatch-val]
+ [^clojure.lang.MultiFn multifn dispatch-val]
  (. multifn removeMethod dispatch-val))
 
 (defn prefer-method
   "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y 
    when there is a conflict"  
   {:added "1.0"
    :static true}
-  [multifn dispatch-val-x dispatch-val-y]
+  [^clojure.lang.MultiFn multifn dispatch-val-x dispatch-val-y]
   (. multifn preferMethod dispatch-val-x dispatch-val-y))
 
 (defn methods
@@ -2438,7 +2438,7 @@
   {:added "1.1"
    :static true}
  ([^clojure.lang.Ref ref]
-   (.getMinHistory ref))
+   (.MinHistory ref))
  ([^clojure.lang.Ref ref n]
    (.setMinHistory ref n)))
 
@@ -2447,7 +2447,7 @@
   {:added "1.1"
    :static true}
  ([^clojure.lang.Ref ref]
-   (.getMaxHistory ref))
+   (.MaxHistory ref))
  ([^clojure.lang.Ref ref n]
    (.setMaxHistory ref n)))
 
@@ -3598,10 +3598,10 @@
        (instance? clojure.lang.BigInt x) x
        (instance? BigInteger x) (clojure.lang.BigInt/fromBigInteger x)
        (decimal? x) (bigint (.ToBigInteger ^BigDecimal x))
-	   (float? x) (bigint (BigDecimal/Create (double x)))                        ;;; (. BigDecimal valueOf (double x))
+	   (float? x) (bigint (clojure.lang.BigDecimal/Create (double x)))                        ;;; (. BigDecimal valueOf (double x))
        (ratio? x) (bigint (.BigIntegerValue ^clojure.lang.Ratio x))
-       (number? x) (clojure.lang.BigInt/valueOf (long x))   (string? x) (bigint (BigInteger/Parse ^String x))   ;; DM: Added string clause
-       :else (bigint (BigInteger. x))))
+       (number? x) (clojure.lang.BigInt/valueOf (long x))   (string? x) (bigint (clojure.lang.BigInteger/Parse ^String x))   ;; DM: Added string clause
+       :else (bigint (clojure.lang.BigInteger. x))))
 
 (defn biginteger
   "Coerce to BigInteger"
@@ -3612,10 +3612,11 @@
        (instance? BigInteger x) x
 	   (instance? clojure.lang.BigInt x) (.toBigInteger ^clojure.lang.BigInt x)
        (decimal? x) (.ToBigInteger ^BigDecimal x)                                ;;; toBigInteger
-	   (float? x) (.ToBigInteger (BigDecimal/Create (double x)))                 ;;; (.toBigInteger (. BigDecimal valueOf (double x)))
+	   (float? x) (.ToBigInteger (clojure.lang.BigDecimal/Create (double x)))                 ;;; (.toBigInteger (. BigDecimal valueOf (double x)))
        (ratio? x) (.BigIntegerValue ^clojure.lang.Ratio x)
-       (number? x) (BigInteger/Create (long x))      (string? x) (bigint (BigInteger/Parse ^String x))          ;;;(BigInteger/valueOf (long x))  DM: Added string clause
-       :else (BigInteger. x)))
+       (number? x) (clojure.lang.BigInteger/Create (long x))
+       (string? x) (bigint (clojure.lang.BigInteger/Parse ^String x))          ;;;(BigInteger/valueOf (long x))  DM: Added string clause
+       :else (clojure.lang.BigInteger. x)))
 
 (defn bigdec
   "Coerce to BigDecimal"
@@ -3624,12 +3625,13 @@
    :static true}
   [x] (cond
        (decimal? x) x
-       (float? x) (BigDecimal/Create (double x))                                          ;;; (. BigDecimal valueOf (double x))
-       (ratio? x) (/ (BigDecimal/Create (.numerator ^clojure.lang.Ratio x)) (.denominator ^clojure.lang.Ratio x))     ;;; (/ (BigDecimal. (.numerator ^clojure.lang.Ratio x)) (.denominator ^clojure.lang.Ratio x))
+       (float? x) (clojure.lang.BigDecimal/Create (double x))                                          ;;; (. BigDecimal valueOf (double x))
+       (ratio? x) (/ (clojure.lang.BigDecimal/Create (.numerator ^clojure.lang.Ratio x)) (.denominator ^clojure.lang.Ratio x))     ;;; (/ (BigDecimal. (.numerator ^clojure.lang.Ratio x)) (.denominator ^clojure.lang.Ratio x))
        (instance? clojure.lang.BigInt x) (.ToBigDecimal ^clojure.lang.BigInt x)           ;;; .ToBigDecimal
-       (instance? BigInteger x) (BigDecimal/Create ^BigInteger x)                         ;;; (BigDecimal. ^BigInteger x)
-       (number? x) (BigDecimal/Create (long x))                                           ;;; (BigDecimal/valueOf (long x))
-       :else  (BigDecimal/Create x)))                                                     ;;; (BigDecimal. x)))
+       (instance? BigInteger x) (clojure.lang.BigDecimal/Create ^BigInteger x)                         ;;; (BigDecimal. ^BigInteger x)
+       (number? x) (clojure.lang.BigDecimal/Create (long x))                                           ;;; (BigDecimal/valueOf (long x))
+       :else  (throw (InvalidCastException. (str "Cannot cast " (type x) " to BigDecimal.")))
+       ))                                                     ;;; (BigDecimal. x)))
 
 (def ^:dynamic ^{:private true} print-initialized false)
 
@@ -3857,25 +3859,25 @@ Note that read can execute code (controlled by *read-eval*),
 (defn aget
   "Returns the value at the index/indices. Works on Java arrays of all
   types."
-  {:inline (fn [a i] `(. clojure.lang.RT (aget ~a (int ~i))))
+  {:inline (fn [^Array a i] `(. clojure.lang.RT (aget ~a (int ~i))))
    :inline-arities #{2}
    :added "1.0"}
-  ([array idx]
-   (clojure.lang.Reflector/prepRet (.GetElementType (class array)) (. array (GetValue idx))))  ;;; was .getComponentType (. Array (get array idx)))  
-  ([array idx & idxs]
-   (apply aget (aget array idx) idxs)))
+  ([^Array array idx]
+   (clojure.lang.Reflector/prepRet (.GetElementType (class array)) (. array (GetValue (int idx)))))  ;;; was .getComponentType (. Array (get array idx)))  
+  ([^Array array idx & idxs]
+   (apply aget (aget array (int idx)) idxs)))
 
 (defn aset
   "Sets the value at the index/indices. Works on Java arrays of
   reference types. Returns val."
   {:inline (fn [a i v] `(. clojure.lang.RT (aset ~a (int ~i) ~v)))
    :inline-arities #{3}
    :added "1.0"}
-  ([array idx val]
-   (. array (SetValue val idx))  ;;; was     (. Array (set array idx val))
+  ([^Array array idx ^Object val]
+   (. array (SetValue val (int idx)))  ;;; was     (. Array (set array idx val))
    val)
-  ([array idx idx2 & idxv]
-   (apply aset (aget array idx) idx2 idxv)))
+  ([^Array array idx idx2 & idxv]
+   (apply aset (aget array (int idx)) idx2 idxv)))
 
 (defmacro
   ^{:private true}
@@ -3885,8 +3887,8 @@ Note that read can execute code (controlled by *read-eval*),
        ([array# idx# val#]
         (. clojure.lang.ArrayHelper (~method array# idx# (~coerce val#)))        ;;; Array -> ArrayHelper so we can provide the overloads below.
         val#)
-       ([array# idx# idx2# & idxv#]
-        (apply ~name (aget array# idx#) idx2# idxv#))))
+       ([^Array array# idx# idx2# & idxv#]
+        (apply ~name (aget array# (int idx#)) idx2# idxv#))))
 
 (def-aset
   ^{:doc "Sets the value at the index/indices. Works on arrays of int. Returns val."
@@ -3937,12 +3939,12 @@ Note that read can execute code (controlled by *read-eval*),
   {:added "1.0"
    :static true}
   ([^Type type len]                                                     ;;; ^Class
-   (. Array (CreateInstance type (int len))))                            ;;; newInstance
+   (Array/CreateInstance type (int len)))                            ;;; newInstance
   ([^Type type dim & more-dims]                                        ;;; ^Class
-   (let [ a  (. Array (CreateInstance Array (int dim)))]       ;;;    [dims (cons dim more-dims)
+   (let [^Array a (System.Array/CreateInstance (.MakeArrayType type) (int dim))]       ;;;    [dims (cons dim more-dims)
                                                                ;;;     ^"[I" dimarray (make-array (. Integer TYPE)  (count dims))]
       (dotimes [i dim]                                         ;;;       (dotimes [i (alength dimarray)]
-          (aset a i (apply make-array type more-dims)))        ;;;   (aset-int dimarray i (nth dims i)))
+          (aset a (int i) (apply make-array type more-dims)))        ;;;   (aset-int dimarray i (nth dims i)))
       a)))                                                     ;;; (. Array (newInstance type dimarray)))))
 
 (defn to-array-2d
@@ -3953,10 +3955,10 @@ Note that read can execute code (controlled by *read-eval*),
    :added "1.0"
    :static true}
   [^System.Collections.ICollection coll]                                              ;;; ^java.util.Collection
-    (let [ret  (make-array Object (.Count coll))]      ;;; NEED BETTER TYPING HERE (make-array (. Class (forName "[Ljava.lang.Object;")) (. coll (size)))]
+    (let [^Array ret  (make-array Object (.Count coll))]      ;;; NEED BETTER TYPING HERE (make-array (. Class (forName "[Ljava.lang.Object;")) (. coll (size)))]
       (loop [i 0 xs (seq coll)]
         (when xs
-          (aset ret i (to-array (first xs)))
+          (aset ret (int i) (to-array (first xs)))
           (recur (inc i) (next xs))))
       ret))
 
@@ -4138,8 +4140,8 @@ Note that read can execute code (controlled by *read-eval*),
   [ns]
   (let [ns (the-ns ns)]
     (filter-key val (fn [ v] (and (instance? clojure.lang.Var v)    ;;;  removed the tag on v:  ^clojure.lang.Var
-                                 (= ns (.ns v))
-                                 (.isPublic v)))
+                                 (= ns (.ns ^clojure.lang.Var v))
+                                 (.isPublic ^clojure.lang.Var v)))
                 (ns-map ns))))
 
 (defn ns-imports
@@ -4693,9 +4695,9 @@ Note that read can execute code (controlled by *read-eval*),
   "Create an instance of ExceptionInfo, a RuntimeException subclass
    that carries a map of additional data."
   {:added "1.4"}
-  ([msg map]
+  ([^String msg ^clojure.lang.IPersistentMap map]
      (ExceptionInfo. msg map))
-  ([msg map cause]
+  ([^String msg ^clojure.lang.IPersistentMap map ^Exception cause]
      (ExceptionInfo. msg map cause)))
 
 (defn ex-data
@@ -4975,7 +4977,7 @@ Note that read can execute code (controlled by *read-eval*),
   {:private true}
   [^clojure.lang.Sorted sc test key]
   (fn [e]
-    (test (.. sc comparator (compare (. sc entryKey e) key)) 0)))
+    (test (.. sc comparator (Compare (. sc entryKey e) key)) 0)))
 
 (defn subseq
   "sc must be a sorted collection, test(s) one of <, <=, > or
@@ -7651,4 +7653,4 @@ clojure.lang.IKVReduce
  (load-data-readers)
  (catch Exception t                                                                 ;;; Throwable
    (System.Console/WriteLine (.StackTrace t))                                       ;;; .printStackTrace
-   (throw t)))
+   (throw t)))

Clojure/Clojure.Source/clojure/core_deftype.clj

@@ -640,8 +640,8 @@
 
 (defn- assert-same-protocol [protocol-var method-syms]
   (doseq [m method-syms]
-    (let [v (resolve m)
-          p (:protocol (meta v))]
+    (let [^clojure.lang.Var v (resolve m)
+          ^clojure.lang.Var p (:protocol (meta v))]
       (when (and v (bound? v) (not= protocol-var p))
         (binding [*out* *err*]
           (println "Warning: protocol" protocol-var "is overwriting"
@@ -899,4 +899,4 @@
   {:added "1.2"} 
 
   [p & specs]
-  (emit-extend-protocol p specs))
+  (emit-extend-protocol p specs))

Clojure/Clojure.Source/clojure/data.clj

@@ -78,9 +78,9 @@
 
 (extend Object
         Diff
-        {:diff-similar (fn [a b] ((if (.. a GetType IsArray) diff-sequential atom-diff) a b))}    ;;; (.. a getClass isArray)
+        {:diff-similar (fn [^Object a ^Object b] ((if (.. a GetType IsArray) diff-sequential atom-diff) a b))}    ;;; (.. a getClass isArray)
         EqualityPartition
-        {:equality-partition (fn [x] (if (.. x GetType IsArray) :sequential :atom))})    ;;; (.. x getClass isArray)
+        {:equality-partition (fn [^Object x] (if (.. x GetType IsArray) :sequential :atom))})    ;;; (.. x getClass isArray)
 
 (extend-protocol EqualityPartition
   nil

Clojure/Clojure.Source/clojure/genclass.clj

@@ -14,15 +14,15 @@
 
  (in-ns 'clojure.core)
 
- (import '(System.Reflection ConstructorInfo))
+ (import '(System.Reflection ConstructorInfo ParameterInfo))
 
  ;;; The options-handling code here is taken from the JVM version.  
 
 
  (defn- ctor-sigs [^Type super]
   (for [^ConstructorInfo ctor (.GetConstructors super)
         :when (not (.IsPrivate ctor))]
-    (apply vector (map #(.ParameterType %) (.GetParameters ctor)))))
+    (apply vector (map #(.ParameterType ^ParameterInfo %) (.GetParameters ctor)))))
 
 
  (def ^{:private true} prim->class
@@ -295,4 +295,4 @@
 
   [& options]
   (let [options-map (into1 {} (map vec (partition 2 options))) ]
-          `'~(generate-interface options-map)))
+          `'~(generate-interface options-map)))

Clojure/Clojure.Source/clojure/instant.clj

@@ -262,7 +262,7 @@ with invalid arguments."
 (defn- construct-datetimeoffset
   "Construct a System.DateTimeOffset, preserving the timezone offset
 but truncating the subsecond fraction to milliseconds."
-  ^DateTimeOffset
+  ^System.DateTimeOffset
   [years months days hours minutes seconds nanoseconds
    offset-sign offset-hours offset-minutes]
   (DateTimeOffset. years months days hours minutes seconds 

Clojure/Clojure.Source/clojure/main.clj

@@ -50,6 +50,7 @@
 
 (defn get-stack-trace 
   "Gets the stack trace for an Exception"
+  ^System.Array
   [^Exception e]
   (.GetFrames (System.Diagnostics.StackTrace. e true)))
 
@@ -117,7 +118,7 @@
   must either be an instance of LineNumberingPushbackReader or duplicate
   its behavior of both supporting .unread and collapsing all of CR, LF, and
   CRLF to a single \\newline."
-  [s]
+  [^clojure.lang.PushbackTextReader s]
   (let [c (.Read s)]                             ;;; .read
     (cond
      (= c (int \newline)) :line-start
@@ -133,7 +134,7 @@
   instance of LineNumberingPushbackReader or duplicate its behavior of both
   supporting .unread and collapsing all of CR, LF, and CRLF to a single
   \\newline."
-  [s]
+  [^clojure.lang.PushbackTextReader s]
   (loop [c (.Read s)]							;;; .read
     (cond
      (= c (int \newline)) :line-start
@@ -162,6 +163,7 @@
 
 (defn repl-exception
   "Returns the root cause of throwables"
+  ^System.Exception
   [throwable]
   (root-cause throwable))
 

Clojure/Clojure.Source/clojure/reflect/clr.clj

@@ -131,7 +131,10 @@
 	   (typesym t))))
 
 (defrecord Constructor
-  [name declaring-class parameter-types flags])
+  [^clojure.lang.Symbol name
+   ^clojure.lang.Symbol declaring-class
+   ^clojure.lang.IPersistentVector parameter-types
+   ^clojure.lang.IPersistentSet flags])
 
 (defn- constructor->map
   [^System.Reflection.ConstructorInfo constructor]

Clojure/Clojure.Source/clojure/repl.clj

@@ -146,7 +146,7 @@ Example: (source-fn 'filter)"
         (with-open [ ^System.IO.TextReader rdr (.OpenText info)]                    ;;; [rdr (LineNumberReader. (InputStreamReader. strm))]
           (dotimes [_ (dec (:line (meta v)))] (.ReadLine rdr))                      ;;; .readLine
           (let [text (StringBuilder.)
-                pbr (proxy [clojure.lang.PushbackTextReader] [rdr]                  ;;; [PushbackReader] [rdr]
+                pbr (proxy [clojure.lang.PushbackTextReader] [^System.IO.TextReader rdr]                  ;;; [PushbackReader] [rdr]
                       (Read [] (let [i (proxy-super Read)]                          ;;; read read
                                  (.Append text (char i))                            ;;; .append
                                  i)))