code: def _unfiltered_jvm_dependency_map(self, fully_transitive=False):
      
      targets = self.jvm_targets
      jvm_deps = defaultdict(set)
  
      def accumulate_jvm_deps(target):
        for dep in target.dependencies:
          if self._is_jvm_target(dep):
            jvm_deps[target].add(dep)
            if not fully_transitive:
              continue
          # If 'dep' isn't in jvm_deps, that means that it isn't in the `targets` list at all
          # (since this is a post-order traversal). If it's not in the targets list at all,
          # that means it cannot have any JvmTargets as transitive dependencies. In which case
          # we don't care about it, so it's fine that the line below is a no-op.
          #
          # Otherwise, we add in any transitive dependencies that were previously collected.
          jvm_deps[target].update(jvm_deps[dep])
  
      # Vanilla DFS runs in O(|V|+|E|), and the code inside the loop in accumulate_jvm_deps ends up
      # being run once for each in the graph over the course of the entire search, which means that
      # the total asymptotic runtime complexity is O(|V|+2|E|), which is still O(|V|+|E|).
      self.context.build_graph.walk_transitive_dependency_graph(
        addresses=[t.address for t in targets],
        work=accumulate_jvm_deps,
        postorder=True
      )
  
      return jvm_deps
docs: Jvm dependency map without filtering out non-JvmTarget keys, exposed for testing.
  
      Unfiltered because the keys in the resulting map include non-JvmTargets.
  
      See the explanation in the jvm_dependency_map() docs for what this method produces.
  
      :param fully_transitive: if true, the elements of the map will be the full set of transitive
        JvmTarget dependencies, not just the "direct" ones. (see jvm_dependency_map for the definition
        of "direct")
      :return: map of target -> set of JvmTarget "direct" dependencies.