   # Reserve a variable name as originating from a function parameter for this
   # scope. No `var` required for internal references.
   parameter: (name) ->
-    @setVar name, 'param'
+    @add name, 'param'
 
   # Just check to see if a variable has already been declared, without reserving,
   # walks up to the root scope.

  # where it should declare its variables, and a reference to the function that
  # it wraps.
  constructor: (@parent, @expressions, @method) ->
    @variables = [{name: 'arguments', type: 'arguments'}]
    @positions = {}
    if @parent
      {@garbage} = @parent
    else
      @garbage   = []
      Scope.root = this
  
  # Adds a new variable or overrides an existing one.
  setVar: (name, type) ->
    if @positions.hasOwnProperty name
      @variables[@positions[name]].type = type
    else
      @positions[name] = -1 + @variables.push {name, type}
    this

  # Create a new garbage level

  # Return to the previous garbage level and erase referenced temporary
  # variables in current level from scope.
  endLevel: ->
    @add name, 'reuse' for name in @garbage.pop() when @type(name) is 'var'
    this

  # Look up a variable name in lexical scope, and declare it if it does not
  # already exist.
  find: (name, options) ->
    return true if @check name, options
    @add name, 'var'
    false

  # Test variables and return `true` the first time `fn(v)` returns `true`
