code: def search_dependencies(self):
          
          result = [self.module.name]
          #First we look at the explicit use references from this module and all
          #its dependencies until the chain terminates.
          stack = self.needs
          while len(stack) > 0:
              module = stack.pop()
              if module in result:
                  continue
              
              self.parent.load_dependency(module, True, True, False)
              if module in self.parent.modules:
                  for dep in self.parent.modules[module].needs:
                      modname = dep.split(".")[0]
                      if modname not in result:
                          result.append(modname)
                      if modname not in stack:
                          stack.append(modname)
  
          #Add any incidentals from the automatic construction of code. These can be from
          #executables that use special precision types without importing them or from
          #derived types. Same applies to the local members of this module.
          for ekey, anexec in list(self.executables.items()):
              for dep in anexec.search_dependencies():
                  if dep is not None and dep not in result:
                      result.append(dep)
  
          for member in list(self.members.values()):
              dep = member.dependency()
              if dep is not None and dep not in result:
                  result.append(dep)
                          
          return result
docs: Returns a list of other modules that this module and its members and executables
          depend on in order to run correctly. This differs from the self.dependencies attribute
          that just hase explicit module names from the 'use' clauses.