swift-api-checker.py

#!/usr/bin/env python3

importargparse
importos
importsubprocess
importsys
importtempfile

INFER_IMPORT_DIR= \
os.path.dirname(os.path.realpath(__file__)) +'/sdk-module-lists'

INFER_IMPORT_PATH=INFER_IMPORT_DIR+'/infer-imports.py'


defprinterr(message):
print(message, file=sys.stderr)


deffatal_error(message):
printerr(message)
sys.exit(1)


defescapeCmdArg(arg):
if'"'inargor' 'inarg:
return'"%s"'%arg.replace('"', '\\"')
else:
returnarg


defcheck_call(cmd, cwd=None, env=os.environ, verbose=False, output=None):
ifverbose:
print(' '.join([escapeCmdArg(arg) forargincmd]))
try:
subprocess.check_call(cmd, cwd=cwd, env=env,
stderr=None, stdout=output)
return0
exceptExceptionaserror:
printerr(error)
return1


defcheck_output(cmd, verbose=False):
ifverbose:
print(' '.join([escapeCmdArg(arg) forargincmd]))
returnsubprocess.check_output(cmd).strip()


defget_sdk_path(platform):
ifplatform.startswith('iosmac'):
platform='macosx'
returncheck_output(['xcrun', '-sdk', platform, '-show-sdk-path'])


defwrite_fixed_module(file, platform, infix, verbose):
common_modules_path=os.path.join(INFER_IMPORT_DIR, 'fixed-'+infix+
'-modules-common.txt')
platform_modules_path=os.path.join(INFER_IMPORT_DIR, 'fixed-'+infix+
'-modules-'+platform+'.txt')
withopen(common_modules_path, 'r') asextra:
ifverbose:
print('Including modules in: '+common_modules_path)
file.write(extra.read())
withopen(platform_modules_path, 'r') asextra:
ifverbose:
print('Including modules in: '+platform_modules_path)
file.write(extra.read())


defprepare_module_list(platform, file, verbose, module_filter_flags,
include_fixed_clang_modules):
cmd= [INFER_IMPORT_PATH, '-s', get_sdk_path(platform)]
cmd.extend(module_filter_flags)
ifplatform.startswith('iosmac'):
cmd.extend(['--catalyst'])
ifverbose:
cmd.extend(['--v'])
check_call(cmd, verbose=verbose, output=file)
# Always include fixed swift modules
write_fixed_module(file, platform, 'swift', verbose)
# Check if we need fixed clang modules
ifinclude_fixed_clang_modules:
write_fixed_module(file, platform, 'clang', verbose)


defget_api_digester_path(tool_path):
iftool_path:
returntool_path
returncheck_output(['xcrun', '--find', 'swift-api-digester'])


defcreate_directory(path):
ifnotos.path.isdir(path):
os.makedirs(path)


classDumpConfig:
def__init__(self, tool_path, platform, platform_alias, abi, verbose):
target_map= {
'iphoneos': 'arm64-apple-ios13.0',
'macosx': 'x86_64-apple-macosx10.15',
'appletvos': 'arm64-apple-tvos13.0',
'watchos': 'armv7k-apple-watchos6.0',
'iosmac': 'x86_64-apple-ios13.1-macabi',
 }
self.tool_path=get_api_digester_path(tool_path)
self.platform=platform
self.target=target_map[platform]
self.sdk=get_sdk_path(platform)
self.inputs= []
self.platform_alias=platform_alias
self.abi=abi
ifself.platform=='macosx':
# We need this input search path for CreateML
self.inputs.extend([self.sdk+'/usr/lib/swift/'])
# This is where XCTest is
self.frameworks= [self.sdk+'/../../Library/Frameworks/']
ifself.platform.startswith('iosmac'):
# Catalyst modules need this extra framework dir
iOSSupport=self.sdk+ \
'/System/iOSSupport/System/Library/Frameworks'
self.frameworks.extend([iOSSupport])
self._environ=dict(os.environ)
self._environ['SWIFT_FORCE_MODULE_LOADING'] ='prefer-interface'
self.verbose=verbose

defdumpZipperedContent(self, cmd, output, module):
dir_path=os.path.realpath(output+'/'+module)
ifself.abi:
dir_path=os.path.join(dir_path, 'ABI')
else:
dir_path=os.path.join(dir_path, 'API')
file_path=os.path.realpath(dir_path+'/'+self.platform_alias+
'.json')
create_directory(dir_path)
current_cmd=list(cmd)
current_cmd.extend(['-module', module])
current_cmd.extend(['-o', file_path])
check_call(current_cmd, env=self._environ, verbose=self.verbose)

