[analyzer] Modernize analyzer's Python scripts

[vsavchenko]

Summary

Fix read/write in binary format, which crashes Python 3.
Additionally, clean up redundant (as for Python 3) code and
fix a handful of flake8 warnings.

[vsavchenko]

Add more 'super' clean-ups

[NoQ]

Thanks!!

Note that there are no tests for these scripts. It's probably not too bad because these scripts *are* the tests but we might as well benefit from some quicker LIT tests that'll respond to our mistakes faster than buildbot re-runs.

clang/utils/analyzer/CmpRuns.py

 import json
 import os
 import plistlib
 import re
 import sys
 
 STATS_REGEXP = re.compile(r"Statistics: (\{.+\})", re.MULTILINE | re.DOTALL)
 
-class Colors(object):
+
+class Colors:
     """
     Color for terminal highlight.
     """
     RED = '\x1b[2;30;41m'
     GREEN = '\x1b[6;30;42m'
     CLEAR = '\x1b[0m'
 
-# Information about analysis run:
-# path - the analysis output directory
-# root - the name of the root directory, which will be disregarded when
-# determining the source file name
-class SingleRunInfo(object):
+
+class SingleRunInfo:
+    """
+    Information about analysis run:
+    path - the analysis output directory
+    root - the name of the root directory, which will be disregarded when
+    determining the source file name
+    """
     def __init__(self, path, root="", verboseLog=None):
         self.path = path
         self.root = root.rstrip("/\\")
         self.verboseLog = verboseLog
 
 
-class AnalysisDiagnostic(object):
+class AnalysisDiagnostic:
     def __init__(self, data, report, htmlReport):
         self._data = data
         self._loc = self._data['location']
         self._report = report
         self._htmlReport = htmlReport
         self._reportSize = len(self._data['path'])
 
     def getFileName(self):
         root = self._report.run.root
         fileName = self._report.files[self._loc['file']]
         if fileName.startswith(root) and len(root) > 0:
             return fileName[len(root) + 1:]
         return fileName
 
     def getRootFileName(self):
         path = self._data['path']
         if not path:
             return self.getFileName()
         p = path[0]
         if 'location' in p:
             fIdx = p['location']['file']
-        else: # control edge
+        else:  # control edge
             fIdx = path[0]['edges'][0]['start'][0]['file']
         out = self._report.files[fIdx]
         root = self._report.run.root
         if out.startswith(root):
             return out[len(root):]
         return out
 
     def getLine(self):
def getReadableName(self):
                                        self.getDescription())
 
     # Note, the data format is not an API and may change from one analyzer
     # version to another.
     def getRawData(self):
         return self._data
 
 
-class AnalysisReport(object):
+class AnalysisReport:
     def __init__(self, run, files):
         self.run = run
         self.files = files
         self.diagnostics = []
 
 
-class AnalysisRun(object):
+class AnalysisRun:
     def __init__(self, info):
         self.path = info.path
         self.root = info.root
         self.info = info
         self.reports = []
         # Cumulative list of all diagnostics from all the reports.
         self.diagnostics = []
         self.clang_version = None
def compareResults(A, B, opts):
     if opts.relative_log_path_histogram or opts.relative_path_histogram or \
             opts.absolute_path_histogram:
         from matplotlib import pyplot
         pyplot.hist(path_difference_data, bins=100)
         pyplot.show()
 
     return res
 
+
 def computePercentile(l, percentile):
     """
     Return computed percentile.
     """
     return sorted(l)[int(round(percentile * len(l) + 0.5)) - 1]
 
+
 def deriveStats(results):
     # Assume all keys are the same in each statistics bucket.
     combined_data = defaultdict(list)
 
     # Collect data on paths length.
     for report in results.reports:
         for diagnostic in report.diagnostics:
             combined_data['PathsLength'].append(diagnostic.getPathLength())
for key in keys:
                 if valB != 0:
                     ratio = (valB - valA) / valB
                     if ratio < -0.2:
                         report = Colors.GREEN + report + Colors.CLEAR
                     elif ratio > 0.2:
                         report = Colors.RED + report + Colors.CLEAR
             print("\t %s %s" % (kkey, report))
 
