code: def scan(self):
          
          # Don't bother scanning non-derived files, because we don't
          # care what their dependencies are.
          # Don't scan again, if we already have scanned.
          if self.implicit is not None:
              return
          self.implicit = []
          self.implicit_set = set()
          self._children_reset()
          if not self.has_builder():
              return
  
          build_env = self.get_build_env()
          executor = self.get_executor()
  
          # Here's where we implement --implicit-cache.
          if implicit_cache and not implicit_deps_changed:
              implicit = self.get_stored_implicit()
              if implicit is not None:
                  # We now add the implicit dependencies returned from the
                  # stored .sconsign entry to have already been converted
                  # to Nodes for us.  (We used to run them through a
                  # source_factory function here.)
  
                  # Update all of the targets with them.  This
                  # essentially short-circuits an N*M scan of the
                  # sources for each individual target, which is a hell
                  # of a lot more efficient.
                  for tgt in executor.get_all_targets():
                      tgt.add_to_implicit(implicit)
  
                  if implicit_deps_unchanged or self.is_up_to_date():
                      return
                  # one of this node's sources has changed,
                  # so we must recalculate the implicit deps for all targets
                  for tgt in executor.get_all_targets():
                      tgt.implicit = []
                      tgt.implicit_set = set()
  
          # Have the executor scan the sources.
          executor.scan_sources(self.builder.source_scanner)
  
          # If there's a target scanner, have the executor scan the target
          # node itself and associated targets that might be built.
          scanner = self.get_target_scanner()
          if scanner:
              executor.scan_targets(scanner)
docs: Scan this node's dependents for implicit dependencies.