def do(self):
        # If absolutely no buildRequires were found automatically,
        # assume that the buildRequires list has been carefully crafted
        # for some reason that the buildRequires enforcement policy
        # doesn't yet support, and don't warn that all of the listed
        # buildRequires might be excessive.
        if self.found and self.recipe._logFile:
            r = self.recipe
            def getReqNames(key):
                return set(x.split('=')[0] for x in r._recipeRequirements[key])
            recipeReqs = getReqNames('buildRequires')
            superReqs = getReqNames('buildRequiresSuper')
            foundPackages = set(x.split(':')[0] for x in self.found)
            superClosure = r._getTransitiveDepClosure(superReqs)
            foundClosure = r._getTransitiveDepClosure(self.found)

            def removeCore(candidates):
                # conary, python, and setup are always required; gcc
                # is often an implicit requirement, and sqlite:lib is
                # listed explicitly make bootstrapping easier
                return set(x for x in candidates if
                           not x.startswith('conary')
                           and not x.startswith('python:')
                           and not x.startswith('gcc:')
                           and not x in ('libgcc:devellib',
                                         'setup:runtime',
                                         'sqlite:lib'))

            def removeSome(candidates):
                # at this point, we don't have good enough detection
                # of :runtime in particular to recommend getting rid
                # of it
                return set(x for x in removeCore(candidates) if
                           not x.endswith(':runtime'))

            def removeDupComponents(candidates):
                # If any component is required, we don't really need
                # to flag others as excessive in superclass excess
                return set(x for x in candidates
                           if x.split(':')[0] not in foundPackages)

            # for superclass reqs
            excessSuperReqs = superReqs - foundClosure
            if excessSuperReqs:
                # note that as this is for debugging only, we do not
                # remove runtime requirements
                deDupedSuperReqs = sorted(list(
                    removeDupComponents(removeCore(excessSuperReqs))))
                if deDupedSuperReqs:
                    self._reportExcessSuperclassBuildRequires(deDupedSuperReqs)

            excessReqs = recipeReqs - self.found
            redundantReqs = recipeReqs.intersection(superClosure)
            if excessReqs or redundantReqs:
                excessBuildRequires = sorted(list(
                    removeSome(excessReqs.union(redundantReqs))))
                # all potential excess build requires might have
                # been removed by removeSome
                if excessBuildRequires:
                    self._reportExcessBuildRequires(excessBuildRequires)