anchor.diff:            (define ok-do-code '((do ((a 1 2) (b 2 3)) (#t) (+ a b)))))
   
            (it "finds a backward dependancy"
  -             (assert-eq (lint:analyze-for-bugged-do bugged-do-code) '("Back reference in a DO: b")))
  +             (assert-eq (lint:analyze-do bugged-do-code) '("Back reference in a DO: b")))
            
            (it "finds no a backward dependancy"
  -             (assert-nil (lint:analyze-for-bugged-do ok-do-code))))
  +             (assert-nil (lint:analyze-do ok-do-code))))
   
   
   (context "checking for single clause ifs"
  
positive.code:           (define ok-let-code '((let ((a 1) (b (+ c 1))) (+ a b)))))
  
           (it "finds a backward dependancy"
               (assert-eq (lint:analyze-for-bugged-let bugged-let-code) '("Back reference in a LET: b")))
           
           (it "finds no a backward dependancy"
               (assert-nil (lint:analyze-for-bugged-let ok-let-code))))
  
  (context "Checking for dependant do bindings"
  
  
negative.code:           (define all-code (append set-code setcar-code setcdr-code)))
  
           (it "find nothing with no sets"
               (assert-nil (lint:analyze-set no-set-code)))
           
           (it "finds set!"
               (assert-eq (lint:analyze-set set-code) '("Mutator found: (set! x 3)")))
  
           (it "finds set!"
               (assert-eq (lint:analyze-set setcar-code) '("Mutator found: (set-car! x 3)")))
           
           (it "finds set!"
               (assert-eq (lint:analyze-set setcdr-code) '("Mutator found: (set-cdr! x 3)")))
  
           (it "finds all"
               (assert-memq (lint:analyze-set all-code) "Mutator found: (set! x 3)")
               (assert-memq (lint:analyze-set all-code) "Mutator found: (set-car! x 3)")
               (assert-memq (lint:analyze-set all-code) "Mutator found: (set-cdr! x 3)")))
  
  (context "Checking for dependant let bindings"
  
  