anchor.diff:        :lshift-equals :rshift-equals :urshift-equals :and-equals :xor-equals :or-equals)
        :right)))
   
  -;;;; Other static properties of source models
  -
  +;;;; ------- Other static properties of source elements --------------------------------------------
  +
  +;;TODO is this function in the right place?
   ;;TODO This function is not complete:
  -;;TODO is this function in the right place?
   ;; - binary operators are idempotent so long as they
   ;;   aren't assignment operators and so long as both args are idempotent.
   ;; - conditional operators are idempotent so long as all args are idempotent
  
positive.code:        (defmethod make-load-form ((self ,type) &optional environment)
           (make-load-form-saving-slots self :environment environment)))))
  
  ;;;; Standard Javascript 
  
  ; GS- i've added types, but should make a virtual "expressions" type to be used where appropriate
  ; instead of source-element
  ; perhaps also one for statement?
  ; JRW - I think both of those are good ideas.  There's a couple of places in type-analysis where
  ; that would be helpful.
  
  (defelement source-element
    "A common base type for all source elements"
    (label nil :type (or string null)))
  
  (defelement (special-value (:include source-element))
    (symbol nil :type symbol))
  
  (defelement (identifier (:include source-element))
    (name nil :type string))
  
  (defelement (numeric-literal (:include source-element))
    (value nil :type number))
  
  (defelement (string-literal (:include source-element))
    (value nil :type string))
  
  (defelement (array-literal (:include source-element))
    (elements nil :type list))
  
  (defelement (object-literal (:include source-element))
    (properties nil :type list))  ; List of (PROPERTY-NAME . PROPERTY-VALUE)
                                  ; PROPERTY-NAME is a STRING-LITERAL
  
  (defelement (re-literal (:include source-element))
    pattern
    options)
  
  (defelement (new-expr (:include source-element))
    (constructor nil :type (or identifier property-access fn-call function-expression))
    (args nil :type (or (cons source-element) null)))
  
  (defelement (fn-call (:include source-element))
    (fn nil :type (or identifier property-access fn-call function-expression))
    (args nil :type (or (cons source-element) null)))
  
  (defelement (property-access (:include source-element))
    (target nil :type source-element)
    (field nil :type source-element))
  
  (defelement (unary-operator (:include source-element))
    (op-symbol nil :type symbol)
    (arg nil :type source-element))
  
  (defelement (binary-operator (:include source-element))
    (op-symbol nil :type symbol)
    (left-arg nil :type source-element)
    (right-arg nil :type source-element))
  
  (defelement (conditional (:include source-element))
    (condition nil :type source-element)
    (true-arg nil :type source-element)
    (false-arg nil :type source-element))
  
  (defelement (comma-expr (:include source-element))
    exprs)
  
  (defelement (var-decl-statement (:include source-element))
    (var-decls nil :type (cons var-decl)))
  
  (defelement (var-decl (:include source-element))
    (name nil :type string)
    (initializer nil :type (or source-element null)))
  
  (defelement (statement-block (:include source-element))
    (statements nil :type (or (cons source-element) null)))
  
  (defelement (if-statement (:include source-element))
    (condition nil :type source-element)
    (then-statement nil :type (or source-element null))
    (else-statement nil :type (or source-element null)))
  
  (defelement (do-statement (:include source-element))
    (condition nil :type source-element)
    (body nil :type source-element))
  
  (defelement (while (:include source-element))
    (condition nil :type source-element)
    (body nil :type (or source-element null)))
  
  (defelement (for (:include source-element))
    (initializer nil :type (or source-element null))
    (condition nil :type (or source-element null))
    (step nil :type (or source-element null))
    (body nil :type (or source-element null)))
  
  (defelement (for-in (:include source-element))
    (binding nil :type source-element)
    (collection nil :type source-element)
    (body nil :type (or source-element null)))
  
  (defelement (continue-statement (:include source-element))
  
negative.code:   (parameters nil :type (or (cons string) null))
    (body nil :type (or (cons source-element) (cons null) null)))
  
  (defelement (function-expression (:include expression))
    (name nil :type (or string null))
    (parameters nil :type (or (cons string) null))
    (body nil :type (or (cons source-element) null)))
  
  ;;;; ------- "Administrative lambda" source elements -----------------------------------------------
  (defelement (continuation-function (:include function-expression))
    "A function expression that is used as a continuation")
  
  