Make several Python scripts portable across Python2 and Python 3

[serge-sans-paille]

Summary

This part only handles object inheritance

No extra dependency added.

[serge-sans-paille]

Conversion using the `futurize` script, then manual review. For the sake of reviewer sanity, I've left all the difficult part to further separate commits.

[michaelplatings]

In general LGTM, as someone who's done a 2-3 conversion of similar scale before.

The only suggestion I'd make is to consider changing the __future__ imports to from __future__ import absolute_import, division, print_function
I found this gave the best consistency between 2 & 3. Probably you don't need it at this point, but once the conversion is done there's less to go wrong in future.

[serge-sans-paille]

Use generic `from __future__ import ` line whenever it makes sense

[joerg]

Can you split off the pure modernisation changes like new exception or print ? Those are completely non-contentious changes after all. I generally do not like the range and list related changes as many instances are clear regressions for the 2.x case. filter to list comprehension should IMO be a separate change as well, but those are much less problematic and often an improvement in terms of both performance and readability.

[michaelplatings]

LGTM

cfe/trunk/bindings/python/clang/cindex.py

def location(self):
         return conf.lib.clang_getDiagnosticLocation(self)
 
     @property
     def spelling(self):
         return conf.lib.clang_getDiagnosticSpelling(self)
 
     @property
     def ranges(self):
-        class RangeIterator:
+        class RangeIterator(object):
             def __init__(self, diag):
                 self.diag = diag
 
             def __len__(self):
                 return int(conf.lib.clang_getDiagnosticNumRanges(self.diag))
 
             def __getitem__(self, key):
                 if (key >= len(self)):
                     raise IndexError
                 return conf.lib.clang_getDiagnosticRange(self.diag, key)
 
         return RangeIterator(self)
 
     @property
     def fixits(self):
-        class FixItIterator:
+        class FixItIterator(object):
             def __init__(self, diag):
                 self.diag = diag
 
             def __len__(self):
                 return int(conf.lib.clang_getDiagnosticNumFixIts(self.diag))
 
             def __getitem__(self, key):
                 range = SourceRange()
                 value = conf.lib.clang_getDiagnosticFixIt(self.diag, key,
                         byref(range))
                 if len(value) == 0:
                     raise IndexError
 
                 return FixIt(range, value)
 
         return FixItIterator(self)
 
     @property
     def children(self):
-        class ChildDiagnosticsIterator:
+        class ChildDiagnosticsIterator(object):
             def __init__(self, diag):
                 self.diag_set = conf.lib.clang_getChildDiagnostics(diag)
 
             def __len__(self):
                 return int(conf.lib.clang_getNumDiagnosticsInSet(self.diag_set))
 
             def __getitem__(self, key):
                 diag = conf.lib.clang_getDiagnosticInSet(self.diag_set, key)
SpellingCache = {
             # 15: CompletionChunk.Kind("ResultType"),
             16: ':',  # CompletionChunk.Kind("Colon"),
             17: ';',  # CompletionChunk.Kind("SemiColon"),
             18: '=',  # CompletionChunk.Kind("Equal"),
             19: ' ',  # CompletionChunk.Kind("HorizontalSpace"),
             # 20: CompletionChunk.Kind("VerticalSpace")
 }
 
-class CompletionChunk:
-    class Kind:
+class CompletionChunk(object):
+    class Kind(object):
         def __init__(self, name):
             self.name = name
 
         def __str__(self):
             return self.name
 
         def __repr__(self):
             return "<ChunkKind: %s>" % self
completionChunkKindMap = {
             15: CompletionChunk.Kind("ResultType"),
             16: CompletionChunk.Kind("Colon"),
             17: CompletionChunk.Kind("SemiColon"),
             18: CompletionChunk.Kind("Equal"),
             19: CompletionChunk.Kind("HorizontalSpace"),
             20: CompletionChunk.Kind("VerticalSpace")}
 
 class CompletionString(ClangObject):
-    class Availability:
+    class Availability(object):
         def __init__(self, name):
             self.name = name
 
         def __str__(self):
             return self.name
 
         def __repr__(self):
             return "<Availability: %s>" % self
def __del__(self):
         conf.lib.clang_disposeCodeCompleteResults(self)
 
     @property
     def results(self):
         return self.ptr.contents
 
     @property
     def diagnostics(self):
-        class DiagnosticsItr:
+        class DiagnosticsItr(object):
             def __init__(self, ccr):
                 self.ccr= ccr
 
             def __len__(self):
                 return int(\
                   conf.lib.clang_codeCompleteGetNumDiagnostics(self.ccr))
 
             def __getitem__(self, key):
def get_extent(self, filename, locations):
 
         return SourceRange.from_locations(start_location, end_location)
 
     @property
     def diagnostics(self):
         """
         Return an iterable (and indexable) object containing the diagnostics.
         """
-        class DiagIterator:
+        class DiagIterator(object):
             def __init__(self, tu):
                 self.tu = tu
 
             def __len__(self):
                 return int(conf.lib.clang_getNumDiagnostics(self.tu))
 
             def __getitem__(self, key):
                 diag = conf.lib.clang_getDiagnostic(self.tu, key)
