Update copieddeps for new dependencies as of Jan 15 2016

Adds java.classpath as a new dependency of tools.namespace 0.3.0-alpha3 Removes old file in copieddeps version of tools.reader that is no longer part of latest tools.reader. Update project.clj and other files so that all Eastwood 'lein test' tests pass with these new versions of copieddeps. Crucible projects have not yet been tested with these new copieddeps. That will be next.
jonase · Jan 17, 2016 · 6284aa6 · 6284aa6
1 parent 739c581
commit 6284aa6
Show file tree

Hide file tree

Showing 25 changed files with 737 additions and 359 deletions.
diff --git a/copy-deps-scripts/README.md b/copy-deps-scripts/README.md
@@ -158,7 +158,7 @@ for details.
     ;; diff command like the following from the dolly project root
     ;; directory in a command shell should show no differences.
 
-    ;; diff -cr copy-deps-scripts/repos/tools.analyzer/src/main/clojure staging
+    ;; diff -cr copy-deps-scripts/repos/tools.analyzer.jvm/src/main/clojure staging
 
     ;; Now move the files from the staging area into dolly's code and
     ;; rename the namespaces.
@@ -203,7 +203,7 @@ for details.
 
     ;; java.classpath
     (c/copy-namespaces-unmodified jc-src-path staging-path 'clojure.java.classpath for-real)
-    (c/move-namespaces-and-rename staging-path src-path 'clojure.java.classpath 'eastwood.copieddeps.dep9.clojure.java.classpath [src-path] for-real)
+    (c/move-namespaces-and-rename staging-path src-path 'clojure.java.classpath 'eastwood.copieddeps.dep11.clojure.java.classpath [src-path] for-real)
 
 
 Here are the dependencies copied in, given in a topologically sorted

diff --git a/project.clj b/project.clj
@@ -3,7 +3,6 @@
   :url "https://github.com/jonase/eastwood"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
-  :aot [eastwood.copieddeps.dep10.clojure.tools.reader.impl.ExceptionInfo]
   :global-vars {*warn-on-reflection* true
                 ;;*unchecked-math* :warn-on-boxed
                }

diff --git a/src/eastwood/copieddeps/dep1/clojure/tools/analyzer/passes.clj b/src/eastwood/copieddeps/dep1/clojure/tools/analyzer/passes.clj
@@ -1,24 +1,13 @@
 (ns eastwood.copieddeps.dep1.clojure.tools.analyzer.passes
+  "Utilities for pass scheduling"
   (:require [eastwood.copieddeps.dep1.clojure.tools.analyzer.ast :refer [prewalk postwalk]]
             [eastwood.copieddeps.dep1.clojure.tools.analyzer.utils :refer [update-vals]]))
 
-(def ^:private ffilter (comp first filter))
-
-(defn ^:private ffilter-walk [f c]
-  (ffilter (comp f :walk) c))
-
 (defn ^:private has-deps?
   "Returns true if the pass has some dependencies"
   [pass]
   (seq (:dependencies pass)))
 
-(defn ^:private group-by-walk
-  "Takes a set of pass-infos and returns a map grouping them by :walk.
-   Possible keys are :any, :none, :pre and :post"
-  [passes]
-  (reduce-kv (fn [m k v] (assoc m k (set (map :name v))))
-             {} (group-by :walk passes)))
-
 (defn ^:private indicize
   "Takes a set of pass-infos and returns a map of pass-name -> pass-info"
   [passes]
@@ -32,6 +21,15 @@
                                         (update-in [:dependants] disj pass))))
                     #{} (vals (dissoc passes pass)))))
 
