Which Vars affect a Clojure function?

Question

How do I programmatically figure out which Vars may affect the results of a function defined in Clojure?

Consider this definition of a Clojure function:

(def ^:dynamic *increment* 3)
(defn f [x]
  (+ x *increment*))

This is a function of x, but also of *increment* (and also of clojure.core/+⁽¹⁾; but I'm less concerned with that). When writing tests for this function, I want to make sure that I control all relevant inputs, so I do something like this:

(assert (= (binding [*increment* 3] (f 1)) 4))
(assert (= (binding [*increment* -1] (f 1)) 0))

(Imagine that *increment* is a configuration value that someone might reasonably change; I don't want this function's tests to need changing when this happens.)

My question is: how do I write an assertion that the value of (f 1) can depend on *increment* but not on any other Var? Because I expect that one day someone will refactor some code and cause the function to be

(defn f [x]
  (+ x *increment* *additional-increment*))

and neglect to update the test, and I would like to have the test fail even if *additional-increment* is zero.

This is of course a simplified example – in a large system, there can be lots of dynamic Vars, and they can get referenced through a long chain of function calls. The solution needs to work even if f calls g which calls h which references a Var. It would be great if it didn't claim that (with-out-str (prn "foo")) depends on *out*, but this is less important. If the code being analyzed calls eval or uses Java interop, of course all bets are off.

I can think of three categories of solutions:

1. Get the information from the compiler

   I imagine the compiler does scan function definitions for the necessary information, because if I try to refer to a nonexistent Var, it throws:

   user=> (defn g [x] (if true x (+ *foobar* x)))
   CompilerException java.lang.RuntimeException: Unable to resolve symbol: *foobar* in this context, compiling:(NO_SOURCE_PATH:24) 
   

   Note that this happens at compile time, and regardless of whether the offending code will ever be executed. Thus the compiler should know what Vars are potentially referenced by the function, and I would like to have access to that information.

2. Parse the source code and walk the syntax tree, and record when a Var is referenced

   Because code is data and all that. I suppose this means calling macroexpand and handling each Clojure primitive and every kind of syntax they take. This looks so much like a compilation phase that it would be great to be able to call parts of the compiler, or somehow add my own hooks to the compiler.

3. Instrument the Var mechanism, execute the test and see which Vars get accessed

   Not as complete as the other methods (what if a Var is used in a branch of the code that my test fails to exercise?) but this would suffice. I imagine I would need to redefine def to produce something that acts like a Var but records its accesses somehow.

---

^{(1) Actually that particular function doesn't change if you rebind +; but in Clojure 1.2 you can bypass that optimization by making it (defn f [x] (+ x 0 *increment*)) and then you can have fun with (binding [+ -] (f 3)). In Clojure 1.3 attempting to rebind + throws an error.}

Answer 1

I know that this doesn't answer your question, but wouldn't it be a lot less work to just provide two versions of a function where one version has no free variables, and the other version calls the first one with the appropriate top-level defines?

For example:

(def ^:dynamic *increment* 3)
(defn f
  ([x]
     (f x *increment*))
  ([x y]
     (+ x y)))

This way you can write all your tests against (f x y), which doesn't rely on any global state.

Answer 2

Regarding your first point you could consider using the analyze library. With it you can quite easily figure out which dynamic vars are used in an expression:

user> (def ^:dynamic *increment* 3)
user> (def src '(defn f [x]
                  (+ x *increment*)))
user> (def env {:ns {:name 'user} :context :eval})
user> (->> (analyze-one env src) 
           expr-seq 
           (filter (op= :var)) 
           (map :var) 
           (filter (comp :dynamic meta)) 
           set)
#{#'user/*increment*}