round-trip-syntax-test

#!/usr/bin/env python3

importargparse
importdifflib
importlogging
importos
importsubprocess
importsys
importtempfile
fromfunctoolsimportreduce

logging.basicConfig(format='%(message)s', level=logging.INFO)


classRoundTripTask(object):
def__init__(self, input_filename, action, swift_syntax_test,
skip_bad_syntax):
assertaction=='-round-trip-parse'oraction=='-round-trip-lex'
ifsys.version_info[0] <3:
assertisinstance(input_filename, str)
assertisinstance(swift_syntax_test, str)

assertos.path.isfile(input_filename), \
"Input file {} is not accessible!".format(input_filename)
assertos.path.isfile(swift_syntax_test), \
"{} tool is not accessible!".format(swift_syntax_test)
self.input_filename=input_filename
self.action=action
self.swift_syntax_test=swift_syntax_test
self.skip_bad_syntax=skip_bad_syntax
self.returncode=None
self.stdout=None
self.stderr=None

@property
deftest_command(self):
return [self.swift_syntax_test, self.action,
'-input-source-filename', self.input_filename]

defrun(self):
command=self.test_command
logging.debug(' '.join(command))
self.output_file=tempfile.NamedTemporaryFile('w', delete=False)
self.stderr_file=tempfile.NamedTemporaryFile('w', delete=False)

process=subprocess.Popen(command, stdout=self.output_file,
stderr=self.stderr_file)
process.wait()
self.returncode=process.returncode

self.output_file.close()
self.stderr_file.close()

withopen(self.output_file.name, 'rb') asstdout_in:
self.stdout=stdout_in.read()
withopen(self.stderr_file.name, 'rb') asstderr_in:
self.stderr=stderr_in.read()

os.remove(self.output_file.name)
os.remove(self.stderr_file.name)

ifself.returncode!=0:
ifself.skip_bad_syntax:
logging.warning('---===WARNING===--- Lex/parse had error'
' diagnostics, so not diffing. Skipping'
' this file due to -skip-bad-syntax.')
logging.error(' '.join(command))
returnNone
else:
logging.error('---===ERROR===--- Lex/parse had error'
' diagnostics, so not diffing.')
logging.error(' '.join(command))
logging.error(self.stdout.decode('utf-8', errors='replace'))
logging.error(self.stderr.decode('utf-8', errors='replace'))
raiseRuntimeError()

contents=''.join(map(lambda_: _.decode('utf-8', errors='replace'),
open(self.input_filename, 'rb').readlines()))
stdout_contents=self.stdout.decode('utf-8', errors='replace')

ifcontents==stdout_contents:
returnNone

lines=difflib.unified_diff(contents, stdout_contents,
fromfile=self.input_filename,
tofile='-')
diff='\n'.join(lineforlineinlines)
returndiffifdiffelseNone


defswift_files_in_dir(d):
swift_files= []
forroot, dirs, filesinos.walk(d):
forbasenameinfiles:
ifnotbasename.endswith('.swift'):
continue
abs_file=os.path.abspath(os.path.join(root, basename))
swift_files.append(abs_file)
returnswift_files


defrun_task(task):
try:
diff=task.run()
ifdiffisnotNone:
logging.error('---===ERROR===--- Diff failed!')
logging.error(' '.join(task.test_command))
logging.error(diff)
logging.error('')
returnTrue
exceptRuntimeErrorase:
logging.error(e.message)
returnTrue
returnFalse


defmain():
tool_description='''
Checks for round-trip lex/parse/print compatibility.

Swift's syntax representation should be "full-fidelity", meaning that there is
a perfect representation of what is in the source. When printing a syntax tree
to a file, that file should be identical to the file that was
originally parsed.

This driver invokes swift-syntax-test using -round-trip-lex and
-round-trip-parse on .swift files and .swift files in directories.
'''
parser=argparse.ArgumentParser(description=tool_description)
parser.add_argument('--directory', '-d', action='append',
dest='input_directories', default=[],
help='Add a directory, searching for .swift files'
' within')
parser.add_argument('--file', '-f', action='append',
dest='individual_input_files', default=[],
help='Add an individual file to test')
parser.add_argument('--swift-syntax-test', '-t', required=True,
dest='tool_path',
help='Absolute path to the swift-syntax-test tool')
parser.add_argument('--skip-bad-syntax',
action='store_true',
default=False,
help="Skip files that caused lex or parse diagnostics"
" to be emitted")

args=parser.parse_args()

dir_listings= [swift_files_in_dir(d) fordinargs.input_directories]
all_input_files= [filenamefordir_listingindir_listings
forfilenameindir_listing]
all_input_files+=args.individual_input_files
ifsys.version_info[0] <3:
all_input_files= [f.decode('utf-8') forfinall_input_files]

iflen(all_input_files) ==0:
logging.error('No input files!')
sys.exit(1)

ifnotos.path.isfile(args.tool_path):
raiseRuntimeError("Couldn't find swift-syntax-test at {}"
 .format(args.tool_path))

lex_tasks= [RoundTripTask(filename, '-round-trip-lex', args.tool_path,
args.skip_bad_syntax)
forfilenameinall_input_files]
parse_tasks= [RoundTripTask(filename, '-round-trip-parse', args.tool_path,
args.skip_bad_syntax)
forfilenameinall_input_files]

failed=reduce(lambdaa, b: aorb,
map(run_task, lex_tasks+parse_tasks))
sys.exit(1iffailedelse0)


if__name__=='__main__':
main()