+
 def dumpScanBuildResultsDiff(dirA, dirB, opts, deleteEmpty=True,
                              Stdout=sys.stdout):
     # Load the run results.
     resultsA = loadResults(dirA, opts, opts.rootA, deleteEmpty)
     resultsB = loadResults(dirB, opts, opts.rootB, deleteEmpty)
     if opts.show_stats:
         compareStats(resultsA, resultsB)
     if opts.stats_only:
         return
 
     # Open the verbose log, if given.
     if opts.verboseLog:
-        auxLog = open(opts.verboseLog, "wb")
+        auxLog = open(opts.verboseLog, "w")
     else:
         auxLog = None
 
     diff = compareResults(resultsA, resultsB, opts)
     foundDiffs = 0
     totalAdded = 0
     totalRemoved = 0
     for res in diff:
def dumpScanBuildResultsDiff(dirA, dirB, opts, deleteEmpty=True,
     Stdout.write("TOTAL REMOVED: %r\n" % totalRemoved)
     if auxLog:
         auxLog.write("('TOTAL NEW REPORTS', %r)\n" % TotalReports)
         auxLog.write("('TOTAL DIFFERENCES', %r)\n" % foundDiffs)
         auxLog.close()
 
     return foundDiffs, len(resultsA.diagnostics), len(resultsB.diagnostics)
 
+
 def generate_option_parser():
     parser = OptionParser("usage: %prog [options] [dir A] [dir B]")
     parser.add_option("", "--rootA", dest="rootA",
                       help="Prefix to ignore on source files for directory A",
                       action="store", type=str, default="")
     parser.add_option("", "--rootB", dest="rootB",
                       help="Prefix to ignore on source files for directory B",
                       action="store", type=str, default="")

clang/utils/analyzer/SATestAdd.py

 
 import os
 import csv
 import sys
 
 
 def isExistingProject(PMapFile, projectID):
     PMapReader = csv.reader(PMapFile)
-    for I in PMapReader:
-        if projectID == I[0]:
+    for ProjectInfo in PMapReader:
+        if projectID == ProjectInfo[0]:
             return True
     return False
 
 
 def addNewProject(ID, BuildMode):
     """
     Add a new project for testing: build it and add to the Project Map file.
     :param ID: is a short string used to identify a project.
     """
 
     CurDir = os.path.abspath(os.curdir)
     Dir = SATestBuild.getProjectDir(ID)
     if not os.path.exists(Dir):
         print("Error: Project directory is missing: %s" % Dir)
         sys.exit(-1)
 
     # Build the project.
+    # TODO: Repair this call.  We give it a wrong amount wrong arguments and it
+    #       is not trivial to construct argparse arguments in here.
+    #       Requires refactoring of the 'testProject' function.
     SATestBuild.testProject(ID, BuildMode, IsReferenceBuild=True)
 
     # Add the project ID to the project map.
     ProjectMapPath = os.path.join(CurDir, SATestBuild.ProjectMapFile)
 
     if os.path.exists(ProjectMapPath):
-        FileMode = "r+b"
+        FileMode = "r+"
     else:
         print("Warning: Creating the Project Map file!!")
-        FileMode = "w+b"
+        FileMode = "w+"
 
     with open(ProjectMapPath, FileMode) as PMapFile:
         if (isExistingProject(PMapFile, ID)):
-            print('Warning: Project with ID \'', ID, \
-                                 '\' already exists.', file=sys.stdout)
+            print('Warning: Project with ID \'', ID,
             print("Reference output has been regenerated.", file=sys.stdout)
         else:
             PMapWriter = csv.writer(PMapFile)
             PMapWriter.writerow((ID, int(BuildMode)))
             print("The project map is updated: ", ProjectMapPath)
 
 
 # TODO: Add an option not to build.
 # TODO: Set the path to the Repository directory.
 if __name__ == '__main__':
     if len(sys.argv) < 2 or sys.argv[1] in ('-h', '--help'):
-        print('Add a new project for testing to the analyzer'\
-                             '\nUsage: ', sys.argv[0],\
-                             'project_ID <mode>\n' \
-                             'mode: 0 for single file project, ' \
-                             '1 for scan_build, ' \
-                             '2 for single file c++11 project', file=sys.stderr)
+        print('Add a new project for testing to the analyzer'
+              '\nUsage: ', sys.argv[0],
+              'project_ID <mode>\n'
+              'mode: 0 for single file project, '
+              '1 for scan_build, '
         sys.exit(-1)
 
     BuildMode = 1
     if (len(sys.argv) >= 3):
         BuildMode = int(sys.argv[2])
     assert((BuildMode == 0) | (BuildMode == 1) | (BuildMode == 2))
 
     addNewProject(sys.argv[1], BuildMode)

clang/utils/analyzer/SATestBuild.py

 
 Local = threading.local()
 Local.stdout = sys.stdout
 Local.stderr = sys.stderr
 logging.basicConfig(
     level=logging.DEBUG,
     format='%(asctime)s:%(levelname)s:%(name)s: %(message)s')
 
-class StreamToLogger(object):
+
+class StreamToLogger:
     def __init__(self, logger, log_level=logging.INFO):
         self.logger = logger
         self.log_level = log_level
 
     def write(self, buf):
         # Rstrip in order not to write an extra newline.
         self.logger.log(self.log_level, buf.rstrip())
 
for FullFileName in glob.glob(Dir + "/*"):
         if not SATestUtils.isValidSingleInputFile(FileName):
             Local.stderr.write(
                 "Error: Invalid single input file %s.\n" % (FullFileName,))
             raise Exception()
 
         # Build and call the analyzer command.
         OutputOption = "-o '%s.plist' " % os.path.join(PlistPath, FileName)
         Command = CmdPrefix + OutputOption + ("'%s'" % FileName)
-        LogFile = open(os.path.join(FailPath, FileName + ".stderr.txt"), "w+b")
+        LogFile = open(os.path.join(FailPath, FileName + ".stderr.txt"), "w+")
         try:
             if Verbose == 1:
                 Local.stdout.write("  Executing: %s\n" % (Command,))
             check_call(Command, cwd=Dir, stderr=LogFile,
                        stdout=LogFile,
                        shell=True)
         except CalledProcessError as e:
             Local.stderr.write("Error: Analyzes of %s failed. "
if (os.path.exists(SBOutputDir)):
         if Verbose == 1:
             Local.stdout.write("  Executing: %s\n" % (RmCommand,))
             check_call(RmCommand, shell=True, stdout=Local.stdout,
                        stderr=Local.stderr)
     assert(not os.path.exists(SBOutputDir))
     os.makedirs(os.path.join(SBOutputDir, LogFolderName))
 
     # Build and analyze the project.
-    with open(BuildLogPath, "wb+") as PBuildLogFile:
+    with open(BuildLogPath, "w+") as PBuildLogFile:
         if (ProjectBuildMode == 1):
             downloadAndPatch(Dir, PBuildLogFile)
             runCleanupScript(Dir, PBuildLogFile)
             runScanBuild(Args, Dir, SBOutputDir, PBuildLogFile)
         else:
             runAnalyzePreprocessed(Args, Dir, SBOutputDir, ProjectBuildMode)
 
         if IsReferenceBuild:
def __init__(self, Args, TasksQueue, ResultsDiffer, FailureFlag):
         :param ResultsDiffer: Used to signify that results differ from
         the canonical ones.
         :param FailureFlag: Used to signify a failure during the run.
         """
         self.Args = Args
         self.TasksQueue = TasksQueue
         self.ResultsDiffer = ResultsDiffer
         self.FailureFlag = FailureFlag
-        super(TestProjectThread, self).__init__()
+        super().__init__()
 
         # Needed to gracefully handle interrupts with Ctrl-C
         self.daemon = True
 
     def run(self):
         while not self.TasksQueue.empty():
             try:
                 ProjArgs = self.TasksQueue.get()
else:
         TestsPassed = runCmpResults(Dir, Strictness)
 
     Local.stdout.write("Completed tests for project %s (time: %.2f).\n" % (
                        ID, (time.time() - TBegin)))
     return TestsPassed
 
 
 def projectFileHandler():
-    return open(getProjectMapPath(), "rb")
+    return open(getProjectMapPath(), "r")
 
 
 def iterateOverProjects(PMapFile):
     """
     Iterate over all projects defined in the project file handler `PMapFile`
     from the start.
     """
     PMapFile.seek(0)
-    for I in csv.reader(PMapFile):
-        if (SATestUtils.isCommentCSVLine(I)):
+    for ProjectInfo in csv.reader(PMapFile):
+        if (SATestUtils.isCommentCSVLine(ProjectInfo)):
             continue
-        yield I
+        yield ProjectInfo
 
 
 def validateProjectFile(PMapFile):
     """
     Validate project file.
     """
-    for I in iterateOverProjects(PMapFile):
-        if len(I) != 2:
+    for ProjectInfo in iterateOverProjects(PMapFile):
+        if len(ProjectInfo) != 2:
             print("Error: Rows in the ProjectMapFile should have 2 entries.")
             raise Exception()
-        if I[1] not in ('0', '1', '2'):
-            print("Error: Second entry in the ProjectMapFile should be 0" \
+        if ProjectInfo[1] not in ('0', '1', '2'):
+            print("Error: Second entry in the ProjectMapFile should be 0"
                   " (single file), 1 (project), or 2(single file c++11).")
             raise Exception()
 
+
 def singleThreadedTestAll(Args, ProjectsToTest):
     """
     Run all projects.
     :return: whether tests have passed.
     """
     Success = True
     for ProjArgs in ProjectsToTest:
         Success &= testProject(Args, *ProjArgs)
     return Success
 
+
 def multiThreadedTestAll(Args, ProjectsToTest, Jobs):
     """
     Run each project in a separate thread.
 
     This is OK despite GIL, as testing is blocked
     on launching external processes.
 
     :return: whether tests have passed.

clang/utils/analyzer/SATestUpdateDiffs.py

def updateReferenceResults(ProjName, ProjBuildMode):
     RefResultsPath = os.path.join(
         ProjDir,
         SATestBuild.getSBOutputDirName(IsReferenceBuild=True))
     CreatedResultsPath = os.path.join(
         ProjDir,
         SATestBuild.getSBOutputDirName(IsReferenceBuild=False))
 
     if not os.path.exists(CreatedResultsPath):
-        print("New results not found, was SATestBuild.py "\
-                             "previously run?", file=sys.stderr)
+        print("New results not found, was SATestBuild.py "
         sys.exit(1)
 
     BuildLogPath = SATestBuild.getBuildLogPath(RefResultsPath)
     Dirname = os.path.dirname(os.path.abspath(BuildLogPath))
     runCmd("mkdir -p '%s'" % Dirname)
-    with open(BuildLogPath, "wb+") as PBuildLogFile:
+    with open(BuildLogPath, "w+") as PBuildLogFile:
         # Remove reference results: in git, and then again for a good measure
         # with rm, as git might not remove things fully if there are empty
         # directories involved.
         runCmd('git rm -r -q "%s"' % (RefResultsPath,), stdout=PBuildLogFile)
         runCmd('rm -rf "%s"' % (RefResultsPath,), stdout=PBuildLogFile)
 
         # Replace reference results with a freshly computed once.
         runCmd('cp -r "%s" "%s"' % (CreatedResultsPath, RefResultsPath,),
                stdout=PBuildLogFile)
 
         # Run cleanup script.
         SATestBuild.runCleanupScript(ProjDir, PBuildLogFile)
 
         SATestBuild.normalizeReferenceResults(
             ProjDir, RefResultsPath, ProjBuildMode)
 
         # Clean up the generated difference results.
         SATestBuild.cleanupReferenceResults(RefResultsPath)
 
         runCmd('git add "%s"' % (RefResultsPath,), stdout=PBuildLogFile)
 
 
 def main(argv):
     if len(argv) == 2 and argv[1] in ('-h', '--help'):
-        print("Update static analyzer reference results based "\
-                             "\non the previous run of SATestBuild.py.\n"\
-                             "\nN.B.: Assumes that SATestBuild.py was just run", file=sys.stderr)
+        print("Update static analyzer reference results based "
+              "\non the previous run of SATestBuild.py.\n"
+              "\nN.B.: Assumes that SATestBuild.py was just run",
+              file=sys.stderr)
         sys.exit(1)
 
     with SATestBuild.projectFileHandler() as f:
         for (ProjName, ProjBuildMode) in SATestBuild.iterateOverProjects(f):
             updateReferenceResults(ProjName, int(ProjBuildMode))
 
 
 if __name__ == '__main__':
     main(sys.argv)

clang/utils/analyzer/SATestUtils.py

 import os
 from subprocess import check_call
 import sys
 
 
 Verbose = 1
 
+
 def which(command, paths=None):
     """which(command, [paths]) - Look up the given command in the paths string
     (or the PATH environment variable, if unspecified)."""
 
     if paths is None:
         paths = os.environ.get('PATH', '')
 
     # Check for absolute match first.

clang/utils/analyzer/SumTimerInfo.py

 #!/usr/bin/env python
 
 """
 Script to Summarize statistics in the scan-build output.
 
 Statistics are enabled by passing '-internal-stats' option to scan-build
 (or '-analyzer-stats' to the analyzer).
 """
 from __future__ import absolute_import, division, print_function
 
 import sys
 
 if __name__ == '__main__':
     if len(sys.argv) < 2:
-        print('Usage: ', sys.argv[0],\
-                             'scan_build_output_file', file=sys.stderr)
+        print('Usage: ', sys.argv[0],
         sys.exit(-1)
 
     f = open(sys.argv[1], 'r')
     Time = 0.0
     TotalTime = 0.0
     MaxTime = 0.0
     Warnings = 0
     Count = 0

clang/utils/analyzer/exploded-graph-rewriter.py

 # A helper function for finding the difference between two dictionaries.
 def diff_dicts(curr, prev):
     removed = [k for k in prev if k not in curr or curr[k] != prev[k]]
     added = [k for k in curr if k not in prev or curr[k] != prev[k]]
     return (removed, added)
 
 
 # Represents any program state trait that is a dictionary of key-value pairs.
-class GenericMap(object):
+class GenericMap:
     def __init__(self, items):
         self.generic_map = collections.OrderedDict(items)
 
     def diff(self, prev):
         return diff_dicts(self.generic_map, prev.generic_map)
 
     def is_different(self, prev):
         removed, added = self.diff(prev)
         return len(removed) != 0 or len(added) != 0
 
 
 # A deserialized source location.
-class SourceLocation(object):
+class SourceLocation:
     def __init__(self, json_loc):
-        super(SourceLocation, self).__init__()
         logging.debug('json: %s' % json_loc)
         self.line = json_loc['line']
         self.col = json_loc['column']
         self.filename = os.path.basename(json_loc['file']) \
             if 'file' in json_loc else '(main file)'
         self.spelling = SourceLocation(json_loc['spelling']) \
             if 'spelling' in json_loc else None
 
     def is_macro(self):
         return self.spelling is not None
 
 
 # A deserialized program point.
-class ProgramPoint(object):
+class ProgramPoint:
     def __init__(self, json_pp):
-        super(ProgramPoint, self).__init__()
         self.kind = json_pp['kind']
         self.tag = json_pp['tag']
         self.node_id = json_pp['node_id']
         self.is_sink = bool(json_pp['is_sink'])
         self.has_report = bool(json_pp['has_report'])
         if self.kind == 'Edge':
             self.src_id = json_pp['src_id']
             self.dst_id = json_pp['dst_id']
         elif self.kind == 'Statement':
             logging.debug(json_pp)
             self.stmt_kind = json_pp['stmt_kind']
             self.cast_kind = json_pp['cast_kind'] \
                 if 'cast_kind' in json_pp else None
             self.stmt_point_kind = json_pp['stmt_point_kind']
             self.stmt_id = json_pp['stmt_id']
             self.pointer = json_pp['pointer']
             self.pretty = json_pp['pretty']
             self.loc = SourceLocation(json_pp['location']) \
                 if json_pp['location'] is not None else None
         elif self.kind == 'BlockEntrance':
             self.block_id = json_pp['block_id']
 
 
 # A single expression acting as a key in a deserialized Environment.
-class EnvironmentBindingKey(object):
+class EnvironmentBindingKey:
     def __init__(self, json_ek):
-        super(EnvironmentBindingKey, self).__init__()
         # CXXCtorInitializer is not a Stmt!
         self.stmt_id = json_ek['stmt_id'] if 'stmt_id' in json_ek \
             else json_ek['init_id']
         self.pretty = json_ek['pretty']
         self.kind = json_ek['kind'] if 'kind' in json_ek else None
 
     def _key(self):
         return self.stmt_id
 
     def __eq__(self, other):
         return self._key() == other._key()
 
     def __hash__(self):
         return hash(self._key())
 
 
 # Deserialized description of a location context.
-class LocationContext(object):
+class LocationContext:
     def __init__(self, json_frame):
-        super(LocationContext, self).__init__()
         self.lctx_id = json_frame['lctx_id']
         self.caption = json_frame['location_context']
         self.decl = json_frame['calling']
         self.loc = SourceLocation(json_frame['location']) \
             if json_frame['location'] is not None else None
 
     def _key(self):
         return self.lctx_id
 
     def __eq__(self, other):
         return self._key() == other._key()
 
     def __hash__(self):
         return hash(self._key())
 
 
 # A group of deserialized Environment bindings that correspond to a specific
 # location context.
-class EnvironmentFrame(object):
+class EnvironmentFrame:
     def __init__(self, json_frame):
-        super(EnvironmentFrame, self).__init__()
         self.location_context = LocationContext(json_frame)
         self.bindings = collections.OrderedDict(
             [(EnvironmentBindingKey(b),
               b['value']) for b in json_frame['items']]
             if json_frame['items'] is not None else [])
 
     def diff_bindings(self, prev):
         return diff_dicts(self.bindings, prev.bindings)
 
     def is_different(self, prev):
         removed, added = self.diff_bindings(prev)
         return len(removed) != 0 or len(added) != 0
 
 
 # A deserialized Environment. This class can also hold other entities that
 # are similar to Environment, such as Objects Under Construction.
-class GenericEnvironment(object):
+class GenericEnvironment:
     def __init__(self, json_e):
-        super(GenericEnvironment, self).__init__()
         self.frames = [EnvironmentFrame(f) for f in json_e]
 
     def diff_frames(self, prev):
         # TODO: It's difficult to display a good diff when frame numbers shift.
         if len(self.frames) != len(prev.frames):
             return None
 
         updated = []
def diff_frames(self, prev):
         return updated
 
     def is_different(self, prev):
         updated = self.diff_frames(prev)
         return updated is None or len(updated) > 0
 
 
 # A single binding key in a deserialized RegionStore cluster.
-class StoreBindingKey(object):
+class StoreBindingKey:
     def __init__(self, json_sk):
-        super(StoreBindingKey, self).__init__()
         self.kind = json_sk['kind']
         self.offset = json_sk['offset']
 
     def _key(self):
         return (self.kind, self.offset)
 
     def __eq__(self, other):
         return self._key() == other._key()
 
     def __hash__(self):
         return hash(self._key())
 
 
 # A single cluster of the deserialized RegionStore.
-class StoreCluster(object):
+class StoreCluster:
     def __init__(self, json_sc):
-        super(StoreCluster, self).__init__()
         self.base_region = json_sc['cluster']
         self.bindings = collections.OrderedDict(
             [(StoreBindingKey(b), b['value']) for b in json_sc['items']])
 
     def diff_bindings(self, prev):
         return diff_dicts(self.bindings, prev.bindings)
 
     def is_different(self, prev):
         removed, added = self.diff_bindings(prev)
         return len(removed) != 0 or len(added) != 0
 
 
 # A deserialized RegionStore.
-class Store(object):
+class Store:
     def __init__(self, json_s):
-        super(Store, self).__init__()
         self.ptr = json_s['pointer']
         self.clusters = collections.OrderedDict(
             [(c['pointer'], StoreCluster(c)) for c in json_s['items']])
 
     def diff_clusters(self, prev):
         removed = [k for k in prev.clusters if k not in self.clusters]
         added = [k for k in self.clusters if k not in prev.clusters]
         updated = [k for k in prev.clusters if k in self.clusters
                    and prev.clusters[k].is_different(self.clusters[k])]
         return (removed, added, updated)
 
     def is_different(self, prev):
         removed, added, updated = self.diff_clusters(prev)
         return len(removed) != 0 or len(added) != 0 or len(updated) != 0
 
 
 # Deserialized messages from a single checker in a single program state.
 # Basically a list of raw strings.
-class CheckerLines(object):
+class CheckerLines:
     def __init__(self, json_lines):
-        super(CheckerLines, self).__init__()
         self.lines = json_lines
 
     def diff_lines(self, prev):
         lines = difflib.ndiff(prev.lines, self.lines)
         return [l.strip() for l in lines
                 if l.startswith('+') or l.startswith('-')]
 
     def is_different(self, prev):
         return len(self.diff_lines(prev)) > 0
 
 
 # Deserialized messages of all checkers, separated by checker.
-class CheckerMessages(object):
+class CheckerMessages:
     def __init__(self, json_m):
-        super(CheckerMessages, self).__init__()
         self.items = collections.OrderedDict(
             [(m['checker'], CheckerLines(m['messages'])) for m in json_m])
 
     def diff_messages(self, prev):
         removed = [k for k in prev.items if k not in self.items]
         added = [k for k in self.items if k not in prev.items]
         updated = [k for k in prev.items if k in self.items
                    and prev.items[k].is_different(self.items[k])]
         return (removed, added, updated)
 
     def is_different(self, prev):
         removed, added, updated = self.diff_messages(prev)
         return len(removed) != 0 or len(added) != 0 or len(updated) != 0
 
 
 # A deserialized program state.
-class ProgramState(object):
+class ProgramState:
     def __init__(self, state_id, json_ps):
-        super(ProgramState, self).__init__()
         logging.debug('Adding ProgramState ' + str(state_id))
 
         if json_ps is None:
             json_ps = {
                 'store': None,
                 'environment': None,
                 'constraints': None,
                 'dynamic_types': None,
def __init__(self, state_id, json_ps):
 
         self.checker_messages = CheckerMessages(json_ps['checker_messages']) \
             if json_ps['checker_messages'] is not None else None
 
 
 # A deserialized exploded graph node. Has a default constructor because it
 # may be referenced as part of an edge before its contents are deserialized,
 # and in this moment we already need a room for predecessors and successors.
-class ExplodedNode(object):
+class ExplodedNode:
     def __init__(self):
-        super(ExplodedNode, self).__init__()
         self.predecessors = []
         self.successors = []
 
     def construct(self, node_id, json_node):
         logging.debug('Adding ' + node_id)
         self.ptr = node_id[4:]
         self.points = [ProgramPoint(p) for p in json_node['program_points']]
         self.node_id = self.points[-1].node_id
         self.state = ProgramState(json_node['state_id'],
                                   json_node['program_state']
             if json_node['program_state'] is not None else None);
 
         assert self.node_name() == node_id
 
     def node_name(self):
         return 'Node' + self.ptr
 
 
 # A deserialized ExplodedGraph. Constructed by consuming a .dot file
 # line-by-line.
-class ExplodedGraph(object):
+class ExplodedGraph:
     # Parse .dot files with regular expressions.
     node_re = re.compile(
         '^(Node0x[0-9a-f]*) \\[shape=record,.*label="{(.*)\\\\l}"\\];$')
     edge_re = re.compile(
         '^(Node0x[0-9a-f]*) -> (Node0x[0-9a-f]*);$')
 
     def __init__(self):
-        super(ExplodedGraph, self).__init__()
         self.nodes = collections.defaultdict(ExplodedNode)
         self.root_id = None
         self.incomplete_line = ''
 
     def add_raw_line(self, raw_line):
         if raw_line.startswith('//'):
             return
 

 #===-----------------------------------------------------------------------===#
 # Visitors traverse a deserialized ExplodedGraph and do different things
 # with every node and edge.
 #===-----------------------------------------------------------------------===#
 
 
 # A visitor that dumps the ExplodedGraph into a DOT file with fancy HTML-based
 # syntax highlighing.
-class DotDumpVisitor(object):
+class DotDumpVisitor:
     def __init__(self, do_diffs, dark_mode, gray_mode,
                  topo_mode, dump_dot_only):
-        super(DotDumpVisitor, self).__init__()
         self._do_diffs = do_diffs
         self._dark_mode = dark_mode
         self._gray_mode = gray_mode
         self._topo_mode = topo_mode
         self._dump_dot_only = dump_dot_only
         self._output = []
 
     def _dump_raw(self, s):

 
 #===-----------------------------------------------------------------------===#
 # Explorers know how to traverse the ExplodedGraph in a certain order.
 # They would invoke a Visitor on every node or edge they encounter.
 #===-----------------------------------------------------------------------===#
 
 
 # BasicExplorer explores the whole graph in no particular order.
-class BasicExplorer(object):
-    def __init__(self):
-        super(BasicExplorer, self).__init__()
-
+class BasicExplorer:
     def explore(self, graph, visitor):
         visitor.visit_begin_graph(graph)
         for node in sorted(graph.nodes):
             logging.debug('Visiting ' + node)
             visitor.visit_node(graph.nodes[node])
             for succ in sorted(graph.nodes[node].successors):
                 logging.debug('Visiting edge: %s -> %s ' % (node, succ))
                 visitor.visit_edge(graph.nodes[node], graph.nodes[succ])
         visitor.visit_end_of_graph()
 
 
 #===-----------------------------------------------------------------------===#
 # Trimmers cut out parts of the ExplodedGraph so that to focus on other parts.
 # Trimmers can be combined together by applying them sequentially.
 #===-----------------------------------------------------------------------===#
 
 
 # SinglePathTrimmer keeps only a single path - the leftmost path from the root.
 # Useful when the trimmed graph is still too large.
-class SinglePathTrimmer(object):
-    def __init__(self):
-        super(SinglePathTrimmer, self).__init__()
-
+class SinglePathTrimmer:
     def trim(self, graph):
         visited_nodes = set()
         node_id = graph.root_id
         while True:
             visited_nodes.add(node_id)
             node = graph.nodes[node_id]
             if len(node.successors) > 0:
                 succ_id = node.successors[0]
                 succ = graph.nodes[succ_id]
                 node.successors = [succ_id]
                 succ.predecessors = [node_id]
                 if succ_id in visited_nodes:
                     break
                 node_id = succ_id
             else:
                 break
         graph.nodes = {node_id: graph.nodes[node_id]
                        for node_id in visited_nodes}
 
 
 # TargetedTrimmer keeps paths that lead to specific nodes and discards all
 # other paths. Useful when you cannot use -trim-egraph (e.g. when debugging
 # a crash).
-class TargetedTrimmer(object):
+class TargetedTrimmer:
     def __init__(self, target_nodes):
-        super(TargetedTrimmer, self).__init__()
         self._target_nodes = target_nodes
 
     @staticmethod
     def parse_target_node(node, graph):
         if node.startswith('0x'):
             ret = 'Node' + node
             assert ret in graph.nodes
             return ret