def register_functions(lib, ignore_errors):
     """
 
     def register(item):
         return register_function(lib, item, ignore_errors)
 
     for f in functionList:
         register(f)
 
-class Config:
+class Config(object):
     library_path = None
     library_file = None
     compatibility_check = True
     loaded = False
 
     @staticmethod
     def set_library_path(path):
         """Set the path in which to search for libclang"""

cfe/trunk/docs/tools/dump_format_style.py

 
 def indent(text, columns, indent_first_line=True):
   indent = ' ' * columns
   s = re.sub(r'\n([^\n])', '\n' + indent + '\\1', text, flags=re.S)
   if not indent_first_line or s.startswith('\n'):
     return s
   return indent + s
 
-class Option:
+class Option(object):
   def __init__(self, name, type, comment):
     self.name = name
     self.type = type
     self.comment = comment.strip()
     self.enum = None
     self.nested_struct = None
 
   def __str__(self):
     s = '**%s** (``%s``)\n%s' % (self.name, self.type,
                                  doxygen2rst(indent(self.comment, 2)))
     if self.enum:
       s += indent('\n\nPossible values:\n\n%s\n' % self.enum, 2)
     if self.nested_struct:
       s += indent('\n\nNested configuration flags:\n\n%s\n' %self.nested_struct,
                   2)
     return s
 
-class NestedStruct:
+class NestedStruct(object):
   def __init__(self, name, comment):
     self.name = name
     self.comment = comment.strip()
     self.values = []
 
   def __str__(self):
     return '\n'.join(map(str, self.values))
 
-class NestedField:
+class NestedField(object):
   def __init__(self, name, comment):
     self.name = name
     self.comment = comment.strip()
 
   def __str__(self):
     return '\n* ``%s`` %s' % (
         self.name,
         doxygen2rst(indent(self.comment, 2, indent_first_line=False)))
 
-class Enum:
+class Enum(object):
   def __init__(self, name, comment):
     self.name = name
     self.comment = comment.strip()
     self.values = []
 
   def __str__(self):
     return '\n'.join(map(str, self.values))
 
-class EnumValue:
+class EnumValue(object):
   def __init__(self, name, comment):
     self.name = name
     self.comment = comment
 
   def __str__(self):
     return '* ``%s`` (in configuration: ``%s``)\n%s' % (
         self.name,
         re.sub('.*_', '', self.name),
         doxygen2rst(indent(self.comment, 2)))
 
 def clean_comment_line(line):
   match = re.match(r'^/// \\code(\{.(\w+)\})?$', line)
   if match:
     lang = match.groups()[1]
     if not lang:
       lang = 'c++'
     return '\n.. code-block:: %s\n\n' % lang
   if line == '/// \\endcode':
     return ''
   return line[4:] + '\n'
 
 def read_options(header):
-  class State:
+  class State(object):
     BeforeStruct, Finished, InStruct, InNestedStruct, InNestedFieldComent, \
     InFieldComment, InEnum, InEnumMemberComment = range(8)
   state = State.BeforeStruct
 
   options = []
   enums = {}
   nested_structs = {}
   comment = ''

cfe/trunk/tools/scan-view/share/Reporter.py

 
 class ReportFailure(Exception):
     """Generic exception for failures in bug reporting."""
     def __init__(self, value):        
         self.value = value
 
 # Collect information about a bug.
 
-class BugReport:
+class BugReport(object):
     def __init__(self, title, description, files):
         self.title = title
         self.description = description
         self.files = files
 
 # Reporter interfaces.
 
 import os
 
 import email, mimetypes, smtplib
 from email import encoders
 from email.message import Message
 from email.mime.base import MIMEBase
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 
 #===------------------------------------------------------------------------===#
 # ReporterParameter
 #===------------------------------------------------------------------------===#
 
-class ReporterParameter:
+class ReporterParameter(object):
   def __init__(self, n):
     self.name = n
   def getName(self):
     return self.name
   def getValue(self,r,bugtype,getConfigOption):
      return getConfigOption(r.getName(),self.getName())
   def saveConfigValue(self):
     return True

 <option value="%s"%s>%s</option>"""%(o[0],
                                      o[0] == default and ' selected="selected"' or '',
                                      o[1]) for o in self.values]))
 
 #===------------------------------------------------------------------------===#
 # Reporters
 #===------------------------------------------------------------------------===#
 
-class EmailReporter:
+class EmailReporter(object):
     def getName(self):
         return 'Email'
 
     def getParameters(self):
         return map(lambda x:TextParameter(x),['To', 'From', 'SMTP Server', 'SMTP Port'])
 
     # Lifted from python email module examples.
     def attachFile(self, outer, path):