+(defn desugar-deps
+  "Takes a map of pass-name -> pass deps and puts the :after :affects and :before passes
+   in the appropriate pass :depends"
+  [passes]
+  (reduce-kv (fn [m name {:keys [after affects before]}]
+               (reduce (fn [m p] (update-in m [p :depends] (fnil conj #{}) name))
+                       (update-in m [name :depends] (fnil into #{}) (into affects (filter passes after)))
+                       before)) passes passes))
+
 (defn ^:private calc-deps
   "Takes a map of pass-name -> pass deps, a pass name, the explicit pass dependencies
    and a set of available pass-infos.
@@ -45,12 +43,6 @@
                 (update-in m [k] into (conj (or (m dep) #{}) dep))))
             (assoc m k deps) deps)))
 
-(defn desugar-deps [passes]
-  (reduce-kv (fn [m name {:keys [after affects before]}]
-               (reduce (fn [m p] (update-in m [p :depends] (fnil conj #{}) name))
-                       (update-in m [name :depends] (fnil into #{}) (into affects (filter passes after)))
-                       before)) passes passes))
-
 (defn calculate-deps
   "Takes a map of pass-name -> pass-info and adds to each pass-info :dependencies and
    :dependants info, which also contain the transitive dependencies"
@@ -120,17 +112,21 @@
     ;; pick a random available pass
     (first free)))
 
+(def ^:private ffilter (comp first filter))
+
+(defn ^:private first-walk [f c]
+  (ffilter (comp #{f} :walk) c))
+
 (defn schedule* [state passes]
-  (let [f                         (filter (comp empty? :dependants val) passes)
-        [free & frs :as free-all] (vals f)
-        w                         (first (group state))
-        non-looping-free          (remove :affects free-all)]
+  (let [free             (filter (comp empty? :dependants) (vals passes))
+        w                (first (group state))
+        non-looping-free (remove :affects free)]
     (if (seq passes)
-      (let [{:keys [name] :as pass} (or (ffilter :compiler free-all)
-                                        (and w (or (ffilter-walk #{w} non-looping-free)
-                                                   (ffilter-walk #{:any} non-looping-free)))
-                                        (ffilter-walk #{:none} free-all)
-                                        (maybe-looping-pass free-all passes))]
+      (let [{:keys [name] :as pass} (or (ffilter :compiler free)
+                                        (and w (or (first-walk w non-looping-free)
+                                                   (first-walk :any non-looping-free)))
+                                        (first-walk :none free)
+                                        (maybe-looping-pass free passes))]
         (recur (cons (assoc pass :passes [name]) state)
                (remove-pass passes name)))
       state)))
@@ -146,8 +142,7 @@
 
 (defn schedule-passes
   [passes]
-  (let [passes (calculate-deps passes)
-        dependencies (set (mapcat :dependencies (vals passes)))]
+  (let [passes (calculate-deps passes)]
 
     (when (every? has-deps? (vals passes))
       (throw (ex-info "Dependency cycle detected" passes)))
@@ -200,7 +195,7 @@
                This pass must take a function as argument and return the actual pass, the
                argument represents the reified tree traversal which the pass can use to
                control a recursive traversal, implies :depends
-   * :state    a no-arg function that should return the init value of an atom that will be
+   * :state    a no-arg function that should return an atom holding an init value that will be
                passed as the first argument to the pass (the pass will thus take the ast
                as the second parameter), the atom will be the same for the whole tree traversal
                and thus can be used to preserve state across the traversal

diff --git a/src/eastwood/copieddeps/dep1/clojure/tools/analyzer/utils.clj b/src/eastwood/copieddeps/dep1/clojure/tools/analyzer/utils.clj
@@ -228,16 +228,8 @@
 
 (defn const-val
   "Returns the value of a constant node (either :quote or :const)"
-  [{:keys [op form val expr]}]
-  (cond
-   (= :quote op)
-   (const-val expr)
-
-   val
-   val
-
-   :else
-   form))
+  [{:keys [form val]}]
+  (or val form))
 
 (def mmerge
   "Same as (fn [m1 m2] (merge-with merge m2 m1))"

diff --git a/src/eastwood/copieddeps/dep10/clojure/tools/reader.clj b/src/eastwood/copieddeps/dep10/clojure/tools/reader.clj
@@ -12,9 +12,13 @@
   (:refer-clojure :exclude [read read-line read-string char
                             default-data-readers *default-data-reader-fn*
                             *read-eval* *data-readers* *suppress-read*])
-  (:use eastwood.copieddeps.dep10.clojure.tools.reader.reader-types
-        [eastwood.copieddeps.dep10.clojure.tools.reader.impl utils commons])
-  (:require [eastwood.copieddeps.dep10.clojure.tools.reader.default-data-readers :as data-readers])
+  (:require [eastwood.copieddeps.dep10.clojure.tools.reader.reader-types :refer
+             [read-char reader-error unread peek-char indexing-reader?
+              get-line-number get-column-number get-file-name string-push-back-reader
+              log-source]]
+            [eastwood.copieddeps.dep10.clojure.tools.reader.impl.utils :refer :all] ;; [char ex-info? whitespace? numeric? desugar-meta]
+            [eastwood.copieddeps.dep10.clojure.tools.reader.impl.commons :refer :all]
+            [eastwood.copieddeps.dep10.clojure.tools.reader.default-data-readers :as data-readers])
   (:import (clojure.lang PersistentHashSet IMeta
                          RT Symbol Reflector Var IObj
                          PersistentVector IRecord Namespace)
@@ -180,20 +184,22 @@
 (defonce ^:private READ_EOF (Object.))
 (defonce ^:private READ_FINISHED (Object.))
 
+(def ^:dynamic *read-delim* false)
 (defn- ^PersistentVector read-delimited
   "Reads and returns a collection ended with delim"
   [delim rdr opts pending-forms]
   (let [[start-line start-column] (starting-line-col-info rdr)
         delim (char delim)]
-    (loop [a (transient [])]
-      (let [form (read* rdr false READ_EOF delim opts pending-forms)]
-        (if (identical? form READ_FINISHED)
-          (persistent! a)
-          (if (identical? form READ_EOF)
-            (reader-error rdr "EOF while reading"
-                          (when start-line
-                            (str ", starting at line " start-line " and column " start-column)))
-            (recur (conj! a form))))))))
+    (binding [*read-delim* true]
+      (loop [a (transient [])]
+        (let [form (read* rdr false READ_EOF delim opts pending-forms)]
+          (if (identical? form READ_FINISHED)
+            (persistent! a)
+            (if (identical? form READ_EOF)
+              (reader-error rdr "EOF while reading"
+                            (when start-line
+                              (str ", starting at line " start-line " and column " start-column)))
+              (recur (conj! a form)))))))))
 
 (defn- read-list
   "Read in a list, including its location if the reader is an indexing reader"
@@ -437,6 +443,8 @@
       (when (identical? form READ_FINISHED)
         READ_FINISHED))))
 
+(def ^:private NO_MATCH (Object.))
+
 (defn- match-feature
   "Read next feature. If matched, read next form and return.
    Otherwise, read and skip next form, returning READ_FINISHED or nil."
@@ -453,29 +461,29 @@
             (check-eof-error rdr first-line)
             (check-invalid-read-cond rdr first-line))
           ;; feature not matched, ignore next form
-          (read-suppress first-line rdr opts pending-forms))))))
+          (or (read-suppress first-line rdr opts pending-forms)
+              NO_MATCH))))))
 
 (defn- read-cond-delimited
   [rdr splicing opts pending-forms]
   (let [first-line (if (indexing-reader? rdr) (get-line-number rdr) -1)
-        result (loop [matched nil
+        result (loop [matched NO_MATCH
                       finished nil]
                  (cond
-                   ;; still looking for match, read feature+form
-                   (nil? matched)
-                   (let [match (match-feature first-line rdr opts pending-forms)]
-                     (if (not (nil? match))
-                       (when-not (identical? match READ_FINISHED)
-                         (recur match nil))
-                       (recur nil nil)))
-
-                   ;; found match, just read and ignore the rest
-                   (not (identical? finished READ_FINISHED))
-                   (recur matched (read-suppress first-line rdr opts pending-forms))
-
-                   :else
-                   matched))]
-    (if (nil? result)
+                  ;; still looking for match, read feature+form
+                  (identical? matched NO_MATCH)
+                  (let [match (match-feature first-line rdr opts pending-forms)]
+                    (if (identical? match READ_FINISHED)
+                      READ_FINISHED
+                      (recur match nil)))
+
+                  ;; found match, just read and ignore the rest
+                  (not (identical? finished READ_FINISHED))
+                  (recur matched (read-suppress first-line rdr opts pending-forms))
+
+                  :else
+                  matched))]
+    (if (identical? result READ_FINISHED)
       rdr
       (if splicing
         (if (instance? List result)
@@ -492,6 +500,9 @@
   (if-let [ch (read-char rdr)]
     (let [splicing (= ch \@)
           ch (if splicing (read-char rdr) ch)]
+      (when splicing
+        (when-not *read-delim*
+          (reader-error rdr "cond-splice not in list")))
       (if-let [ch (if (whitespace? ch) (read-past whitespace? rdr) ch)]
         (if (not= ch \()
           (throw (RuntimeException. "read-cond body must be a list"))
@@ -694,7 +705,7 @@
                :else (resolve-symbol form)))))
 
     (unquote? form) (second form)
-    (unquote-splicing? form) (throw (IllegalStateException. "splice not in list"))
+    (unquote-splicing? form) (throw (IllegalStateException. "unquote-splice not in list"))
 
     (coll? form)
     (cond

diff --git a/src/eastwood/copieddeps/dep10/clojure/tools/reader/edn.clj b/src/eastwood/copieddeps/dep10/clojure/tools/reader/edn.clj
@@ -9,10 +9,14 @@
 (ns ^{:doc "An EDN reader in clojure"
       :author "Bronsa"}
   eastwood.copieddeps.dep10.clojure.tools.reader.edn
-  (:refer-clojure :exclude [read read-line read-string char default-data-readers])
-  (:use eastwood.copieddeps.dep10.clojure.tools.reader.reader-types
-        [eastwood.copieddeps.dep10.clojure.tools.reader.impl utils commons]
-        [eastwood.copieddeps.dep10.clojure.tools.reader :only [default-data-readers]])
+  (:refer-clojure :exclude [read read-string char default-data-readers])
+  (:require [eastwood.copieddeps.dep10.clojure.tools.reader.reader-types :refer
+             [read-char reader-error unread peek-char indexing-reader?
+              get-line-number get-column-number get-file-name string-push-back-reader]]
+            [eastwood.copieddeps.dep10.clojure.tools.reader.impl.utils :refer
+             [char ex-info? whitespace? numeric? desugar-meta]]
+            [eastwood.copieddeps.dep10.clojure.tools.reader.impl.commons :refer :all]
+            [eastwood.copieddeps.dep10.clojure.tools.reader :refer [default-data-readers]])
   (:import (clojure.lang PersistentHashSet IMeta RT PersistentVector)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

diff --git a/src/eastwood/copieddeps/dep10/clojure/tools/reader/impl/ExceptionInfo.clj b/src/eastwood/copieddeps/dep10/clojure/tools/reader/impl/ExceptionInfo.clj
diff --git a/src/eastwood/copieddeps/dep10/clojure/tools/reader/impl/commons.clj b/src/eastwood/copieddeps/dep10/clojure/tools/reader/impl/commons.clj
@@ -6,10 +6,10 @@
 ;;   the terms of this license.
 ;;   You must not remove this notice, or any other, from this software.
 
-(ns ^:skip-wiki eastwood.copieddeps.dep10.clojure.tools.reader.impl.commons
-  (:refer-clojure :exclude [char read-line])
-  (:use eastwood.copieddeps.dep10.clojure.tools.reader.reader-types
-        eastwood.copieddeps.dep10.clojure.tools.reader.impl.utils)
+(ns eastwood.copieddeps.dep10.clojure.tools.reader.impl.commons
+  (:refer-clojure :exclude [char])
+  (:require [eastwood.copieddeps.dep10.clojure.tools.reader.reader-types :refer [peek-char read-char reader-error]]
+            [eastwood.copieddeps.dep10.clojure.tools.reader.impl.utils :refer [numeric? newline? char]])
   (:import (clojure.lang BigInt Numbers)
            (java.util.regex Pattern Matcher)
            java.lang.reflect.Constructor))
@@ -57,10 +57,9 @@
              (.group m 5) [(.group m 5) 8]
              (.group m 7) [(.group m 7) (Integer/parseInt (.group m 6))]
              :else        [nil nil])
-          ^String n (a 0)
-          radix (int (a 1))]
+          ^String n (a 0)]
       (when n
-        (let [bn (BigInteger. n radix)
+        (let [bn (BigInteger. n (int (a 1)))
               bn (if negate? (.negate bn) bn)]
           (if (.group m 8)
             (BigInt/fromBigInteger bn)

diff --git a/src/eastwood/copieddeps/dep10/clojure/tools/reader/impl/utils.clj b/src/eastwood/copieddeps/dep10/clojure/tools/reader/impl/utils.clj
@@ -7,7 +7,6 @@
 ;;   You must not remove this notice, or any other, from this software.
 
 (ns ^:skip-wiki eastwood.copieddeps.dep10.clojure.tools.reader.impl.utils
-  (:require eastwood.copieddeps.dep10.clojure.tools.reader.impl.ExceptionInfo) ;; force loading
   (:refer-clojure :exclude [char]))
 
 (defn char [x]
@@ -38,21 +37,8 @@
     then
     else))
 
-(compile-if (= 3 (:minor *clojure-version*))
-  (do
-    (defn ex-info
-      ([msg map]
-         (eastwood.copieddeps.dep10.clojure.tools.reader.impl.ExceptionInfo. msg map))
-      ([msg map cause]
-         (eastwood.copieddeps.dep10.clojure.tools.reader.impl.ExceptionInfo. msg map cause)))
-    (defn ex-data
-      [^eastwood.copieddeps.dep10.clojure.tools.reader.impl.ExceptionInfo ex]
-      (.getData ex))
-    (defn ex-info? [ex]
-      (instance? eastwood.copieddeps.dep10.clojure.tools.reader.impl.ExceptionInfo ex)))
-
-  (defn ex-info? [ex]
-    (instance? clojure.lang.ExceptionInfo ex)))
+(defn ex-info? [ex]
+  (instance? clojure.lang.ExceptionInfo ex))
 
 (compile-if <=clojure-1-7-alpha5
   (do