     @importedModules = newSet()
     @_requested = newMap()
 
-  req: (moduleName, names) ->
-    addToMap @_requested, moduleName, names
+  req: (moduleName, importSetup) ->
+    addToMap @_requested, moduleName, importSetup
     if not @isModuleLoaded moduleName
       @_requesting = yes
 

  if (not isTuple reqTuple) or _empty reqs
    return malformed ctx, reqTuple, 'req requires a tuple of names to be required'
  map (syntaxNewName ctx, 'definition name to be imported required'), reqs
  [moduleNameAtom] = _validArguments call
  if not moduleNameAtom or not isName moduleNameAtom
    return malformed ctx, call, 'req requires a module name to require from'
  moduleNameAtom.label = 'module'
  declaredModuleName = moduleNameAtom.symbol
  requiredNames = (arrayToSet (filter _is, (map _symbol, reqs)))
  moduleName = (resolveModuleName ctx, declaredModuleName)
  ctx.req moduleName, requiredNames
  if ctx.isModuleLoaded moduleName
    for arg in reqs
      if (isName arg)
        name = arg.symbol
        if ctx.isFinallyTyped name, ctx.currentScopeIndex()

  modules: setToArray modules

moduleDependencies = (moduleName) ->
  concatSets (requiresFor moduleName), (newMapWith moduleName, importAll: yes)

reverseModuleDependencies = (moduleName) ->
  concatSets (newMapWith moduleName, importAll: yes), (requiresFor moduleName)

runtimeDependencies = (moduleName) ->
  concatSets (collectRequiresFor moduleName), (newSetWith moduleName)

modulePathToName = (path) ->
  path.join '/'
