mirror of
https://github.com/facebook/sapling.git
synced 2024-10-09 16:31:02 +03:00
2125e5d7d4
The most painful part of ensuring Python code runs on both Python 2 and 3 is string encoding. Making this difficult is that string literals in Python 2 are bytes and string literals in Python 3 are unicode. So, to ensure consistent types are used, you have to use "from __future__ import unicode_literals" and/or prefix literals with their type (e.g. b'foo' or u'foo'). Nearly every string in Mercurial is bytes. So, to use the same source code on both Python 2 and 3 would require prefixing nearly every string literal with "b" to make it a byte literal. This is ugly and not something mpm is willing to do at this point in time. This patch implements a custom module loader on Python 3 that performs source transformation to convert string literals (unicode in Python 3) to byte literals. In effect, it changes Python 3's string literals to behave like Python 2's. In addition, the module loader recognizes well-known built-in functions (getattr, setattr, hasattr) and methods (encode and decode) that barf when bytes are used and prevents these from being rewritten. This prevents excessive source changes to accommodate this change (we would have to rewrite every occurrence of these functions passing string literals otherwise). The module loader is only used on Python packages belonging to Mercurial. The loader works by tokenizing the loaded source and replacing "string" tokens if necessary. The modified token stream is untokenized back to source and loaded like normal. This does add some overhead. However, this all occurs before caching: .pyc files will cache the transformed version. This means the transformation penalty is only paid on first load. As the extensive inline comments explain, the presence of a custom source transformer invalidates assumptions made by Python's built-in bytecode caching mechanism. So, we have to wrap bytecode loading and writing and add an additional header to bytecode files to facilitate additional cache validation when the source transformations change in the future. There are still a few things this code doesn't handle well, namely support for zip files as module sources and for extensions. Since Mercurial doesn't officially support Python 3 yet, I'm inclined to leave these as to-do items: getting a basic module loading mechanism in place to unblock further Python 3 porting effort is more important than comprehensive module importing support. check-py3-compat.py has been updated to ignore frames. This is necessary because CPython has built-in code to strip frames from the built-in importer. When our custom code is present, this doesn't work and the frames get all messed up. The new code is not perfect. It works for now. But once you start chasing import failures you find some edge cases where the files aren't being printed properly. This only burdens people doing future Python 3 porting work so I'm inclined to punt on the issue: the most important thing is for the source transforming module loader to land. There was a bit of churn in test-check-py3-compat.t because we now trip up on str/unicode/bytes failures as a result of source transformation. This is unfortunate but what are you going to do. It's worth noting that other approaches were investigated. We considered using a custom file encoding whose decode() would apply source transformations. This was rejected because it would require each source file to declare its custom Mercurial encoding. Furthermore, when changing the source transformation we'd need to version bump the encoding name otherwise the module caching layer wouldn't know the .pyc file was invalidated. This would mean mass updating every file when the source transformation changes. Yuck. We also considered transforming at the AST layer. However, Python's ast module is quite gnarly and doing AST transforms is quite complicated, even for trivial rewrites. There are whole Python packages that exist to make AST transformations usable. AST transforms would still require import machinery, so the choice was basically to perform source-level, token-level, or ast-level transforms. Token-level rewriting delivers the metadata we need to rewrite intelligently while being relatively easy to understand. So it won. General consensus seems to be that this approach is the best available to avoid bulk rewriting of '' to b''. However, we aren't confident that this approach will never be a future maintenance burden. This approach does unblock serious Python 3 porting efforts. So we can re-evaulate once more work is done to support Python 3.
97 lines
3.3 KiB
Python
Executable File
97 lines
3.3 KiB
Python
Executable File
#!/usr/bin/env python
|
|
#
|
|
# check-py3-compat - check Python 3 compatibility of Mercurial files
|
|
#
|
|
# Copyright 2015 Gregory Szorc <gregory.szorc@gmail.com>
|
|
#
|
|
# This software may be used and distributed according to the terms of the
|
|
# GNU General Public License version 2 or any later version.
|
|
|
|
from __future__ import absolute_import, print_function
|
|
|
|
import ast
|
|
import imp
|
|
import os
|
|
import sys
|
|
import traceback
|
|
|
|
def check_compat_py2(f):
|
|
"""Check Python 3 compatibility for a file with Python 2"""
|
|
with open(f, 'rb') as fh:
|
|
content = fh.read()
|
|
root = ast.parse(content)
|
|
|
|
# Ignore empty files.
|
|
if not root.body:
|
|
return
|
|
|
|
futures = set()
|
|
haveprint = False
|
|
for node in ast.walk(root):
|
|
if isinstance(node, ast.ImportFrom):
|
|
if node.module == '__future__':
|
|
futures |= set(n.name for n in node.names)
|
|
elif isinstance(node, ast.Print):
|
|
haveprint = True
|
|
|
|
if 'absolute_import' not in futures:
|
|
print('%s not using absolute_import' % f)
|
|
if haveprint and 'print_function' not in futures:
|
|
print('%s requires print_function' % f)
|
|
|
|
def check_compat_py3(f):
|
|
"""Check Python 3 compatibility of a file with Python 3."""
|
|
with open(f, 'rb') as fh:
|
|
content = fh.read()
|
|
|
|
try:
|
|
ast.parse(content)
|
|
except SyntaxError as e:
|
|
print('%s: invalid syntax: %s' % (f, e))
|
|
return
|
|
|
|
# Try to import the module.
|
|
# For now we only support mercurial.* and hgext.* modules because figuring
|
|
# out module paths for things not in a package can be confusing.
|
|
if f.startswith(('hgext/', 'mercurial/')) and not f.endswith('__init__.py'):
|
|
assert f.endswith('.py')
|
|
name = f.replace('/', '.')[:-3]
|
|
with open(f, 'r') as fh:
|
|
try:
|
|
imp.load_module(name, fh, '', ('py', 'r', imp.PY_SOURCE))
|
|
except Exception as e:
|
|
exc_type, exc_value, tb = sys.exc_info()
|
|
# We walk the stack and ignore frames from our custom importer,
|
|
# import mechanisms, and stdlib modules. This kinda/sorta
|
|
# emulates CPython behavior in import.c while also attempting
|
|
# to pin blame on a Mercurial file.
|
|
for frame in reversed(traceback.extract_tb(tb)):
|
|
if frame.name == '_call_with_frames_removed':
|
|
continue
|
|
if 'importlib' in frame.filename:
|
|
continue
|
|
if 'mercurial/__init__.py' in frame.filename:
|
|
continue
|
|
if frame.filename.startswith(sys.prefix):
|
|
continue
|
|
break
|
|
|
|
if frame.filename:
|
|
filename = os.path.basename(frame.filename)
|
|
print('%s: error importing: <%s> %s (error at %s:%d)' % (
|
|
f, type(e).__name__, e, filename, frame.lineno))
|
|
else:
|
|
print('%s: error importing module: <%s> %s (line %d)' % (
|
|
f, type(e).__name__, e, frame.lineno))
|
|
|
|
if __name__ == '__main__':
|
|
if sys.version_info[0] == 2:
|
|
fn = check_compat_py2
|
|
else:
|
|
fn = check_compat_py3
|
|
|
|
for f in sys.argv[1:]:
|
|
fn(f)
|
|
|
|
sys.exit(0)
|