defrun(self, output, module, swift_ver, opts,
module_filter_flags, include_fixed_clang_modules,
separate_by_module, zippered):
cmd= [self.tool_path, '-sdk', self.sdk, '-target',
self.target, '-dump-sdk', '-module-cache-path',
'/tmp/ModuleCache', '-swift-version',
swift_ver, '-abort-on-module-fail']
forpathinself.frameworks:
cmd.extend(['-iframework', path])
forpathinself.inputs:
cmd.extend(['-I', path])
ifself.abi:
cmd.extend(['-abi', '-swift-only'])
cmd.extend(['-'+oforoinopts])
ifself.verbose:
cmd.extend(['-v'])
ifmodule:
ifzippered:
create_directory(output)
self.dumpZipperedContent(cmd, output, module)
else:
cmd.extend(['-module', module])
cmd.extend(['-o', output])
check_call(cmd, env=self._environ, verbose=self.verbose)
else:
withtempfile.NamedTemporaryFile() astmp:
prepare_module_list(self.platform, tmp, self.verbose,
module_filter_flags,
include_fixed_clang_modules)
ifseparate_by_module:
tmp.seek(0)
create_directory(output)
formodulein [name.strip() fornameintmp.readlines()]:
# Skip comments
ifmodule.startswith('//'):
continue
self.dumpZipperedContent(cmd, output, module)
else:
cmd.extend(['-o', output])
cmd.extend(['-module-list-file', tmp.name])
check_call(cmd, env=self._environ, verbose=self.verbose)


classDiagnoseConfig:
def__init__(self, tool_path, abi):
self.tool_path=get_api_digester_path(tool_path)
self.abi=abi

defrun(self, opts, before, after, output, verbose):
cmd= [self.tool_path, '-diagnose-sdk', '-input-paths', before,
'-input-paths', after, '-print-module']
ifoutput:
cmd.extend(['-o', output])
ifself.abi:
cmd.extend(['-abi'])
cmd.extend(['-'+oforoinopts])
ifverbose:
cmd.extend(['-v'])
check_call(cmd, verbose=verbose)


defmain():
parser=argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description='''
A convenient wrapper for swift-api-digester.
''')

basic_group=parser.add_argument_group('Basic')

basic_group.add_argument('--tool-path', default=None, help='''
 the path to a swift-api-digester; if not specified, the script will
 use the one from the toolchain
 ''')

basic_group.add_argument('--action', default='', help='''
 the action to perform for swift-api-digester
 ''')

basic_group.add_argument('--target', default=None, help='''
 one of macosx, iphoneos, appletvos, and watchos
 ''')

basic_group.add_argument('--output', default=None, help='''
 the output file of the module baseline should end with .json
 ''')

basic_group.add_argument('--swift-version', default='5', help='''
 Swift version to use; default is 5
 ''')

basic_group.add_argument('--module', default=None, help='''
 name of the module/framework to generate baseline, e.g. Foundation
 ''')

basic_group.add_argument('--module-filter', default='', help='''
 the action to perform for swift-api-digester
 ''')

basic_group.add_argument('--opts', nargs='+', default=[], help='''
 additional flags to pass to swift-api-digester
 ''')

basic_group.add_argument('--v',
action='store_true',
help='Process verbosely')

basic_group.add_argument('--dump-before',
action=None,
help='''
 Path to the json file generated before change'
 ''')

basic_group.add_argument('--dump-after',
action=None,
help='''
 Path to the json file generated after change
 ''')

basic_group.add_argument('--separate-by-module',
action='store_true',
help='When importing entire SDK, dump content '
'separately by module names')

basic_group.add_argument('--zippered',
action='store_true',
help='dump module content to a dir with files for'
'separately targets')

basic_group.add_argument('--abi',
action='store_true',
help='Process verbosely')

basic_group.add_argument('--platform-alias', default='', help='''
 Specify a file name to use if using a platform name in json file isn't
 optimal
 ''')

args=parser.parse_args(sys.argv[1:])

ifargs.action=='dump':
ifnotargs.target:
fatal_error("Need to specify --target")
ifnotargs.output:
fatal_error("Need to specify --output")
ifargs.module_filter=='':
module_filter_flags= []
include_fixed_clang_modules=True
elifargs.module_filter=='swift-frameworks-only':
module_filter_flags= ['--swift-frameworks-only']
include_fixed_clang_modules=False
elifargs.module_filter=='swift-overlay-only':
module_filter_flags= ['--swift-overlay-only']
include_fixed_clang_modules=False
else:
fatal_error("cannot recognize --module-filter")
ifargs.platform_alias=='':
args.platform_alias=args.target
runner=DumpConfig(tool_path=args.tool_path, platform=args.target,
platform_alias=args.platform_alias,
abi=args.abi,
verbose=args.v)
runner.run(output=args.output, module=args.module,
swift_ver=args.swift_version, opts=args.opts,
module_filter_flags=module_filter_flags,
include_fixed_clang_modules=include_fixed_clang_modules,
separate_by_module=args.separate_by_module,
zippered=args.zippered)
elifargs.action=='diagnose':
ifnotargs.dump_before:
fatal_error("Need to specify --dump-before")
ifnotargs.dump_after:
fatal_error("Need to specify --dump-after")
runner=DiagnoseConfig(tool_path=args.tool_path, abi=args.abi)
runner.run(opts=args.opts, before=args.dump_before,
after=args.dump_after, output=args.output, verbose=args.v)
else:
fatal_error('Cannot recognize action: '+args.action)


if__name__=='__main__':
main()