--- a/python/mozbuild/mozbuild/configure/__init__.py
+++ b/python/mozbuild/mozbuild/configure/__init__.py
@@ -318,63 +318,66 @@ class ConfigureSandbox(dict):
 
         The decorated function is altered to use a different global namespace
         for its execution. This different global namespace exposes a limited
         set of functions from os.path.
         '''
         if not args:
             raise ConfigureError('@depends needs at least one argument')
 
-        resolved_args = []
         dependencies = []
         for arg in args:
             if isinstance(arg, types.StringTypes):
                 prefix, name, values = Option.split_option(arg)
                 if values != ():
                     raise ConfigureError("Option must not contain an '='")
                 if name not in self._options:
                     raise ConfigureError("'%s' is not a known option. "
                                          "Maybe it's declared too late?"
                                          % arg)
                 arg = self._options[name]
                 self._seen.add(arg)
                 dependencies.append(arg)
-                assert arg in self._option_values or self._help
-                resolved_arg = self._option_values.get(arg)
             elif isinstance(arg, DependsFunction):
                 assert arg in self._depends
                 dependencies.append(arg)
-                arg, _ = self._depends[arg]
-                resolved_arg = self._results.get(arg)
             else:
                 raise TypeError(
                     "Cannot use object of type '%s' as argument to @depends"
                     % type(arg).__name__)
-            resolved_args.append(resolved_arg)
         dependencies = tuple(dependencies)
 
         def decorator(func):
             if inspect.isgeneratorfunction(func):
                 raise ConfigureError(
                     'Cannot decorate generator functions with @depends')
             func, glob = self._prepare_function(func)
             dummy = wraps(func)(DependsFunction())
             self._depends[dummy] = func, dependencies
             with_help = self._help_option in dependencies
             if with_help:
-                for arg in args:
+                for arg in dependencies:
                     if isinstance(arg, DependsFunction):
                         _, deps = self._depends[arg]
                         if self._help_option not in deps:
                             raise ConfigureError(
                                 "`%s` depends on '--help' and `%s`. "
                                 "`%s` must depend on '--help'"
                                 % (func.__name__, arg.__name__, arg.__name__))
 
             if not self._help or with_help:
+                resolved_args = []
+                for arg in dependencies:
+                    if isinstance(arg, Option):
+                        assert arg in self._option_values
+                        resolved_args.append(self._option_values.get(arg))
+                    elif isinstance(arg, DependsFunction):
+                        arg, _ = self._depends[arg]
+                        resolved_args.append(self._results.get(arg))
+
                 self._results[func] = func(*resolved_args)
 
             return dummy
 
         return decorator
 
     def include_impl(self, what):
         '''Implementation of include().