"""%(report.title, report.description)
                              port=parameters.get('SMTP Port'))
             s.sendmail(msg['From'], msg['To'], msg.as_string())
             s.close()
         except:
             raise ReportFailure('Unable to send message via SMTP.')
 
         return "Message sent!"
 
-class BugzillaReporter:
+class BugzillaReporter(object):
     def getName(self):
         return 'Bugzilla'
     
     def getParameters(self):
         return map(lambda x:TextParameter(x),['URL','Product'])
 
     def fileReport(self, report, parameters):
         raise NotImplementedError
if bugtype.find("leak") != -1:
       return '3'
     elif bugtype.find("dereference") != -1:
       return '2'
     elif bugtype.find("missing ivar release") != -1:
       return '3'
     else:
       return '7'
 
-class RadarReporter:
+class RadarReporter(object):
     @staticmethod
     def isAvailable():
         # FIXME: Find this .scpt better
         path = os.path.join(os.path.dirname(__file__),'../share/scan-view/GetRadarVersion.scpt')
         try:
           p = subprocess.Popen(['osascript',path], 
           stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         except:

cfe/trunk/tools/scan-view/share/ScanView.py

def send_open_report(self, report):
         if status:
             res = 'Opened: "%s"' % file
         else:
             res = 'Open failed: "%s"' % file
 
         return self.send_string(res, 'text/plain')
 
     def get_report_context(self, report):
-        class Context:
+        class Context(object):
             pass
         if report is None or report == 'None':
             data = self.load_crashes()
             # Don't allow empty reports.
             if not data:
                 raise ValueError('No crashes detected!')
             c = Context()
             c.title = 'clang static analyzer failures'

cfe/trunk/utils/ABITest/ABITestGen.py

 #!/usr/bin/env python
 
 from pprint import pprint
 import random, atexit, time
 from random import randrange
 import re
 
 from Enumeration import *
 from TypeGen import *
 
 ####
 
-class TypePrinter:
+class TypePrinter(object):
     def __init__(self, output, outputHeader=None, 
                  outputTests=None, outputDriver=None,
                  headerName=None, info=None):
         self.output = output
         self.outputHeader = outputHeader
         self.outputTests = outputTests
         self.outputDriver = outputDriver
         self.writeBody = outputHeader or outputTests or outputDriver

cfe/trunk/utils/ABITest/TypeGen.py

 #  - block types
 #  - K&R functions
 #  - pass arguments of different types (test extension, transparent union)
 #  - varargs
 
 ###
 # Actual type types
 
-class Type:
+class Type(object):
     def isBitField(self):
         return False
 
     def isPaddingBitField(self):
         return False
 
     def getTypeName(self, printer):
         name = 'T%d' % len(printer.types)

cfe/trunk/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:
+class Colors(object):
     """
     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:
+class SingleRunInfo(object):
     def __init__(self, path, root="", verboseLog=None):
         self.path = path
         self.root = root.rstrip("/\\")
         self.verboseLog = verboseLog
 
 
-class AnalysisDiagnostic:
+class AnalysisDiagnostic(object):
     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):
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:
+class AnalysisReport(object):
     def __init__(self, run, files):
         self.run = run
         self.files = files
         self.diagnostics = []
 
 
-class AnalysisRun:
+class AnalysisRun(object):
     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

cfe/trunk/utils/modfuzz.py

 #! /usr/bin/env python
 
 # To use:
 #  1) Update the 'decls' list below with your fuzzing configuration.
 #  2) Run with the clang binary as the command-line argument.
 
 import random
 import subprocess
 import sys
 import os
 
 clang = sys.argv[1]
 none_opts = 0.3
 
-class Decl:
+class Decl(object):
   def __init__(self, text, depends=[], provides=[], conflicts=[]):
     self.text = text
     self.depends = depends
     self.provides = provides
     self.conflicts = conflicts
 
   def valid(self, model):
     for i in self.depends:
def apply(self, model, name):
     model.source += self.text % {'name': name}
 
 decls = [
   Decl('struct X { int n; };\n', provides=['X'], conflicts=['X']),
   Decl('static_assert(X{.n=1}.n == 1, "");\n', depends=['X']),
   Decl('X %(name)s;\n', depends=['X']),
 ]
 
-class FS:
+class FS(object):
   def __init__(self):
     self.fs = {}
     self.prevfs = {}
 
   def write(self, path, contents):
     self.fs[path] = contents
 
   def done(self):
     for f, s in self.fs.items():
       if self.prevfs.get(f) != s:
         f = file(f, 'w')
         f.write(s)
         f.close()
 
     for f in self.prevfs:
       if f not in self.fs:
         os.remove(f)
 
     self.prevfs, self.fs = self.fs, {}
 
 fs = FS()
 
-class CodeModel:
+class CodeModel(object):
   def __init__(self):
     self.source = ''
     self.modules = {}
     self.decls = {}
     self.i = 0
 
   def make_name(self):
     self.i += 1

cfe/trunk/utils/token-delta.py

def search(self, c, sets):
             # pases without this subset.
             if len(sets) > 2:
                 complement = sum(sets[:i] + sets[i+1:],[])
                 if self.getTestResult(complement):
                     return self.delta(complement, sets[:i] + sets[i+1:])
 
 ###
 
-class Token:
+class Token(object):
     def __init__(self, type, data, flags, file, line, column):
         self.type   = type
         self.data   = data
         self.flags  = flags
         self.file   = file
         self.line   = line
         self.column = column