Revert "[mypyc] Add LoadLiteral and use tables to construct and store literals (#10040)" This reverts commit 7ec1455821373ee394afc824f18c53bff1b6923b.
diff --git a/mypyc/analysis/dataflow.py b/mypyc/analysis/dataflow.py index 17f6d33..d130e48 100644 --- a/mypyc/analysis/dataflow.py +++ b/mypyc/analysis/dataflow.py
@@ -7,7 +7,7 @@ from mypyc.ir.ops import ( Value, ControlOp, BasicBlock, OpVisitor, Assign, Integer, LoadErrorValue, RegisterOp, Goto, Branch, Return, Call, - Box, Unbox, Cast, Op, Unreachable, TupleGet, TupleSet, GetAttr, SetAttr, LoadLiteral, + Box, Unbox, Cast, Op, Unreachable, TupleGet, TupleSet, GetAttr, SetAttr, LoadStatic, InitStatic, MethodCall, RaiseStandardError, CallC, LoadGlobal, Truncate, IntOp, LoadMem, GetElementPtr, LoadAddress, ComparisonOp, SetMem ) @@ -165,9 +165,6 @@ def visit_load_error_value(self, op: LoadErrorValue) -> GenAndKill: return self.visit_register_op(op) - def visit_load_literal(self, op: LoadLiteral) -> GenAndKill: - return self.visit_register_op(op) - def visit_get_attr(self, op: GetAttr) -> GenAndKill: return self.visit_register_op(op)
diff --git a/mypyc/codegen/cstring.py b/mypyc/codegen/cstring.py index 15c8538..4fdb279 100644 --- a/mypyc/codegen/cstring.py +++ b/mypyc/codegen/cstring.py
@@ -18,13 +18,10 @@ octal digits. """ -from typing import List import string +from typing import Tuple -from typing_extensions import Final - - -CHAR_MAP = ['\\{:03o}'.format(i) for i in range(256)] # type: Final +CHAR_MAP = ['\\{:03o}'.format(i) for i in range(256)] # It is safe to use string.printable as it always uses the C locale. for c in string.printable: @@ -41,33 +38,12 @@ CHAR_MAP[ord('?')] = r'\?' -def encode_bytes_as_c_string(b: bytes) -> str: - """Produce contents of a C string literal for a byte string, without quotes.""" +def encode_as_c_string(s: str) -> Tuple[str, int]: + """Produce a quoted C string literal and its size, for a UTF-8 string.""" + return encode_bytes_as_c_string(s.encode('utf-8')) + + +def encode_bytes_as_c_string(b: bytes) -> Tuple[str, int]: + """Produce a quoted C string literal and its size, for a byte string.""" escaped = ''.join([CHAR_MAP[i] for i in b]) - return escaped - - -def c_string_initializer(components: List[bytes]) -> str: - """Create initializer for a C char[] variable from a list of fragments. - - For example, if components is [b'foo', b'bar'], the result would be - '"foobar"', which could then be used like this to initialize 's': - - const char s[] = "foobar"; - - If the result is long, split it into multiple lines. - """ - res = [] - current = '' - for c in components: - enc = encode_bytes_as_c_string(c) - if not current or len(current) + len(enc) < 70: - current += enc - else: - res.append('"%s"' % current) - current = enc - if current: - res.append('"%s"' % current) - if len(res) > 1: - res.insert(0, '') - return '\n '.join(res) + return '"{}"'.format(escaped), len(b)
diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py index 82d17c6..6199262 100644 --- a/mypyc/codegen/emit.py +++ b/mypyc/codegen/emit.py
@@ -20,7 +20,6 @@ from mypyc.ir.class_ir import ClassIR, all_concrete_classes from mypyc.namegen import NameGenerator, exported_name from mypyc.sametype import is_same_type -from mypyc.codegen.literals import Literals class HeaderDeclaration: @@ -85,8 +84,6 @@ # The declaration contains the body of the struct. self.declarations = OrderedDict() # type: Dict[str, HeaderDeclaration] - self.literals = Literals() - class Emitter: """Helper for C code generation."""
diff --git a/mypyc/codegen/emitfunc.py b/mypyc/codegen/emitfunc.py index 538a672..c8b6334 100644 --- a/mypyc/codegen/emitfunc.py +++ b/mypyc/codegen/emitfunc.py
@@ -12,11 +12,11 @@ LoadStatic, InitStatic, TupleGet, TupleSet, Call, IncRef, DecRef, Box, Cast, Unbox, BasicBlock, Value, MethodCall, Unreachable, NAMESPACE_STATIC, NAMESPACE_TYPE, NAMESPACE_MODULE, RaiseStandardError, CallC, LoadGlobal, Truncate, IntOp, LoadMem, GetElementPtr, - LoadAddress, ComparisonOp, SetMem, Register, LoadLiteral + LoadAddress, ComparisonOp, SetMem, Register ) from mypyc.ir.rtypes import ( RType, RTuple, is_tagged, is_int32_rprimitive, is_int64_rprimitive, RStruct, - is_pointer_rprimitive, is_int_rprimitive + is_pointer_rprimitive ) from mypyc.ir.func_ir import FuncIR, FuncDecl, FUNC_STATICMETHOD, FUNC_CLASSMETHOD, all_values from mypyc.ir.class_ir import ClassIR @@ -96,7 +96,6 @@ self.declarations = declarations self.source_path = source_path self.module_name = module_name - self.literals = emitter.context.literals def temp_name(self) -> str: return self.emitter.temp_name() @@ -174,19 +173,6 @@ self.emit_line('%s = %s;' % (self.reg(op), self.c_error_value(op.type))) - def visit_load_literal(self, op: LoadLiteral) -> None: - index = self.literals.literal_index(op.value) - s = repr(op.value) - if not any(x in s for x in ('/*', '*/', '\0')): - ann = ' /* %s */' % s - else: - ann = '' - if not is_int_rprimitive(op.type): - self.emit_line('%s = CPyStatics[%d];%s' % (self.reg(op), index, ann)) - else: - self.emit_line('%s = (CPyTagged)CPyStatics[%d] | 1;%s' % ( - self.reg(op), index, ann)) - def get_attr_expr(self, obj: str, op: Union[GetAttr, SetAttr], decl_cl: ClassIR) -> str: """Generate attribute accessor for normal (non-property) access.
diff --git a/mypyc/codegen/emitmodule.py b/mypyc/codegen/emitmodule.py index 9f149e7..48ae169 100644 --- a/mypyc/codegen/emitmodule.py +++ b/mypyc/codegen/emitmodule.py
@@ -23,11 +23,10 @@ from mypyc.irbuild.prepare import load_type_map from mypyc.irbuild.mapper import Mapper from mypyc.common import ( - PREFIX, TOP_LEVEL_NAME, MODULE_PREFIX, RUNTIME_C_FILES, USE_FASTCALL, + PREFIX, TOP_LEVEL_NAME, INT_PREFIX, MODULE_PREFIX, RUNTIME_C_FILES, USE_FASTCALL, USE_VECTORCALL, shared_lib_name, ) -from mypyc.codegen.cstring import c_string_initializer -from mypyc.codegen.literals import Literals +from mypyc.codegen.cstring import encode_as_c_string, encode_bytes_as_c_string from mypyc.codegen.emit import EmitterContext, Emitter, HeaderDeclaration from mypyc.codegen.emitfunc import generate_native_function, native_function_header from mypyc.codegen.emitclass import generate_class_type_decl, generate_class @@ -35,7 +34,7 @@ generate_wrapper_function, wrapper_function_header, generate_legacy_wrapper_function, legacy_wrapper_function_header, ) -from mypyc.ir.ops import DeserMaps, LoadLiteral +from mypyc.ir.ops import LiteralsMap, DeserMaps from mypyc.ir.rtypes import RType, RTuple from mypyc.ir.func_ir import FuncIR from mypyc.ir.class_ir import ClassIR @@ -287,8 +286,9 @@ if not group_modules: ctext[group_name] = [] continue + literals = mapper.literals[group_name] generator = GroupGenerator( - group_modules, source_paths, + literals, group_modules, source_paths, group_name, mapper.group_map, names, compiler_options ) @@ -447,6 +447,7 @@ class GroupGenerator: def __init__(self, + literals: LiteralsMap, modules: List[Tuple[str, ModuleIR]], source_paths: Dict[str, str], group_name: Optional[str], @@ -460,6 +461,7 @@ one .c file per module if in multi_file mode.) Arguments: + literals: The literals declared in this group modules: (name, ir) pairs for each module in the group source_paths: Map from module names to source file paths group_name: The name of the group (or None if this is single-module compilation) @@ -468,6 +470,7 @@ multi_file: Whether to put each module in its own source file regardless of group structure. """ + self.literals = literals self.modules = modules self.source_paths = source_paths self.context = EmitterContext(names, group_name, group_map) @@ -492,11 +495,6 @@ file_contents = [] multi_file = self.use_shared_lib and self.multi_file - # Collect all literal refs in IR. - for _, module in self.modules: - for fn in module.functions: - collect_literals(fn, self.context.literals) - base_emitter = Emitter(self.context) # Optionally just include the runtime library c files to # reduce the number of compiler invocations needed @@ -507,7 +505,12 @@ base_emitter.emit_line('#include "__native_internal{}.h"'.format(self.short_group_suffix)) emitter = base_emitter - self.generate_literal_tables() + for (_, literal), identifier in self.literals.items(): + if isinstance(literal, int): + symbol = emitter.static_name(identifier, None) + self.declare_global('CPyTagged ', symbol) + else: + self.declare_static_pyobject(identifier, emitter) for module_name, module in self.modules: if multi_file: @@ -618,32 +621,6 @@ ''.join(ext_declarations.fragments)), ] - def generate_literal_tables(self) -> None: - """Generate tables containing descriptions of Python literals to construct. - - We will store the constructed literals in a single array that contains - literals of all types. This way we can refer to an arbitrary literal by - its index. - """ - literals = self.context.literals - # During module initialization we store all the constructed objects here - self.declare_global('PyObject *[%d]' % literals.num_literals(), 'CPyStatics') - # Descriptions of str literals - init_str = c_string_initializer(literals.encoded_str_values()) - self.declare_global('const char []', 'CPyLit_Str', initializer=init_str) - # Descriptions of bytes literals - init_bytes = c_string_initializer(literals.encoded_bytes_values()) - self.declare_global('const char []', 'CPyLit_Bytes', initializer=init_bytes) - # Descriptions of int literals - init_int = c_string_initializer(literals.encoded_int_values()) - self.declare_global('const char []', 'CPyLit_Int', initializer=init_int) - # Descriptions of float literals - init_floats = c_array_initializer(literals.encoded_float_values()) - self.declare_global('const double []', 'CPyLit_Float', initializer=init_floats) - # Descriptions of complex literals - init_complex = c_array_initializer(literals.encoded_complex_values()) - self.declare_global('const double []', 'CPyLit_Complex', initializer=init_complex) - def generate_export_table(self, decl_emitter: Emitter, code_emitter: Emitter) -> None: """Generate the declaration and definition of the group's export struct. @@ -816,10 +793,46 @@ for symbol, fixup in self.simple_inits: emitter.emit_line('{} = {};'.format(symbol, fixup)) - values = 'CPyLit_Str, CPyLit_Bytes, CPyLit_Int, CPyLit_Float, CPyLit_Complex' - emitter.emit_lines('if (CPyStatics_Initialize(CPyStatics, {}) < 0) {{'.format(values), - 'return -1;', - '}') + for (_, literal), identifier in self.literals.items(): + symbol = emitter.static_name(identifier, None) + if isinstance(literal, int): + actual_symbol = symbol + symbol = INT_PREFIX + symbol + emitter.emit_line( + 'PyObject * {} = PyLong_FromString(\"{}\", NULL, 10);'.format( + symbol, str(literal)) + ) + elif isinstance(literal, float): + emitter.emit_line( + '{} = PyFloat_FromDouble({});'.format(symbol, str(literal)) + ) + elif isinstance(literal, complex): + emitter.emit_line( + '{} = PyComplex_FromDoubles({}, {});'.format( + symbol, str(literal.real), str(literal.imag)) + ) + elif isinstance(literal, str): + emitter.emit_line( + '{} = PyUnicode_FromStringAndSize({}, {});'.format( + symbol, *encode_as_c_string(literal)) + ) + elif isinstance(literal, bytes): + emitter.emit_line( + '{} = PyBytes_FromStringAndSize({}, {});'.format( + symbol, *encode_bytes_as_c_string(literal)) + ) + else: + assert False, ('Literals must be integers, floating point numbers, or strings,', + 'but the provided literal is of type {}'.format(type(literal))) + emitter.emit_lines('if (unlikely({} == NULL))'.format(symbol), + ' return -1;') + # Ints have an unboxed representation. + if isinstance(literal, int): + emitter.emit_line( + '{} = CPyTagged_FromObject({});'.format(actual_symbol, symbol) + ) + elif isinstance(literal, str): + emitter.emit_line('PyUnicode_InternInPlace(&{});'.format(symbol)) emitter.emit_lines( 'is_initialized = 1;', @@ -961,19 +974,13 @@ def declare_global(self, type_spaced: str, name: str, *, initializer: Optional[str] = None) -> None: - if '[' not in type_spaced: - base = '{}{}'.format(type_spaced, name) - else: - a, b = type_spaced.split('[', 1) - base = '{}{}[{}'.format(a, name, b) - if not initializer: defn = None else: - defn = ['{} = {};'.format(base, initializer)] + defn = ['{}{} = {};'.format(type_spaced, name, initializer)] if name not in self.context.declarations: self.context.declarations[name] = HeaderDeclaration( - '{};'.format(base), + '{}{};'.format(type_spaced, name), defn=defn, ) @@ -1073,46 +1080,3 @@ # TODO: Support fastcall for __init__. return USE_FASTCALL and fn.name != '__init__' return USE_FASTCALL - - -def collect_literals(fn: FuncIR, literals: Literals) -> None: - """Store all Python literal object refs in fn. - - Collecting literals must happen only after we have the final IR. - This way we won't include literals that have been optimized away. - """ - for block in fn.blocks: - for op in block.ops: - if isinstance(op, LoadLiteral): - literals.record_literal(op.value) - - -def c_array_initializer(components: List[str]) -> str: - """Construct an initializer for a C array variable. - - Components are C expressions valid in an initializer. - - For example, if components are ["1", "2"], the result - would be "{1, 2}", which can be used like this: - - int a[] = {1, 2}; - - If the result is long, split it into multiple lines. - """ - res = [] - current = [] # type: List[str] - cur_len = 0 - for c in components: - if not current or cur_len + 2 + len(c) < 70: - current.append(c) - cur_len += len(c) + 2 - else: - res.append(', '.join(current)) - current = [c] - cur_len = len(c) - if not res: - # Result fits on a single line - return '{%s}' % ', '.join(current) - # Multi-line result - res.append(', '.join(current)) - return '{\n ' + ',\n '.join(res) + '\n}'
diff --git a/mypyc/codegen/literals.py b/mypyc/codegen/literals.py deleted file mode 100644 index a7b5967..0000000 --- a/mypyc/codegen/literals.py +++ /dev/null
@@ -1,190 +0,0 @@ -from typing import Dict, List, Union - - -class Literals: - """Collection of literal values used in a compilation group and related helpers.""" - - def __init__(self) -> None: - # Each dict maps value to literal index (0, 1, ...) - self.str_literals = {} # type: Dict[str, int] - self.bytes_literals = {} # type: Dict[bytes, int] - self.int_literals = {} # type: Dict[int, int] - self.float_literals = {} # type: Dict[float, int] - self.complex_literals = {} # type: Dict[complex, int] - - def record_literal(self, value: Union[str, bytes, int, float, complex]) -> None: - """Ensure that the literal value is available in generated code.""" - if isinstance(value, str): - str_literals = self.str_literals - if value not in str_literals: - str_literals[value] = len(str_literals) - elif isinstance(value, bytes): - bytes_literals = self.bytes_literals - if value not in bytes_literals: - bytes_literals[value] = len(bytes_literals) - elif isinstance(value, int): - int_literals = self.int_literals - if value not in int_literals: - int_literals[value] = len(int_literals) - elif isinstance(value, float): - float_literals = self.float_literals - if value not in float_literals: - float_literals[value] = len(float_literals) - elif isinstance(value, complex): - complex_literals = self.complex_literals - if value not in complex_literals: - complex_literals[value] = len(complex_literals) - else: - assert False, 'invalid literal: %r' % value - - def literal_index(self, value: Union[str, bytes, int, float, complex]) -> int: - """Return the index to the literals array for given value.""" - # The array contains first all str values, followed by bytes values, etc. - if isinstance(value, str): - return self.str_literals[value] - n = len(self.str_literals) - if isinstance(value, bytes): - return n + self.bytes_literals[value] - n += len(self.bytes_literals) - if isinstance(value, int): - return n + self.int_literals[value] - n += len(self.int_literals) - if isinstance(value, float): - return n + self.float_literals[value] - n += len(self.float_literals) - if isinstance(value, complex): - return n + self.complex_literals[value] - assert False, 'invalid literal: %r' % value - - def num_literals(self) -> int: - return (len(self.str_literals) + len(self.bytes_literals) + len(self.int_literals) + - len(self.float_literals) + len(self.complex_literals)) - - # The following methods return the C encodings of literal values - # of different types - - def encoded_str_values(self) -> List[bytes]: - return encode_str_values(self.str_literals) - - def encoded_int_values(self) -> List[bytes]: - return encode_int_values(self.int_literals) - - def encoded_bytes_values(self) -> List[bytes]: - return encode_bytes_values(self.bytes_literals) - - def encoded_float_values(self) -> List[str]: - return encode_float_values(self.float_literals) - - def encoded_complex_values(self) -> List[str]: - return encode_complex_values(self.complex_literals) - - -def encode_str_values(values: Dict[str, int]) -> List[bytes]: - value_by_index = {} - for value, index in values.items(): - value_by_index[index] = value - result = [] - num = len(values) - result.append(format_int(num)) - for i in range(num): - value = value_by_index[i] - c_literal = format_str_literal(value) - result.append(c_literal) - return result - - -def encode_bytes_values(values: Dict[bytes, int]) -> List[bytes]: - value_by_index = {} - for value, index in values.items(): - value_by_index[index] = value - result = [] - num = len(values) - result.append(format_int(num)) - for i in range(num): - value = value_by_index[i] - result.append(format_int(len(value))) - result.append(value) - return result - - -def format_int(n: int) -> bytes: - """Format an integer using a variable-length binary encoding.""" - if n < 128: - a = [n] - else: - a = [] - while n > 0: - a.insert(0, n & 0x7f) - n >>= 7 - for i in range(len(a) - 1): - # If the highest bit is set, more 7-bit digits follow - a[i] |= 0x80 - return bytes(a) - - -def format_str_literal(s: str) -> bytes: - utf8 = s.encode('utf-8') - return format_int(len(utf8)) + utf8 - - -def encode_int_values(values: Dict[int, int]) -> List[bytes]: - """Encode int values into C string fragments. - - Values are stored in base 10 and separated by 0 bytes. - """ - value_by_index = {} - for value, index in values.items(): - value_by_index[index] = value - result = [] - num = len(values) - result.append(format_int(num)) - for i in range(num): - value = value_by_index[i] - result.append(b'%d\0' % value) - return result - - -def float_to_c(x: float) -> str: - """Return C literal representation of a float value.""" - s = str(x) - if s == 'inf': - return 'INFINITY' - elif s == '-inf': - return '-INFINITY' - return s - - -def encode_float_values(values: Dict[float, int]) -> List[str]: - """Encode float values into a C array values. - - The result contains the number of values followed by individual values. - """ - value_by_index = {} - for value, index in values.items(): - value_by_index[index] = value - result = [] - num = len(values) - result.append(str(num)) - for i in range(num): - value = value_by_index[i] - result.append(float_to_c(value)) - return result - - -def encode_complex_values(values: Dict[complex, int]) -> List[str]: - """Encode float values into a C array values. - - The result contains the number of values followed by pairs of doubles - representing complex numbers. - """ - value_by_index = {} - for value, index in values.items(): - value_by_index[index] = value - result = [] - num = len(values) - result.append(str(num)) - for i in range(num): - value = value_by_index[i] - result.append(float_to_c(value.real)) - result.append(float_to_c(value.imag)) - return result
diff --git a/mypyc/common.py b/mypyc/common.py index fdb07f2..7c06372 100644 --- a/mypyc/common.py +++ b/mypyc/common.py
@@ -19,6 +19,7 @@ LAMBDA_NAME = '__mypyc_lambda__' # type: Final PROPSET_PREFIX = '__mypyc_setter__' # type: Final SELF_NAME = '__mypyc_self__' # type: Final +INT_PREFIX = '__tmp_literal_int_' # type: Final # Max short int we accept as a literal is based on 32-bit platforms, # so that we can just always emit the same code.
diff --git a/mypyc/ir/ops.py b/mypyc/ir/ops.py index 567ee59..107a2e5 100644 --- a/mypyc/ir/ops.py +++ b/mypyc/ir/ops.py
@@ -14,7 +14,7 @@ List, Sequence, Dict, Generic, TypeVar, Optional, NamedTuple, Tuple, Union ) -from typing_extensions import Final, TYPE_CHECKING +from typing_extensions import Final, Type, TYPE_CHECKING from mypy_extensions import trait from mypyc.ir.rtypes import ( @@ -143,7 +143,7 @@ class Integer(Value): - """Short integer literal. + """Integer literal. Integer literals are treated as constant values and are generally not included in data flow analyses and such, unlike Register and @@ -494,36 +494,6 @@ return visitor.visit_load_error_value(self) -class LoadLiteral(RegisterOp): - """Load a Python literal object (dest = 'foo' / b'foo' / ...). - - This is used to load a static PyObject * value corresponding to - a literal of one of the supported types. - - NOTE: For int literals, both int_rprimitive (CPyTagged) and - object_primitive (PyObject *) are supported as types. However, - when using int_rprimitive, the value must *not* be small enough - to fit in an unboxed integer. - - NOTE: You can use this to load boxed (Python) int objects. Use - Integer to load unboxed, tagged integers or fixed-width, - low-level integers. - """ - - error_kind = ERR_NEVER - is_borrowed = True - - def __init__(self, value: Union[str, bytes, int, float, complex], rtype: RType) -> None: - self.value = value - self.type = rtype - - def sources(self) -> List[Value]: - return [] - - def accept(self, visitor: 'OpVisitor[T]') -> T: - return visitor.visit_load_literal(self) - - class GetAttr(RegisterOp): """obj.attr (for a native object)""" @@ -870,12 +840,7 @@ class LoadGlobal(RegisterOp): - """Load a low-level global variable/pointer. - - Note that can't be used to directly load Python module-level - global variable, since they are stored in a globals dictionary - and accessed using dictionary operations. - """ + """Load a global variable/pointer.""" error_kind = ERR_NEVER is_borrowed = True @@ -1160,10 +1125,6 @@ raise NotImplementedError @abstractmethod - def visit_load_literal(self, op: LoadLiteral) -> T: - raise NotImplementedError - - @abstractmethod def visit_get_attr(self, op: GetAttr) -> T: raise NotImplementedError @@ -1254,7 +1215,7 @@ raise NotImplementedError -# TODO: Should the following definition live somewhere else? +# TODO: Should the following definitions live somewhere else? # We do a three-pass deserialization scheme in order to resolve name # references. @@ -1280,3 +1241,5 @@ # compilation but so far it is not hooked up to anything.) DeserMaps = NamedTuple('DeserMaps', [('classes', Dict[str, 'ClassIR']), ('functions', Dict[str, 'FuncIR'])]) + +LiteralsMap = Dict[Tuple[Type[object], Union[int, float, str, bytes, complex]], str]
diff --git a/mypyc/ir/pprint.py b/mypyc/ir/pprint.py index c7c750a..046f903 100644 --- a/mypyc/ir/pprint.py +++ b/mypyc/ir/pprint.py
@@ -9,7 +9,7 @@ Goto, Branch, Return, Unreachable, Assign, Integer, LoadErrorValue, GetAttr, SetAttr, LoadStatic, InitStatic, TupleGet, TupleSet, IncRef, DecRef, Call, MethodCall, Cast, Box, Unbox, RaiseStandardError, CallC, Truncate, LoadGlobal, IntOp, ComparisonOp, LoadMem, SetMem, - GetElementPtr, LoadAddress, Register, Value, OpVisitor, BasicBlock, ControlOp, LoadLiteral + GetElementPtr, LoadAddress, Register, Value, OpVisitor, BasicBlock, ControlOp ) from mypyc.ir.func_ir import FuncIR, all_values_full from mypyc.ir.module_ir import ModuleIRs @@ -59,14 +59,6 @@ def visit_load_error_value(self, op: LoadErrorValue) -> str: return self.format('%r = <error> :: %s', op, op.type) - def visit_load_literal(self, op: LoadLiteral) -> str: - prefix = '' - # For values that have a potential unboxed representation, make - # it explicit that this is a Python object. - if isinstance(op.value, int): - prefix = 'object ' - return self.format('%r = %s%s', op, prefix, repr(op.value)) - def visit_get_attr(self, op: GetAttr) -> str: return self.format('%r = %r.%s', op, op.obj, op.attr)
diff --git a/mypyc/irbuild/builder.py b/mypyc/irbuild/builder.py index ef4fb79..190e852 100644 --- a/mypyc/irbuild/builder.py +++ b/mypyc/irbuild/builder.py
@@ -191,11 +191,11 @@ def py_get_attr(self, obj: Value, attr: str, line: int) -> Value: return self.builder.py_get_attr(obj, attr, line) - def load_str(self, value: str) -> Value: - return self.builder.load_str(value) + def load_static_unicode(self, value: str) -> Value: + return self.builder.load_static_unicode(value) - def load_int(self, value: int) -> Value: - return self.builder.load_int(value) + def load_static_int(self, value: int) -> Value: + return self.builder.load_static_int(value) def unary_op(self, lreg: Value, expr_op: str, line: int) -> Value: return self.builder.unary_op(lreg, expr_op, line) @@ -283,7 +283,7 @@ def add_to_non_ext_dict(self, non_ext: NonExtClassInfo, key: str, val: Value, line: int) -> None: # Add an attribute entry into the class dict of a non-extension class. - key_unicode = self.load_str(key) + key_unicode = self.load_static_unicode(key) self.call_c(dict_set_item_op, [non_ext.dict, key_unicode, val], line) def gen_import(self, id: str, line: int) -> None: @@ -295,7 +295,7 @@ self.add_bool_branch(comparison, out, needs_import) self.activate_block(needs_import) - value = self.call_c(import_op, [self.load_str(id)], line) + value = self.call_c(import_op, [self.load_static_unicode(id)], line) self.add(InitStatic(value, id, namespace=NAMESPACE_MODULE)) self.goto_and_activate(out) @@ -378,13 +378,13 @@ elif isinstance(val, int): # TODO: take care of negative integer initializers # (probably easier to fix this in mypy itself). - return self.builder.load_int(val) + return self.builder.load_static_int(val) elif isinstance(val, float): - return self.builder.load_float(val) + return self.builder.load_static_float(val) elif isinstance(val, str): - return self.builder.load_str(val) + return self.builder.load_static_unicode(val) elif isinstance(val, bytes): - return self.builder.load_bytes(val) + return self.builder.load_static_bytes(val) else: assert False, "Unsupported final literal value" @@ -419,7 +419,7 @@ return self.lookup(symbol) elif lvalue.kind == GDEF: globals_dict = self.load_globals_dict() - name = self.load_str(lvalue.name) + name = self.load_static_unicode(lvalue.name) return AssignmentTargetIndex(globals_dict, name) else: assert False, lvalue.kind @@ -484,7 +484,7 @@ rvalue_reg = self.coerce(rvalue_reg, target.type, line) self.add(SetAttr(target.obj, target.attr, rvalue_reg, line)) else: - key = self.load_str(target.attr) + key = self.load_static_unicode(target.attr) boxed_reg = self.builder.box(rvalue_reg) self.call_c(py_setattr_op, [target.obj, key, boxed_reg], line) elif isinstance(target, AssignmentTargetIndex): @@ -519,7 +519,7 @@ values = [] for i in range(len(target.items)): item = target.items[i] - index = self.builder.load_int(i) + index = self.builder.load_static_int(i) if is_list_rprimitive(rvalue.type): item_value = self.call_c(list_get_item_unsafe_op, [rvalue, index], line) else: @@ -1074,7 +1074,7 @@ def load_global_str(self, name: str, line: int) -> Value: _globals = self.load_globals_dict() - reg = self.load_str(name) + reg = self.load_static_unicode(name) return self.call_c(dict_get_item_op, [_globals, reg], line) def load_globals_dict(self) -> Value:
diff --git a/mypyc/irbuild/classdef.py b/mypyc/irbuild/classdef.py index b708255..88d49b2 100644 --- a/mypyc/irbuild/classdef.py +++ b/mypyc/irbuild/classdef.py
@@ -123,7 +123,7 @@ typ = builder.load_native_type_object(cdef.fullname) value = builder.accept(stmt.rvalue) builder.call_c( - py_setattr_op, [typ, builder.load_str(lvalue.name), value], stmt.line) + py_setattr_op, [typ, builder.load_static_unicode(lvalue.name), value], stmt.line) if builder.non_function_scope() and stmt.is_final_def: builder.init_final_static(lvalue, value, cdef.name) elif isinstance(stmt, ExpressionStmt) and isinstance(stmt.expr, StrExpr): @@ -150,7 +150,7 @@ builder.call_c(dict_set_item_op, [ builder.load_globals_dict(), - builder.load_str(cdef.name), + builder.load_static_unicode(cdef.name), non_ext_class ], cdef.line) @@ -166,7 +166,7 @@ tp_bases = builder.new_tuple(bases, cdef.line) else: tp_bases = builder.add(LoadErrorValue(object_rprimitive, is_borrowed=True)) - modname = builder.load_str(builder.module_name) + modname = builder.load_static_unicode(builder.module_name) template = builder.add(LoadStatic(object_rprimitive, cdef.name + "_template", builder.module_name, NAMESPACE_TYPE)) # Create the class @@ -181,7 +181,7 @@ FuncSignature([], bool_rprimitive)), [], -1)) # Populate a '__mypyc_attrs__' field containing the list of attrs builder.call_c(py_setattr_op, [ - tp, builder.load_str('__mypyc_attrs__'), + tp, builder.load_static_unicode('__mypyc_attrs__'), create_mypyc_attrs_tuple(builder, builder.mapper.type_to_ir[cdef.info], cdef.line)], cdef.line) @@ -192,7 +192,7 @@ builder.call_c(dict_set_item_op, [ builder.load_globals_dict(), - builder.load_str(cdef.name), + builder.load_static_unicode(cdef.name), tp, ], cdef.line) @@ -242,7 +242,7 @@ # Check if the metaclass defines a __prepare__ method, and if so, call it. has_prepare = builder.call_c(py_hasattr_op, [metaclass, - builder.load_str('__prepare__')], cdef.line) + builder.load_static_unicode('__prepare__')], cdef.line) non_ext_dict = Register(dict_rprimitive) @@ -250,7 +250,7 @@ builder.add_bool_branch(has_prepare, true_block, false_block) builder.activate_block(true_block) - cls_name = builder.load_str(cdef.name) + cls_name = builder.load_static_unicode(cdef.name) prepare_meth = builder.py_get_attr(metaclass, '__prepare__', cdef.line) prepare_dict = builder.py_call(prepare_meth, [cls_name, bases], cdef.line) builder.assign(non_ext_dict, prepare_dict, cdef.line) @@ -277,7 +277,7 @@ # We populate __annotations__ because dataclasses uses it to determine # which attributes to compute on. # TODO: Maybe generate more precise types for annotations - key = builder.load_str(lvalue.name) + key = builder.load_static_unicode(lvalue.name) typ = builder.add(LoadAddress(type_object_op.type, type_object_op.src, stmt.line)) builder.call_c(dict_set_item_op, [non_ext.anns, key, typ], stmt.line) @@ -389,7 +389,7 @@ ir: ClassIR, non_ext: NonExtClassInfo, line: int) -> Value: - cls_name = builder.load_str(ir.name) + cls_name = builder.load_static_unicode(ir.name) finish_non_ext_dict(builder, non_ext, line) @@ -432,14 +432,14 @@ attrs = [name for ancestor in ir.mro for name in ancestor.attributes] if ir.inherits_python: attrs.append('__dict__') - items = [builder.load_str(attr) for attr in attrs] + items = [builder.load_static_unicode(attr) for attr in attrs] return builder.new_tuple(items, line) def finish_non_ext_dict(builder: IRBuilder, non_ext: NonExtClassInfo, line: int) -> None: # Add __annotations__ to the class dict. builder.call_c(dict_set_item_op, - [non_ext.dict, builder.load_str('__annotations__'), + [non_ext.dict, builder.load_static_unicode('__annotations__'), non_ext.anns], -1) # We add a __doc__ attribute so if the non-extension class is decorated with the @@ -447,9 +447,9 @@ # https://github.com/python/cpython/blob/3.7/Lib/dataclasses.py#L957 filler_doc_str = 'mypyc filler docstring' builder.add_to_non_ext_dict( - non_ext, '__doc__', builder.load_str(filler_doc_str), line) + non_ext, '__doc__', builder.load_static_unicode(filler_doc_str), line) builder.add_to_non_ext_dict( - non_ext, '__module__', builder.load_str(builder.module_name), line) + non_ext, '__module__', builder.load_static_unicode(builder.module_name), line) def dataclass_finalize(
diff --git a/mypyc/irbuild/expression.py b/mypyc/irbuild/expression.py index 19f8aa2..8b671ad 100644 --- a/mypyc/irbuild/expression.py +++ b/mypyc/irbuild/expression.py
@@ -95,7 +95,7 @@ # instead load the module separately on each access. mod_dict = builder.call_c(get_module_dict_op, [], expr.line) obj = builder.call_c(dict_get_item_op, - [mod_dict, builder.load_str(expr.node.fullname)], + [mod_dict, builder.load_static_unicode(expr.node.fullname)], expr.line) return obj else: @@ -124,7 +124,7 @@ if isinstance(typ, TupleType) and typ.partial_fallback.type.is_named_tuple: fields = typ.partial_fallback.type.metadata['namedtuple']['fields'] if expr.name in fields: - index = builder.builder.load_int(fields.index(expr.name)) + index = builder.builder.load_static_int(fields.index(expr.name)) return builder.gen_method_call(obj, '__getitem__', [index], rtype, expr.line) return builder.builder.get_attr(obj, expr.name, rtype, expr.line) @@ -383,13 +383,13 @@ if index.begin_index: begin = builder.accept(index.begin_index) else: - begin = builder.load_int(0) + begin = builder.load_static_int(0) if index.end_index: end = builder.accept(index.end_index) else: # Replace missing end index with the largest short integer # (a sequence can't be longer). - end = builder.load_int(MAX_SHORT_INT) + end = builder.load_static_int(MAX_SHORT_INT) candidates = [list_slice_op, tuple_slice_op, str_slice_op] return builder.builder.matching_call_c(candidates, [base, begin, end], index.line) @@ -520,24 +520,24 @@ def transform_int_expr(builder: IRBuilder, expr: IntExpr) -> Value: - return builder.builder.load_int(expr.value) + return builder.builder.load_static_int(expr.value) def transform_float_expr(builder: IRBuilder, expr: FloatExpr) -> Value: - return builder.builder.load_float(expr.value) + return builder.builder.load_static_float(expr.value) def transform_complex_expr(builder: IRBuilder, expr: ComplexExpr) -> Value: - return builder.builder.load_complex(expr.value) + return builder.builder.load_static_complex(expr.value) def transform_str_expr(builder: IRBuilder, expr: StrExpr) -> Value: - return builder.load_str(expr.value) + return builder.load_static_unicode(expr.value) def transform_bytes_expr(builder: IRBuilder, expr: BytesExpr) -> Value: value = bytes(expr.value, 'utf8').decode('unicode-escape').encode('raw-unicode-escape') - return builder.builder.load_bytes(value) + return builder.builder.load_static_bytes(value) def transform_ellipsis(builder: IRBuilder, o: EllipsisExpr) -> Value:
diff --git a/mypyc/irbuild/function.py b/mypyc/irbuild/function.py index 0e76067..53bdbcf 100644 --- a/mypyc/irbuild/function.py +++ b/mypyc/irbuild/function.py
@@ -96,7 +96,7 @@ # Set the callable object representing the decorated function as a global. builder.call_c(dict_set_item_op, [builder.load_globals_dict(), - builder.load_str(dec.func.name), decorated_func], + builder.load_static_unicode(dec.func.name), decorated_func], decorated_func.line) builder.functions.append(func_ir) @@ -361,7 +361,7 @@ builder.call_c(py_setattr_op, [ typ, - builder.load_str(name), + builder.load_static_unicode(name), decorated_func ], fdef.line)
diff --git a/mypyc/irbuild/ll_builder.py b/mypyc/irbuild/ll_builder.py index c2e8e76..8466e4f 100644 --- a/mypyc/irbuild/ll_builder.py +++ b/mypyc/irbuild/ll_builder.py
@@ -18,8 +18,8 @@ from mypyc.ir.ops import ( BasicBlock, Op, Integer, Value, Register, Assign, Branch, Goto, Call, Box, Unbox, Cast, - GetAttr, LoadStatic, MethodCall, CallC, Truncate, LoadLiteral, - RaiseStandardError, Unreachable, LoadErrorValue, + GetAttr, LoadStatic, MethodCall, CallC, Truncate, + RaiseStandardError, Unreachable, LoadErrorValue, LoadGlobal, NAMESPACE_TYPE, NAMESPACE_MODULE, NAMESPACE_STATIC, IntOp, GetElementPtr, LoadMem, ComparisonOp, LoadAddress, TupleGet, SetMem, ERR_NEVER, ERR_FALSE ) @@ -34,7 +34,8 @@ from mypyc.ir.func_ir import FuncDecl, FuncSignature from mypyc.ir.class_ir import ClassIR, all_concrete_classes from mypyc.common import ( - FAST_ISINSTANCE_MAX_SUBCLASSES, MAX_LITERAL_SHORT_INT, PLATFORM_SIZE + FAST_ISINSTANCE_MAX_SUBCLASSES, MAX_LITERAL_SHORT_INT, + STATIC_PREFIX, PLATFORM_SIZE ) from mypyc.primitives.registry import ( method_call_ops, CFunctionDescription, function_ops, @@ -190,7 +191,7 @@ Prefer get_attr() which generates optimized code for native classes. """ - key = self.load_str(attr) + key = self.load_static_unicode(attr) return self.call_c(py_getattr_op, [obj, key], line) # isinstance() checks @@ -261,7 +262,7 @@ pos_arg_values.append(value) elif kind == ARG_NAMED: assert name is not None - key = self.load_str(name) + key = self.load_static_unicode(name) kw_arg_key_value_pairs.append((key, value)) elif kind == ARG_STAR: star_arg_values.append(value) @@ -297,7 +298,7 @@ arg_names: Optional[Sequence[Optional[str]]]) -> Value: """Call a Python method (non-native and slow).""" if (arg_kinds is None) or all(kind == ARG_POS for kind in arg_kinds): - method_name_reg = self.load_str(method_name) + method_name_reg = self.load_static_unicode(method_name) return self.call_c(py_method_call_op, [obj, method_name_reg] + arg_values, line) else: method = self.py_get_attr(obj, method_name, line) @@ -348,7 +349,7 @@ items = [args[i] for i in lst] output_arg = self.new_tuple(items, line) elif arg.kind == ARG_STAR2: - dict_entries = [(self.load_str(cast(str, arg_names[i])), args[i]) + dict_entries = [(self.load_static_unicode(cast(str, arg_names[i])), args[i]) for i in lst] output_arg = self.make_dict(dict_entries, line) elif not lst: @@ -447,32 +448,40 @@ """Load Python None value (type: object_rprimitive).""" return self.add(LoadAddress(none_object_op.type, none_object_op.src, line=-1)) - def load_int(self, value: int) -> Value: - """Load a tagged (Python) integer literal value.""" + def literal_static_name(self, value: Union[int, float, complex, str, bytes]) -> str: + return STATIC_PREFIX + self.mapper.literal_static_name(self.current_module, value) + + def load_static_int(self, value: int) -> Value: + """Loads a static integer Python 'int' object into a register.""" if abs(value) > MAX_LITERAL_SHORT_INT: - return self.add(LoadLiteral(value, int_rprimitive)) + identifier = self.literal_static_name(value) + return self.add(LoadGlobal(int_rprimitive, identifier, ann=value)) else: return Integer(value) - def load_float(self, value: float) -> Value: - """Load a float literal value.""" - return self.add(LoadLiteral(value, float_rprimitive)) + def load_static_float(self, value: float) -> Value: + """Loads a static float value into a register.""" + identifier = self.literal_static_name(value) + return self.add(LoadGlobal(float_rprimitive, identifier, ann=value)) - def load_str(self, value: str) -> Value: - """Load a str literal value. + def load_static_bytes(self, value: bytes) -> Value: + """Loads a static bytes value into a register.""" + identifier = self.literal_static_name(value) + return self.add(LoadGlobal(object_rprimitive, identifier, ann=value)) - This is useful for more than just str literals; for example, method calls + def load_static_complex(self, value: complex) -> Value: + """Loads a static complex value into a register.""" + identifier = self.literal_static_name(value) + return self.add(LoadGlobal(object_rprimitive, identifier, ann=value)) + + def load_static_unicode(self, value: str) -> Value: + """Loads a static unicode value into a register. + + This is useful for more than just unicode literals; for example, method calls also require a PyObject * form for the name of the method. """ - return self.add(LoadLiteral(value, str_rprimitive)) - - def load_bytes(self, value: bytes) -> Value: - """Load a bytes literal value.""" - return self.add(LoadLiteral(value, object_rprimitive)) - - def load_complex(self, value: complex) -> Value: - """Load a complex literal value.""" - return self.add(LoadLiteral(value, object_rprimitive)) + identifier = self.literal_static_name(value) + return self.add(LoadGlobal(str_rprimitive, identifier, ann=value)) def load_static_checked(self, typ: RType, identifier: str, module_name: Optional[str] = None, namespace: str = NAMESPACE_STATIC,
diff --git a/mypyc/irbuild/mapper.py b/mypyc/irbuild/mapper.py index 5b2521d..7cc6689 100644 --- a/mypyc/irbuild/mapper.py +++ b/mypyc/irbuild/mapper.py
@@ -1,6 +1,7 @@ """Maintain a mapping from mypy concepts to IR/compiled concepts.""" -from typing import Dict, Optional +from typing import Dict, Optional, Union +from mypy.ordered_dict import OrderedDict from mypy.nodes import FuncDef, TypeInfo, SymbolNode, ARG_STAR, ARG_STAR2 from mypy.types import ( @@ -9,6 +10,7 @@ get_proper_type ) +from mypyc.ir.ops import LiteralsMap from mypyc.ir.rtypes import ( RType, RUnion, RTuple, RInstance, object_rprimitive, dict_rprimitive, tuple_rprimitive, none_rprimitive, int_rprimitive, float_rprimitive, str_rprimitive, bool_rprimitive, @@ -32,6 +34,12 @@ self.group_map = group_map self.type_to_ir = {} # type: Dict[TypeInfo, ClassIR] self.func_to_decl = {} # type: Dict[SymbolNode, FuncDecl] + # LiteralsMap maps literal values to a static name. Each + # compilation group has its own LiteralsMap. (Since they can't + # share literals.) + self.literals = { + v: OrderedDict() for v in group_map.values() + } # type: Dict[Optional[str], LiteralsMap] def type_to_rtype(self, typ: Optional[Type]) -> RType: if typ is None: @@ -140,3 +148,19 @@ if fdef.name in ('__eq__', '__ne__', '__lt__', '__gt__', '__le__', '__ge__'): ret = object_rprimitive return FuncSignature(args, ret) + + def literal_static_name(self, module: str, + value: Union[int, float, complex, str, bytes]) -> str: + # Literals are shared between modules in a compilation group + # but not outside the group. + literals = self.literals[self.group_map.get(module)] + + # Include type to distinguish between 1 and 1.0, and so on. + key = (type(value), value) + if key not in literals: + if isinstance(value, str): + prefix = 'unicode_' + else: + prefix = type(value).__name__ + '_' + literals[key] = prefix + str(len(literals)) + return literals[key]
diff --git a/mypyc/irbuild/statement.py b/mypyc/irbuild/statement.py index 06d5cca..269e354 100644 --- a/mypyc/irbuild/statement.py +++ b/mypyc/irbuild/statement.py
@@ -156,10 +156,10 @@ mod_dict = builder.call_c(get_module_dict_op, [], node.line) # Get top-level module/package object. obj = builder.call_c(dict_get_item_op, - [mod_dict, builder.load_str(base)], node.line) + [mod_dict, builder.load_static_unicode(base)], node.line) builder.gen_method_call( - globals, '__setitem__', [builder.load_str(name), obj], + globals, '__setitem__', [builder.load_static_unicode(name), obj], result_type=None, line=node.line) @@ -193,7 +193,7 @@ as_name = maybe_as_name or name obj = builder.py_get_attr(module, name, node.line) builder.gen_method_call( - globals, '__setitem__', [builder.load_str(as_name), obj], + globals, '__setitem__', [builder.load_static_unicode(as_name), obj], result_type=None, line=node.line) @@ -663,7 +663,7 @@ line=line ) elif isinstance(target, AssignmentTargetAttr): - key = builder.load_str(target.attr) + key = builder.load_static_unicode(target.attr) builder.call_c(py_delattr_op, [target.obj, key], line) elif isinstance(target, AssignmentTargetRegister): # Delete a local by assigning an error value to it, which will
diff --git a/mypyc/lib-rt/CPy.h b/mypyc/lib-rt/CPy.h index a69836a..9d0ec6e 100644 --- a/mypyc/lib-rt/CPy.h +++ b/mypyc/lib-rt/CPy.h
@@ -522,8 +522,6 @@ CPyArg_Parser *parser, ...); int CPySequence_CheckUnpackCount(PyObject *sequence, Py_ssize_t expected); -int CPyStatics_Initialize(PyObject **statics, const char *strings, const char *bytestrings, - const char *ints, const double *floats, const double *complex_numbers); #ifdef __cplusplus
diff --git a/mypyc/lib-rt/misc_ops.c b/mypyc/lib-rt/misc_ops.c index bc51dea..5d6aa63 100644 --- a/mypyc/lib-rt/misc_ops.c +++ b/mypyc/lib-rt/misc_ops.c
@@ -509,90 +509,3 @@ } return 0; } - -// Parse an integer (size_t) encoded as a variable-length binary sequence. -static const char *parse_int(const char *s, size_t *len) { - ssize_t n = 0; - while ((unsigned char)*s >= 0x80) { - n = (n << 7) + (*s & 0x7f); - s++; - } - n = (n << 7) | *s++; - *len = n; - return s; -} - -// Initialize static constant array of literal values -int CPyStatics_Initialize(PyObject **statics, - const char *strings, - const char *bytestrings, - const char *ints, - const double *floats, - const double *complex_numbers) { - if (strings) { - size_t num; - strings = parse_int(strings, &num); - while (num-- > 0) { - size_t len; - strings = parse_int(strings, &len); - PyObject *obj = PyUnicode_FromStringAndSize(strings, len); - if (obj == NULL) { - return -1; - } - PyUnicode_InternInPlace(&obj); - *statics++ = obj; - strings += len; - } - } - if (bytestrings) { - size_t num; - bytestrings = parse_int(bytestrings, &num); - while (num-- > 0) { - size_t len; - bytestrings = parse_int(bytestrings, &len); - PyObject *obj = PyBytes_FromStringAndSize(bytestrings, len); - if (obj == NULL) { - return -1; - } - *statics++ = obj; - bytestrings += len; - } - } - if (ints) { - size_t num; - ints = parse_int(ints, &num); - while (num-- > 0) { - char *end; - PyObject *obj = PyLong_FromString(ints, &end, 10); - if (obj == NULL) { - return -1; - } - ints = end; - ints++; - *statics++ = obj; - } - } - if (floats) { - size_t num = (size_t)*floats++; - while (num-- > 0) { - PyObject *obj = PyFloat_FromDouble(*floats++); - if (obj == NULL) { - return -1; - } - *statics++ = obj; - } - } - if (complex_numbers) { - size_t num = (size_t)*complex_numbers++; - while (num-- > 0) { - double real = *complex_numbers++; - double imag = *complex_numbers++; - PyObject *obj = PyComplex_FromDoubles(real, imag); - if (obj == NULL) { - return -1; - } - *statics++ = obj; - } - } - return 0; -}
diff --git a/mypyc/test-data/analysis.test b/mypyc/test-data/analysis.test index efa7fd0..3e12b52 100644 --- a/mypyc/test-data/analysis.test +++ b/mypyc/test-data/analysis.test
@@ -548,7 +548,7 @@ L2: r1 = CPy_CatchError() r2 = builtins :: module - r3 = 'Exception' + r3 = load_global CPyStatic_unicode_1 :: static ('Exception') r4 = CPyObject_GetAttr(r2, r3) if is_error(r4) goto L8 (error at lol:4) else goto L3 L3: @@ -605,4 +605,3 @@ (10, 1) {r8} {} (11, 0) {} {r9} (11, 1) {r9} {} -
diff --git a/mypyc/test-data/exceptions.test b/mypyc/test-data/exceptions.test index ba21969..a1925e4 100644 --- a/mypyc/test-data/exceptions.test +++ b/mypyc/test-data/exceptions.test
@@ -187,7 +187,7 @@ L0: L1: r0 = builtins :: module - r1 = 'object' + r1 = load_global CPyStatic_unicode_1 :: static ('object') r2 = CPyObject_GetAttr(r0, r1) if is_error(r2) goto L3 (error at g:3) else goto L2 L2: @@ -196,9 +196,9 @@ if is_error(r3) goto L3 (error at g:3) else goto L10 L3: r4 = CPy_CatchError() - r5 = 'weeee' + r5 = load_global CPyStatic_unicode_2 :: static ('weeee') r6 = builtins :: module - r7 = 'print' + r7 = load_global CPyStatic_unicode_3 :: static ('print') r8 = CPyObject_GetAttr(r6, r7) if is_error(r8) goto L6 (error at g:5) else goto L4 L4: @@ -253,7 +253,7 @@ L0: L1: r0 = builtins :: module - r1 = 'print' + r1 = load_global CPyStatic_unicode_1 :: static ('print') r2 = CPyObject_GetAttr(r0, r1) if is_error(r2) goto L5 (error at a:3) else goto L2 L2: @@ -261,7 +261,7 @@ dec_ref r2 if is_error(r3) goto L5 (error at a:3) else goto L20 L3: - r4 = 'hi' + r4 = load_global CPyStatic_unicode_2 :: static ('hi') inc_ref r4 r5 = r4 L4: @@ -274,9 +274,9 @@ r9 = CPy_CatchError() r7 = r9 L6: - r10 = 'goodbye!' + r10 = load_global CPyStatic_unicode_3 :: static ('goodbye!') r11 = builtins :: module - r12 = 'print' + r12 = load_global CPyStatic_unicode_1 :: static ('print') r13 = CPyObject_GetAttr(r11, r12) if is_error(r13) goto L13 (error at a:6) else goto L7 L7: @@ -352,7 +352,7 @@ r3 :: str L0: L1: - r0 = 'foo' + r0 = load_global CPyStatic_unicode_3 :: static ('foo') r1 = CPyObject_GetAttr(x, r0) if is_error(r1) goto L3 (error at lol:4) else goto L2 L2: @@ -360,7 +360,7 @@ goto L4 L3: r2 = CPy_CatchError() - r3 = '' + r3 = load_global CPyStatic_unicode_4 :: static CPy_RestoreExcInfo(r2) dec_ref r2 inc_ref r3 @@ -394,12 +394,12 @@ r1 = <error> :: object b = r1 L1: - r2 = 'foo' + r2 = load_global CPyStatic_unicode_3 :: static ('foo') r3 = CPyObject_GetAttr(x, r2) if is_error(r3) goto L4 (error at lol:4) else goto L15 L2: a = r3 - r4 = 'bar' + r4 = load_global CPyStatic_unicode_4 :: static ('bar') r5 = CPyObject_GetAttr(x, r4) if is_error(r5) goto L4 (error at lol:5) else goto L16 L3: @@ -469,13 +469,13 @@ L0: r0 = <error> :: str v = r0 - r1 = 'a' + r1 = load_global CPyStatic_unicode_1 :: static ('a') inc_ref r1 u = r1 L1: if b goto L10 else goto L11 :: bool L2: - r2 = 'b' + r2 = load_global CPyStatic_unicode_2 :: static ('b') inc_ref r2 v = r2 r3 = v == u @@ -483,7 +483,7 @@ if r4 goto L11 else goto L1 :: bool L3: r5 = builtins :: module - r6 = 'print' + r6 = load_global CPyStatic_unicode_3 :: static ('print') r7 = CPyObject_GetAttr(r5, r6) if is_error(r7) goto L12 (error at f:7) else goto L4 L4:
diff --git a/mypyc/test-data/fixtures/ir.py b/mypyc/test-data/fixtures/ir.py index bb85a41..09bd0aa 100644 --- a/mypyc/test-data/fixtures/ir.py +++ b/mypyc/test-data/fixtures/ir.py
@@ -90,7 +90,6 @@ def __sub__(self, n: complex) -> complex: pass def __mul__(self, n: complex) -> complex: pass def __truediv__(self, n: complex) -> complex: pass - def __neg__(self) -> complex: pass class bytes: def __init__(self, x: object) -> None: pass
diff --git a/mypyc/test-data/irbuild-any.test b/mypyc/test-data/irbuild-any.test index c2badd4..8c07aeb 100644 --- a/mypyc/test-data/irbuild-any.test +++ b/mypyc/test-data/irbuild-any.test
@@ -62,7 +62,7 @@ a = r4 r5 = unbox(int, a) n = r5 - r6 = 'a' + r6 = load_global CPyStatic_unicode_6 :: static ('a') r7 = box(int, n) r8 = PyObject_SetAttr(a, r6, r7) r9 = r8 >= 0 :: signed
diff --git a/mypyc/test-data/irbuild-basic.test b/mypyc/test-data/irbuild-basic.test index 184984e..e853fda 100644 --- a/mypyc/test-data/irbuild-basic.test +++ b/mypyc/test-data/irbuild-basic.test
@@ -683,7 +683,7 @@ r5 :: int L0: r0 = testmodule :: module - r1 = 'factorial' + r1 = load_global CPyStatic_unicode_2 :: static ('factorial') r2 = CPyObject_GetAttr(r0, r1) r3 = box(int, x) r4 = PyObject_CallFunctionObjArgs(r2, r3, 0) @@ -707,7 +707,7 @@ r5 :: int L0: r0 = __main__.globals :: static - r1 = 'g' + r1 = load_global CPyStatic_unicode_2 :: static ('g') r2 = CPyDict_GetItem(r0, r1) r3 = box(int, x) r4 = PyObject_CallFunctionObjArgs(r2, r3, 0) @@ -726,7 +726,7 @@ r2, r3, r4 :: object L0: r0 = builtins :: module - r1 = 'print' + r1 = load_global CPyStatic_unicode_1 :: static ('print') r2 = CPyObject_GetAttr(r0, r1) r3 = box(short_int, 10) r4 = PyObject_CallFunctionObjArgs(r2, r3, 0) @@ -744,7 +744,7 @@ r2, r3, r4 :: object L0: r0 = builtins :: module - r1 = 'print' + r1 = load_global CPyStatic_unicode_1 :: static ('print') r2 = CPyObject_GetAttr(r0, r1) r3 = box(short_int, 10) r4 = PyObject_CallFunctionObjArgs(r2, r3, 0) @@ -758,9 +758,9 @@ def f(): r0, x, r1 :: str L0: - r0 = 'some string' + r0 = load_global CPyStatic_unicode_1 :: static ('some string') x = r0 - r1 = 'some other string' + r1 = load_global CPyStatic_unicode_2 :: static ('some other string') return r1 [case testBytesLiteral] @@ -771,9 +771,9 @@ def f(): r0, x, r1 :: object L0: - r0 = b'\xf0' + r0 = load_global CPyStatic_bytes_1 :: static (b'\xf0') x = r0 - r1 = b'1234' + r1 = load_global CPyStatic_bytes_2 :: static (b'1234') return r1 [case testPyMethodCall1] @@ -791,11 +791,11 @@ r4 :: object r5 :: int L0: - r0 = 'pop' + r0 = load_global CPyStatic_unicode_3 :: static ('pop') r1 = CPyObject_CallMethodObjArgs(x, r0, 0) r2 = unbox(int, r1) y = r2 - r3 = 'pop' + r3 = load_global CPyStatic_unicode_3 :: static ('pop') r4 = CPyObject_CallMethodObjArgs(x, r3, 0) r5 = unbox(int, r4) return r5 @@ -1018,11 +1018,11 @@ r5 :: object r6 :: float L0: - r0 = 1.0 + r0 = load_global CPyStatic_float_1 :: static (1.0) f1 = r0 - r1 = 2.0 + r1 = load_global CPyStatic_float_2 :: static (2.0) f2 = r1 - r2 = 3.0 + r2 = load_global CPyStatic_float_3 :: static (3.0) f3 = r2 r3 = PyNumber_Multiply(f1, f2) r4 = cast(float, r3) @@ -1039,8 +1039,8 @@ r1 :: float r2 :: object L0: - r0 = 5j - r1 = 1.0 + r0 = load_global CPyStatic_complex_1 :: static (5j) + r1 = load_global CPyStatic_float_2 :: static (1.0) r2 = PyNumber_Add(r0, r1) return r2 @@ -1060,13 +1060,13 @@ L0: a_62_bit = 9223372036854775804 max_62_bit = 9223372036854775806 - r0 = object 4611686018427387904 + r0 = load_global CPyStatic_int_1 :: static (4611686018427387904) b_63_bit = r0 - r1 = object 9223372036854775806 + r1 = load_global CPyStatic_int_2 :: static (9223372036854775806) c_63_bit = r1 - r2 = object 9223372036854775807 + r2 = load_global CPyStatic_int_3 :: static (9223372036854775807) max_63_bit = r2 - r3 = object 9223372036854775808 + r3 = load_global CPyStatic_int_4 :: static (9223372036854775808) d_64_bit = r3 max_32_bit = 4294967294 max_31_bit = 2147483646 @@ -1086,19 +1086,19 @@ def big_int(): r0, a_62_bit, r1, max_62_bit, r2, b_63_bit, r3, c_63_bit, r4, max_63_bit, r5, d_64_bit, r6, max_32_bit, max_31_bit :: int L0: - r0 = object 4611686018427387902 + r0 = load_global CPyStatic_int_1 :: static (4611686018427387902) a_62_bit = r0 - r1 = object 4611686018427387903 + r1 = load_global CPyStatic_int_2 :: static (4611686018427387903) max_62_bit = r1 - r2 = object 4611686018427387904 + r2 = load_global CPyStatic_int_3 :: static (4611686018427387904) b_63_bit = r2 - r3 = object 9223372036854775806 + r3 = load_global CPyStatic_int_4 :: static (9223372036854775806) c_63_bit = r3 - r4 = object 9223372036854775807 + r4 = load_global CPyStatic_int_5 :: static (9223372036854775807) max_63_bit = r4 - r5 = object 9223372036854775808 + r5 = load_global CPyStatic_int_6 :: static (9223372036854775808) d_64_bit = r5 - r6 = object 2147483647 + r6 = load_global CPyStatic_int_7 :: static (2147483647) max_32_bit = r6 max_31_bit = 2147483646 return 1 @@ -1165,7 +1165,7 @@ def return_float(): r0 :: float L0: - r0 = 5.0 + r0 = load_global CPyStatic_float_3 :: static (5.0) return r0 def return_callable_type(): r0 :: dict @@ -1173,7 +1173,7 @@ r2 :: object L0: r0 = __main__.globals :: static - r1 = 'return_float' + r1 = load_global CPyStatic_unicode_4 :: static ('return_float') r2 = CPyDict_GetItem(r0, r1) return r2 def call_callable_type(): @@ -1209,7 +1209,7 @@ r6 :: int L0: r0 = load_address PyLong_Type - r1 = 'base' + r1 = load_global CPyStatic_unicode_3 :: static ('base') r2 = PyTuple_Pack(1, x) r3 = box(short_int, 4) r4 = CPyDict_Build(1, r1, r3) @@ -1235,18 +1235,18 @@ r15 :: dict r16 :: object L0: - r0 = 'insert' + r0 = load_global CPyStatic_unicode_4 :: static ('insert') r1 = CPyObject_GetAttr(xs, r0) - r2 = 'x' + r2 = load_global CPyStatic_unicode_5 :: static ('x') r3 = box(short_int, 0) r4 = PyTuple_Pack(1, r3) r5 = box(int, first) r6 = CPyDict_Build(1, r2, r5) r7 = PyObject_Call(r1, r4, r6) - r8 = 'insert' + r8 = load_global CPyStatic_unicode_4 :: static ('insert') r9 = CPyObject_GetAttr(xs, r8) - r10 = 'x' - r11 = 'i' + r10 = load_global CPyStatic_unicode_5 :: static ('x') + r11 = load_global CPyStatic_unicode_6 :: static ('i') r12 = PyTuple_Pack(0) r13 = box(int, second) r14 = box(short_int, 2) @@ -1417,7 +1417,7 @@ r2, r3 :: object L0: r0 = builtins :: module - r1 = 'Exception' + r1 = load_global CPyStatic_unicode_1 :: static ('Exception') r2 = CPyObject_GetAttr(r0, r1) r3 = PyObject_CallFunctionObjArgs(r2, 0) CPy_Raise(r3) @@ -1428,7 +1428,7 @@ r2 :: object L0: r0 = builtins :: module - r1 = 'Exception' + r1 = load_global CPyStatic_unicode_1 :: static ('Exception') r2 = CPyObject_GetAttr(r0, r1) CPy_Raise(r2) unreachable @@ -1450,11 +1450,11 @@ r6, r7, r8 :: object L0: r0 = __main__.globals :: static - r1 = 'x' + r1 = load_global CPyStatic_unicode_1 :: static ('x') r2 = CPyDict_GetItem(r0, r1) r3 = unbox(int, r2) r4 = builtins :: module - r5 = 'print' + r5 = load_global CPyStatic_unicode_2 :: static ('print') r6 = CPyObject_GetAttr(r4, r5) r7 = box(int, r3) r8 = PyObject_CallFunctionObjArgs(r6, r7, 0) @@ -1482,21 +1482,21 @@ r2 = r0 != r1 if r2 goto L2 else goto L1 :: bool L1: - r3 = 'builtins' + r3 = load_global CPyStatic_unicode_0 :: static ('builtins') r4 = PyImport_Import(r3) builtins = r4 :: module L2: r5 = __main__.globals :: static - r6 = 'x' + r6 = load_global CPyStatic_unicode_1 :: static ('x') r7 = box(short_int, 2) r8 = CPyDict_SetItem(r5, r6, r7) r9 = r8 >= 0 :: signed r10 = __main__.globals :: static - r11 = 'x' + r11 = load_global CPyStatic_unicode_1 :: static ('x') r12 = CPyDict_GetItem(r10, r11) r13 = unbox(int, r12) r14 = builtins :: module - r15 = 'print' + r15 = load_global CPyStatic_unicode_2 :: static ('print') r16 = CPyObject_GetAttr(r14, r15) r17 = box(int, r13) r18 = PyObject_CallFunctionObjArgs(r16, r17, 0) @@ -1520,7 +1520,7 @@ r5 :: str L0: r0 = m :: module - r1 = 'f' + r1 = load_global CPyStatic_unicode_2 :: static ('f') r2 = CPyObject_GetAttr(r0, r1) r3 = box(short_int, 2) r4 = PyObject_CallFunctionObjArgs(r2, r3, 0) @@ -1628,9 +1628,9 @@ r2 :: str r3 :: None L0: - r0 = 'a' + r0 = load_global CPyStatic_unicode_1 :: static ('a') r1 = f(0, r0) - r2 = 'b' + r2 = load_global CPyStatic_unicode_2 :: static ('b') r3 = f(2, r2) return 1 @@ -1655,9 +1655,9 @@ r2 :: str r3 :: None L0: - r0 = 'a' + r0 = load_global CPyStatic_unicode_4 :: static ('a') r1 = a.f(0, r0) - r2 = 'b' + r2 = load_global CPyStatic_unicode_5 :: static ('b') r3 = a.f(2, r2) return 1 @@ -1690,7 +1690,7 @@ L0: r0 = (2, 4, 6) r1 = __main__.globals :: static - r2 = 'f' + r2 = load_global CPyStatic_unicode_3 :: static ('f') r3 = CPyDict_GetItem(r1, r2) r4 = PyList_New(0) r5 = box(tuple[int, int, int], r0) @@ -1716,7 +1716,7 @@ L0: r0 = (4, 6) r1 = __main__.globals :: static - r2 = 'f' + r2 = load_global CPyStatic_unicode_3 :: static ('f') r3 = CPyDict_GetItem(r1, r2) r4 = PyList_New(1) r5 = box(short_int, 2) @@ -1759,15 +1759,15 @@ r14 :: object r15 :: tuple[int, int, int] L0: - r0 = 'a' - r1 = 'b' - r2 = 'c' + r0 = load_global CPyStatic_unicode_3 :: static ('a') + r1 = load_global CPyStatic_unicode_4 :: static ('b') + r2 = load_global CPyStatic_unicode_5 :: static ('c') r3 = box(short_int, 2) r4 = box(short_int, 4) r5 = box(short_int, 6) r6 = CPyDict_Build(3, r0, r3, r1, r4, r2, r5) r7 = __main__.globals :: static - r8 = 'f' + r8 = load_global CPyStatic_unicode_6 :: static ('f') r9 = CPyDict_GetItem(r7, r8) r10 = PyTuple_Pack(0) r11 = PyDict_New() @@ -1789,13 +1789,13 @@ r13 :: object r14 :: tuple[int, int, int] L0: - r0 = 'b' - r1 = 'c' + r0 = load_global CPyStatic_unicode_4 :: static ('b') + r1 = load_global CPyStatic_unicode_5 :: static ('c') r2 = box(short_int, 4) r3 = box(short_int, 6) r4 = CPyDict_Build(2, r0, r2, r1, r3) r5 = __main__.globals :: static - r6 = 'f' + r6 = load_global CPyStatic_unicode_6 :: static ('f') r7 = CPyDict_GetItem(r5, r6) r8 = box(short_int, 2) r9 = PyTuple_Pack(1, r8) @@ -1824,7 +1824,7 @@ L2: if is_error(z) goto L3 else goto L4 L3: - r0 = 'test' + r0 = load_global CPyStatic_unicode_1 :: static ('test') z = r0 L4: return 1 @@ -1863,7 +1863,7 @@ L2: if is_error(z) goto L3 else goto L4 L3: - r0 = 'test' + r0 = load_global CPyStatic_unicode_4 :: static ('test') z = r0 L4: return 1 @@ -2566,7 +2566,7 @@ r2 = r0 != r1 if r2 goto L2 else goto L1 :: bool L1: - r3 = 'builtins' + r3 = load_global CPyStatic_unicode_0 :: static ('builtins') r4 = PyImport_Import(r3) builtins = r4 :: module L2: @@ -2575,76 +2575,76 @@ r7 = r5 != r6 if r7 goto L4 else goto L3 :: bool L3: - r8 = 'typing' + r8 = load_global CPyStatic_unicode_1 :: static ('typing') r9 = PyImport_Import(r8) typing = r9 :: module L4: r10 = typing :: module r11 = __main__.globals :: static - r12 = 'List' + r12 = load_global CPyStatic_unicode_2 :: static ('List') r13 = CPyObject_GetAttr(r10, r12) - r14 = 'List' + r14 = load_global CPyStatic_unicode_2 :: static ('List') r15 = CPyDict_SetItem(r11, r14, r13) r16 = r15 >= 0 :: signed - r17 = 'NewType' + r17 = load_global CPyStatic_unicode_3 :: static ('NewType') r18 = CPyObject_GetAttr(r10, r17) - r19 = 'NewType' + r19 = load_global CPyStatic_unicode_3 :: static ('NewType') r20 = CPyDict_SetItem(r11, r19, r18) r21 = r20 >= 0 :: signed - r22 = 'NamedTuple' + r22 = load_global CPyStatic_unicode_4 :: static ('NamedTuple') r23 = CPyObject_GetAttr(r10, r22) - r24 = 'NamedTuple' + r24 = load_global CPyStatic_unicode_4 :: static ('NamedTuple') r25 = CPyDict_SetItem(r11, r24, r23) r26 = r25 >= 0 :: signed - r27 = 'Lol' - r28 = 'a' + r27 = load_global CPyStatic_unicode_5 :: static ('Lol') + r28 = load_global CPyStatic_unicode_6 :: static ('a') r29 = load_address PyLong_Type r30 = (r28, r29) r31 = box(tuple[str, object], r30) - r32 = 'b' + r32 = load_global CPyStatic_unicode_7 :: static ('b') r33 = load_address PyUnicode_Type r34 = (r32, r33) r35 = box(tuple[str, object], r34) r36 = (r31, r35) r37 = box(tuple[object, object], r36) r38 = __main__.globals :: static - r39 = 'NamedTuple' + r39 = load_global CPyStatic_unicode_4 :: static ('NamedTuple') r40 = CPyDict_GetItem(r38, r39) r41 = PyObject_CallFunctionObjArgs(r40, r27, r37, 0) r42 = __main__.globals :: static - r43 = 'Lol' + r43 = load_global CPyStatic_unicode_5 :: static ('Lol') r44 = CPyDict_SetItem(r42, r43, r41) r45 = r44 >= 0 :: signed - r46 = '' + r46 = load_global CPyStatic_unicode_8 :: static r47 = __main__.globals :: static - r48 = 'Lol' + r48 = load_global CPyStatic_unicode_5 :: static ('Lol') r49 = CPyDict_GetItem(r47, r48) r50 = box(short_int, 2) r51 = PyObject_CallFunctionObjArgs(r49, r50, r46, 0) r52 = cast(tuple, r51) r53 = __main__.globals :: static - r54 = 'x' + r54 = load_global CPyStatic_unicode_9 :: static ('x') r55 = CPyDict_SetItem(r53, r54, r52) r56 = r55 >= 0 :: signed r57 = __main__.globals :: static - r58 = 'List' + r58 = load_global CPyStatic_unicode_2 :: static ('List') r59 = CPyDict_GetItem(r57, r58) r60 = load_address PyLong_Type r61 = PyObject_GetItem(r59, r60) r62 = __main__.globals :: static - r63 = 'Foo' + r63 = load_global CPyStatic_unicode_10 :: static ('Foo') r64 = CPyDict_SetItem(r62, r63, r61) r65 = r64 >= 0 :: signed - r66 = 'Bar' + r66 = load_global CPyStatic_unicode_11 :: static ('Bar') r67 = __main__.globals :: static - r68 = 'Foo' + r68 = load_global CPyStatic_unicode_10 :: static ('Foo') r69 = CPyDict_GetItem(r67, r68) r70 = __main__.globals :: static - r71 = 'NewType' + r71 = load_global CPyStatic_unicode_3 :: static ('NewType') r72 = CPyDict_GetItem(r70, r71) r73 = PyObject_CallFunctionObjArgs(r72, r66, r69, 0) r74 = __main__.globals :: static - r75 = 'Bar' + r75 = load_global CPyStatic_unicode_11 :: static ('Bar') r76 = CPyDict_SetItem(r74, r75, r73) r77 = r76 >= 0 :: signed r78 = PyList_New(3) @@ -2659,11 +2659,11 @@ r85 = r83 + WORD_SIZE*2 set_mem r85, r81, r78 :: builtins.object* r86 = __main__.globals :: static - r87 = 'Bar' + r87 = load_global CPyStatic_unicode_11 :: static ('Bar') r88 = CPyDict_GetItem(r86, r87) r89 = PyObject_CallFunctionObjArgs(r88, r78, 0) r90 = __main__.globals :: static - r91 = 'y' + r91 = load_global CPyStatic_unicode_12 :: static ('y') r92 = CPyDict_SetItem(r90, r91, r89) r93 = r92 >= 0 :: signed return 1 @@ -2825,16 +2825,16 @@ r0 = __mypyc_self__.__mypyc_env__ r1 = r0.g g = r1 - r2 = 'Entering' + r2 = load_global CPyStatic_unicode_3 :: static ('Entering') r3 = builtins :: module - r4 = 'print' + r4 = load_global CPyStatic_unicode_4 :: static ('print') r5 = CPyObject_GetAttr(r3, r4) r6 = PyObject_CallFunctionObjArgs(r5, r2, 0) r7 = r0.f r8 = PyObject_CallFunctionObjArgs(r7, 0) - r9 = 'Exited' + r9 = load_global CPyStatic_unicode_5 :: static ('Exited') r10 = builtins :: module - r11 = 'print' + r11 = load_global CPyStatic_unicode_4 :: static ('print') r12 = CPyObject_GetAttr(r10, r11) r13 = PyObject_CallFunctionObjArgs(r12, r9, 0) return 1 @@ -2882,16 +2882,16 @@ r0 = __mypyc_self__.__mypyc_env__ r1 = r0.g g = r1 - r2 = '---' + r2 = load_global CPyStatic_unicode_6 :: static ('---') r3 = builtins :: module - r4 = 'print' + r4 = load_global CPyStatic_unicode_4 :: static ('print') r5 = CPyObject_GetAttr(r3, r4) r6 = PyObject_CallFunctionObjArgs(r5, r2, 0) r7 = r0.f r8 = PyObject_CallFunctionObjArgs(r7, 0) - r9 = '---' + r9 = load_global CPyStatic_unicode_6 :: static ('---') r10 = builtins :: module - r11 = 'print' + r11 = load_global CPyStatic_unicode_4 :: static ('print') r12 = CPyObject_GetAttr(r10, r11) r13 = PyObject_CallFunctionObjArgs(r12, r9, 0) return 1 @@ -2935,9 +2935,9 @@ r0 = __mypyc_self__.__mypyc_env__ r1 = r0.d d = r1 - r2 = 'd' + r2 = load_global CPyStatic_unicode_7 :: static ('d') r3 = builtins :: module - r4 = 'print' + r4 = load_global CPyStatic_unicode_4 :: static ('print') r5 = CPyObject_GetAttr(r3, r4) r6 = PyObject_CallFunctionObjArgs(r5, r2, 0) return 1 @@ -2961,17 +2961,17 @@ r1 = __mypyc_d_decorator_helper_____mypyc_c_decorator_helper___obj() r1.__mypyc_env__ = r0; r2 = is_error r3 = __main__.globals :: static - r4 = 'b' + r4 = load_global CPyStatic_unicode_8 :: static ('b') r5 = CPyDict_GetItem(r3, r4) r6 = PyObject_CallFunctionObjArgs(r5, r1, 0) r7 = __main__.globals :: static - r8 = 'a' + r8 = load_global CPyStatic_unicode_9 :: static ('a') r9 = CPyDict_GetItem(r7, r8) r10 = PyObject_CallFunctionObjArgs(r9, r6, 0) r0.d = r10; r11 = is_error - r12 = 'c' + r12 = load_global CPyStatic_unicode_10 :: static ('c') r13 = builtins :: module - r14 = 'print' + r14 = load_global CPyStatic_unicode_4 :: static ('print') r15 = CPyObject_GetAttr(r13, r14) r16 = PyObject_CallFunctionObjArgs(r15, r12, 0) r17 = r0.d @@ -3010,7 +3010,7 @@ r2 = r0 != r1 if r2 goto L2 else goto L1 :: bool L1: - r3 = 'builtins' + r3 = load_global CPyStatic_unicode_0 :: static ('builtins') r4 = PyImport_Import(r3) builtins = r4 :: module L2: @@ -3019,30 +3019,30 @@ r7 = r5 != r6 if r7 goto L4 else goto L3 :: bool L3: - r8 = 'typing' + r8 = load_global CPyStatic_unicode_1 :: static ('typing') r9 = PyImport_Import(r8) typing = r9 :: module L4: r10 = typing :: module r11 = __main__.globals :: static - r12 = 'Callable' + r12 = load_global CPyStatic_unicode_2 :: static ('Callable') r13 = CPyObject_GetAttr(r10, r12) - r14 = 'Callable' + r14 = load_global CPyStatic_unicode_2 :: static ('Callable') r15 = CPyDict_SetItem(r11, r14, r13) r16 = r15 >= 0 :: signed r17 = __main__.globals :: static - r18 = '__mypyc_c_decorator_helper__' + r18 = load_global CPyStatic_unicode_11 :: static ('__mypyc_c_decorator_helper__') r19 = CPyDict_GetItem(r17, r18) r20 = __main__.globals :: static - r21 = 'b' + r21 = load_global CPyStatic_unicode_8 :: static ('b') r22 = CPyDict_GetItem(r20, r21) r23 = PyObject_CallFunctionObjArgs(r22, r19, 0) r24 = __main__.globals :: static - r25 = 'a' + r25 = load_global CPyStatic_unicode_9 :: static ('a') r26 = CPyDict_GetItem(r24, r25) r27 = PyObject_CallFunctionObjArgs(r26, r23, 0) r28 = __main__.globals :: static - r29 = 'c' + r29 = load_global CPyStatic_unicode_10 :: static ('c') r30 = CPyDict_SetItem(r28, r29, r27) r31 = r30 >= 0 :: signed return 1 @@ -3087,16 +3087,16 @@ r0 = __mypyc_self__.__mypyc_env__ r1 = r0.g g = r1 - r2 = 'Entering' + r2 = load_global CPyStatic_unicode_3 :: static ('Entering') r3 = builtins :: module - r4 = 'print' + r4 = load_global CPyStatic_unicode_4 :: static ('print') r5 = CPyObject_GetAttr(r3, r4) r6 = PyObject_CallFunctionObjArgs(r5, r2, 0) r7 = r0.f r8 = PyObject_CallFunctionObjArgs(r7, 0) - r9 = 'Exited' + r9 = load_global CPyStatic_unicode_5 :: static ('Exited') r10 = builtins :: module - r11 = 'print' + r11 = load_global CPyStatic_unicode_4 :: static ('print') r12 = CPyObject_GetAttr(r10, r11) r13 = PyObject_CallFunctionObjArgs(r12, r9, 0) return 1 @@ -3135,7 +3135,7 @@ r2 = r0 != r1 if r2 goto L2 else goto L1 :: bool L1: - r3 = 'builtins' + r3 = load_global CPyStatic_unicode_0 :: static ('builtins') r4 = PyImport_Import(r3) builtins = r4 :: module L2: @@ -3144,15 +3144,15 @@ r7 = r5 != r6 if r7 goto L4 else goto L3 :: bool L3: - r8 = 'typing' + r8 = load_global CPyStatic_unicode_1 :: static ('typing') r9 = PyImport_Import(r8) typing = r9 :: module L4: r10 = typing :: module r11 = __main__.globals :: static - r12 = 'Callable' + r12 = load_global CPyStatic_unicode_2 :: static ('Callable') r13 = CPyObject_GetAttr(r10, r12) - r14 = 'Callable' + r14 = load_global CPyStatic_unicode_2 :: static ('Callable') r15 = CPyDict_SetItem(r11, r14, r13) r16 = r15 >= 0 :: signed return 1 @@ -3266,8 +3266,8 @@ r3 :: bit r4 :: object L0: - r0 = 'x' - r1 = '5' + r0 = load_global CPyStatic_unicode_5 :: static ('x') + r1 = load_global CPyStatic_unicode_6 :: static ('5') r2 = PyObject_SetAttr(x, r0, r1) r3 = r2 >= 0 :: signed r4 = box(None, 1) @@ -3314,10 +3314,10 @@ L0: if a goto L1 else goto L2 :: bool L1: - r0 = 'x' + r0 = load_global CPyStatic_unicode_3 :: static ('x') return r0 L2: - r1 = 'y' + r1 = load_global CPyStatic_unicode_4 :: static ('y') return r1 L3: unreachable @@ -3507,7 +3507,7 @@ r2, r3, r4 :: object L0: r0 = builtins :: module - r1 = 'reveal_type' + r1 = load_global CPyStatic_unicode_1 :: static ('reveal_type') r2 = CPyObject_GetAttr(r0, r1) r3 = box(int, x) r4 = PyObject_CallFunctionObjArgs(r2, r3, 0) @@ -3610,20 +3610,20 @@ r3 = r1 != r2 if r3 goto L2 else goto L1 :: bool L1: - r4 = 'p.m' + r4 = load_global CPyStatic_unicode_1 :: static ('p.m') r5 = PyImport_Import(r4) p.m = r5 :: module L2: r6 = PyImport_GetModuleDict() - r7 = 'p' + r7 = load_global CPyStatic_unicode_2 :: static ('p') r8 = CPyDict_GetItem(r6, r7) - r9 = 'p' + r9 = load_global CPyStatic_unicode_2 :: static ('p') r10 = CPyDict_SetItem(r0, r9, r8) r11 = r10 >= 0 :: signed r12 = PyImport_GetModuleDict() - r13 = 'p' + r13 = load_global CPyStatic_unicode_2 :: static ('p') r14 = CPyDict_GetItem(r12, r13) - r15 = 'x' + r15 = load_global CPyStatic_unicode_3 :: static ('x') r16 = CPyObject_GetAttr(r14, r15) r17 = unbox(int, r16) return r17
diff --git a/mypyc/test-data/irbuild-classes.test b/mypyc/test-data/irbuild-classes.test index 278b8c4..505a499 100644 --- a/mypyc/test-data/irbuild-classes.test +++ b/mypyc/test-data/irbuild-classes.test
@@ -83,7 +83,7 @@ r0 :: str r1 :: int L0: - r0 = 'hi' + r0 = load_global CPyStatic_unicode_4 :: static ('hi') r1 = a.f(2, r0) return 1 @@ -370,7 +370,7 @@ r2 = r0 != r1 if r2 goto L2 else goto L1 :: bool L1: - r3 = 'builtins' + r3 = load_global CPyStatic_unicode_0 :: static ('builtins') r4 = PyImport_Import(r3) builtins = r4 :: module L2: @@ -379,20 +379,20 @@ r7 = r5 != r6 if r7 goto L4 else goto L3 :: bool L3: - r8 = 'typing' + r8 = load_global CPyStatic_unicode_1 :: static ('typing') r9 = PyImport_Import(r8) typing = r9 :: module L4: r10 = typing :: module r11 = __main__.globals :: static - r12 = 'TypeVar' + r12 = load_global CPyStatic_unicode_2 :: static ('TypeVar') r13 = CPyObject_GetAttr(r10, r12) - r14 = 'TypeVar' + r14 = load_global CPyStatic_unicode_2 :: static ('TypeVar') r15 = CPyDict_SetItem(r11, r14, r13) r16 = r15 >= 0 :: signed - r17 = 'Generic' + r17 = load_global CPyStatic_unicode_3 :: static ('Generic') r18 = CPyObject_GetAttr(r10, r17) - r19 = 'Generic' + r19 = load_global CPyStatic_unicode_3 :: static ('Generic') r20 = CPyDict_SetItem(r11, r19, r18) r21 = r20 >= 0 :: signed r22 = mypy_extensions :: module @@ -400,75 +400,75 @@ r24 = r22 != r23 if r24 goto L6 else goto L5 :: bool L5: - r25 = 'mypy_extensions' + r25 = load_global CPyStatic_unicode_4 :: static ('mypy_extensions') r26 = PyImport_Import(r25) mypy_extensions = r26 :: module L6: r27 = mypy_extensions :: module r28 = __main__.globals :: static - r29 = 'trait' + r29 = load_global CPyStatic_unicode_5 :: static ('trait') r30 = CPyObject_GetAttr(r27, r29) - r31 = 'trait' + r31 = load_global CPyStatic_unicode_5 :: static ('trait') r32 = CPyDict_SetItem(r28, r31, r30) r33 = r32 >= 0 :: signed - r34 = 'T' + r34 = load_global CPyStatic_unicode_6 :: static ('T') r35 = __main__.globals :: static - r36 = 'TypeVar' + r36 = load_global CPyStatic_unicode_2 :: static ('TypeVar') r37 = CPyDict_GetItem(r35, r36) r38 = PyObject_CallFunctionObjArgs(r37, r34, 0) r39 = __main__.globals :: static - r40 = 'T' + r40 = load_global CPyStatic_unicode_6 :: static ('T') r41 = CPyDict_SetItem(r39, r40, r38) r42 = r41 >= 0 :: signed r43 = <error> :: object - r44 = '__main__' + r44 = load_global CPyStatic_unicode_7 :: static ('__main__') r45 = __main__.C_template :: type r46 = CPyType_FromTemplate(r45, r43, r44) r47 = C_trait_vtable_setup() - r48 = '__mypyc_attrs__' + r48 = load_global CPyStatic_unicode_8 :: static ('__mypyc_attrs__') r49 = PyTuple_Pack(0) r50 = PyObject_SetAttr(r46, r48, r49) r51 = r50 >= 0 :: signed __main__.C = r46 :: type r52 = __main__.globals :: static - r53 = 'C' + r53 = load_global CPyStatic_unicode_9 :: static ('C') r54 = CPyDict_SetItem(r52, r53, r46) r55 = r54 >= 0 :: signed r56 = <error> :: object - r57 = '__main__' + r57 = load_global CPyStatic_unicode_7 :: static ('__main__') r58 = __main__.S_template :: type r59 = CPyType_FromTemplate(r58, r56, r57) - r60 = '__mypyc_attrs__' + r60 = load_global CPyStatic_unicode_8 :: static ('__mypyc_attrs__') r61 = PyTuple_Pack(0) r62 = PyObject_SetAttr(r59, r60, r61) r63 = r62 >= 0 :: signed __main__.S = r59 :: type r64 = __main__.globals :: static - r65 = 'S' + r65 = load_global CPyStatic_unicode_10 :: static ('S') r66 = CPyDict_SetItem(r64, r65, r59) r67 = r66 >= 0 :: signed r68 = __main__.C :: type r69 = __main__.S :: type r70 = __main__.globals :: static - r71 = 'Generic' + r71 = load_global CPyStatic_unicode_3 :: static ('Generic') r72 = CPyDict_GetItem(r70, r71) r73 = __main__.globals :: static - r74 = 'T' + r74 = load_global CPyStatic_unicode_6 :: static ('T') r75 = CPyDict_GetItem(r73, r74) r76 = PyObject_GetItem(r72, r75) r77 = PyTuple_Pack(3, r68, r69, r76) - r78 = '__main__' + r78 = load_global CPyStatic_unicode_7 :: static ('__main__') r79 = __main__.D_template :: type r80 = CPyType_FromTemplate(r79, r77, r78) r81 = D_trait_vtable_setup() - r82 = '__mypyc_attrs__' - r83 = '__dict__' + r82 = load_global CPyStatic_unicode_8 :: static ('__mypyc_attrs__') + r83 = load_global CPyStatic_unicode_11 :: static ('__dict__') r84 = PyTuple_Pack(1, r83) r85 = PyObject_SetAttr(r80, r82, r84) r86 = r85 >= 0 :: signed __main__.D = r80 :: type r87 = __main__.globals :: static - r88 = 'D' + r88 = load_global CPyStatic_unicode_12 :: static ('D') r89 = CPyDict_SetItem(r87, r88, r80) r90 = r89 >= 0 :: signed return 1 @@ -792,7 +792,7 @@ r3 :: int L0: r0 = __main__.A :: type - r1 = 'x' + r1 = load_global CPyStatic_unicode_6 :: static ('x') r2 = CPyObject_GetAttr(r0, r1) r3 = unbox(int, r2) return r3 @@ -958,7 +958,7 @@ r1 :: object r2 :: bool L0: - r0 = '__ne__' + r0 = load_global CPyStatic_unicode_1 :: static ('__ne__') r1 = CPyObject_CallMethodObjArgs(a, r0, b, 0) r2 = unbox(bool, r1) return r2 @@ -1029,7 +1029,7 @@ L0: __mypyc_self__.x = 20; r0 = is_error r1 = __main__.globals :: static - r2 = 'LOL' + r2 = load_global CPyStatic_unicode_9 :: static ('LOL') r3 = CPyDict_GetItem(r1, r2) r4 = cast(str, r3) __mypyc_self__.y = r4; r5 = is_error
diff --git a/mypyc/test-data/irbuild-dict.test b/mypyc/test-data/irbuild-dict.test index 5a127ff..ba0c7a8 100644 --- a/mypyc/test-data/irbuild-dict.test +++ b/mypyc/test-data/irbuild-dict.test
@@ -52,7 +52,7 @@ r1, r2 :: object r3, d :: dict L0: - r0 = '' + r0 = load_global CPyStatic_unicode_1 :: static r1 = box(short_int, 2) r2 = box(short_int, 4) r3 = CPyDict_Build(2, r1, r2, r0, x) @@ -194,7 +194,7 @@ r6 :: int32 r7 :: bit L0: - r0 = 'z' + r0 = load_global CPyStatic_unicode_3 :: static ('z') r1 = box(short_int, 4) r2 = CPyDict_Build(1, x, r1) r3 = CPyDict_UpdateInDisplay(r2, y)
diff --git a/mypyc/test-data/irbuild-nested.test b/mypyc/test-data/irbuild-nested.test index c5de7d6..d531a03 100644 --- a/mypyc/test-data/irbuild-nested.test +++ b/mypyc/test-data/irbuild-nested.test
@@ -93,7 +93,7 @@ r1 = r0.__mypyc_env__ r2 = r0.second second = r2 - r3 = 'b.first.second: nested function' + r3 = load_global CPyStatic_unicode_3 :: static ('b.first.second: nested function') return r3 def first_b_obj.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object @@ -163,7 +163,7 @@ r0 = __mypyc_self__.__mypyc_env__ r1 = r0.inner inner = r1 - r2 = '!' + r2 = load_global CPyStatic_unicode_4 :: static ('!') r3 = PyUnicode_Concat(s, r2) return r3 def c(num): @@ -202,7 +202,7 @@ r0 = __mypyc_self__.__mypyc_env__ r1 = r0.inner inner = r1 - r2 = '?' + r2 = load_global CPyStatic_unicode_5 :: static ('?') r3 = PyUnicode_Concat(s, r2) return r3 def d(num): @@ -220,12 +220,12 @@ r1 = inner_d_obj() r1.__mypyc_env__ = r0; r2 = is_error r0.inner = r1; r3 = is_error - r4 = 'one' + r4 = load_global CPyStatic_unicode_6 :: static ('one') r5 = r0.inner r6 = PyObject_CallFunctionObjArgs(r5, r4, 0) r7 = cast(str, r6) a = r7 - r8 = 'two' + r8 = load_global CPyStatic_unicode_7 :: static ('two') r9 = r0.inner r10 = PyObject_CallFunctionObjArgs(r9, r8, 0) r11 = cast(str, r10) @@ -234,17 +234,17 @@ def inner(): r0 :: str L0: - r0 = 'inner: normal function' + r0 = load_global CPyStatic_unicode_8 :: static ('inner: normal function') return r0 def first(): r0 :: str L0: - r0 = 'first: normal function' + r0 = load_global CPyStatic_unicode_9 :: static ('first: normal function') return r0 def second(): r0 :: str L0: - r0 = 'second: normal function' + r0 = load_global CPyStatic_unicode_10 :: static ('second: normal function') return r0 [case testFreeVars] @@ -384,7 +384,7 @@ r0 = __mypyc_self__.__mypyc_env__ r1 = r0.inner inner = r1 - r2 = 'f.inner: first definition' + r2 = load_global CPyStatic_unicode_3 :: static ('f.inner: first definition') return r2 def inner_c_obj_0.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object @@ -408,7 +408,7 @@ r0 = __mypyc_self__.__mypyc_env__ r1 = r0.inner inner = r1 - r2 = 'f.inner: second definition' + r2 = load_global CPyStatic_unicode_4 :: static ('f.inner: second definition') return r2 def c(flag): flag :: bool @@ -565,7 +565,7 @@ r0 = __mypyc_self__.__mypyc_env__ r1 = r0.inner inner = r1 - r2 = 'f.inner: first definition' + r2 = load_global CPyStatic_unicode_1 :: static ('f.inner: first definition') return r2 def inner_f_obj_0.__get__(__mypyc_self__, instance, owner): __mypyc_self__, instance, owner, r0 :: object @@ -589,7 +589,7 @@ r0 = __mypyc_self__.__mypyc_env__ r1 = r0.inner inner = r1 - r2 = 'f.inner: second definition' + r2 = load_global CPyStatic_unicode_2 :: static ('f.inner: second definition') return r2 def f(flag): flag :: bool
diff --git a/mypyc/test-data/irbuild-optional.test b/mypyc/test-data/irbuild-optional.test index ab7890f..20a9ce3 100644 --- a/mypyc/test-data/irbuild-optional.test +++ b/mypyc/test-data/irbuild-optional.test
@@ -341,7 +341,7 @@ r1 :: int32 r2 :: bit L0: - r0 = 'a' + r0 = load_global CPyStatic_unicode_5 :: static ('a') r1 = PyObject_SetAttr(o, r0, s) r2 = r1 >= 0 :: signed return 1 @@ -471,7 +471,7 @@ goto L3 L2: r7 = o - r8 = 'x' + r8 = load_global CPyStatic_unicode_7 :: static ('x') r9 = CPyObject_GetAttr(r7, r8) r10 = unbox(int, r9) r6 = r10 @@ -502,7 +502,7 @@ goto L3 L2: r7 = o - r8 = 'x' + r8 = load_global CPyStatic_unicode_7 :: static ('x') r9 = CPyObject_GetAttr(r7, r8) r10 = unbox(int, r9) r6 = r10 @@ -530,9 +530,8 @@ r2, r3 :: object L0: r0 = o - r1 = 'x' + r1 = load_global CPyStatic_unicode_6 :: static ('x') r2 = CPyObject_GetAttr(r0, r1) r3 = r2 L1: return 1 -
diff --git a/mypyc/test-data/irbuild-statements.test b/mypyc/test-data/irbuild-statements.test index de8521d..490da2a 100644 --- a/mypyc/test-data/irbuild-statements.test +++ b/mypyc/test-data/irbuild-statements.test
@@ -737,7 +737,7 @@ if r5 goto L3 else goto L2 :: bool L2: r6 = builtins :: module - r7 = 'AssertionError' + r7 = load_global CPyStatic_unicode_3 :: static ('AssertionError') r8 = CPyObject_GetAttr(r6, r7) r9 = PyObject_CallFunctionObjArgs(r8, s, 0) CPy_Raise(r9) @@ -841,13 +841,13 @@ r6 :: int32 r7 :: bit L0: - r0 = 'one' - r1 = 'two' + r0 = load_global CPyStatic_unicode_1 :: static ('one') + r1 = load_global CPyStatic_unicode_2 :: static ('two') r2 = box(short_int, 2) r3 = box(short_int, 4) r4 = CPyDict_Build(2, r0, r2, r1, r3) d = r4 - r5 = 'one' + r5 = load_global CPyStatic_unicode_1 :: static ('one') r6 = PyObject_DelItem(d, r5) r7 = r6 >= 0 :: signed return 1 @@ -861,18 +861,18 @@ r13 :: int32 r14 :: bit L0: - r0 = 'one' - r1 = 'two' - r2 = 'three' - r3 = 'four' + r0 = load_global CPyStatic_unicode_1 :: static ('one') + r1 = load_global CPyStatic_unicode_2 :: static ('two') + r2 = load_global CPyStatic_unicode_3 :: static ('three') + r3 = load_global CPyStatic_unicode_4 :: static ('four') r4 = box(short_int, 2) r5 = box(short_int, 4) r6 = box(short_int, 6) r7 = box(short_int, 8) r8 = CPyDict_Build(4, r0, r4, r1, r5, r2, r6, r3, r7) d = r8 - r9 = 'one' - r10 = 'four' + r9 = load_global CPyStatic_unicode_1 :: static ('one') + r10 = load_global CPyStatic_unicode_4 :: static ('four') r11 = PyObject_DelItem(d, r9) r12 = r11 >= 0 :: signed r13 = PyObject_DelItem(d, r10) @@ -907,7 +907,7 @@ L0: r0 = Dummy(2, 4) dummy = r0 - r1 = 'x' + r1 = load_global CPyStatic_unicode_3 :: static ('x') r2 = PyObject_DelAttr(dummy, r1) r3 = r2 >= 0 :: signed return 1 @@ -922,10 +922,10 @@ L0: r0 = Dummy(2, 4) dummy = r0 - r1 = 'x' + r1 = load_global CPyStatic_unicode_3 :: static ('x') r2 = PyObject_DelAttr(dummy, r1) r3 = r2 >= 0 :: signed - r4 = 'y' + r4 = load_global CPyStatic_unicode_4 :: static ('y') r5 = PyObject_DelAttr(dummy, r4) r6 = r5 >= 0 :: signed return 1
diff --git a/mypyc/test-data/irbuild-try.test b/mypyc/test-data/irbuild-try.test index d1119c5..7d68040 100644 --- a/mypyc/test-data/irbuild-try.test +++ b/mypyc/test-data/irbuild-try.test
@@ -18,15 +18,15 @@ L0: L1: r0 = builtins :: module - r1 = 'object' + r1 = load_global CPyStatic_unicode_1 :: static ('object') r2 = CPyObject_GetAttr(r0, r1) r3 = PyObject_CallFunctionObjArgs(r2, 0) goto L5 L2: (handler for L1) r4 = CPy_CatchError() - r5 = 'weeee' + r5 = load_global CPyStatic_unicode_2 :: static ('weeee') r6 = builtins :: module - r7 = 'print' + r7 = load_global CPyStatic_unicode_3 :: static ('print') r8 = CPyObject_GetAttr(r6, r7) r9 = PyObject_CallFunctionObjArgs(r8, r5, 0) L3: @@ -66,20 +66,20 @@ if b goto L2 else goto L3 :: bool L2: r0 = builtins :: module - r1 = 'object' + r1 = load_global CPyStatic_unicode_1 :: static ('object') r2 = CPyObject_GetAttr(r0, r1) r3 = PyObject_CallFunctionObjArgs(r2, 0) goto L4 L3: - r4 = 'hi' + r4 = load_global CPyStatic_unicode_2 :: static ('hi') r5 = PyObject_Str(r4) L4: goto L8 L5: (handler for L1, L2, L3, L4) r6 = CPy_CatchError() - r7 = 'weeee' + r7 = load_global CPyStatic_unicode_3 :: static ('weeee') r8 = builtins :: module - r9 = 'print' + r9 = load_global CPyStatic_unicode_4 :: static ('print') r10 = CPyObject_GetAttr(r8, r9) r11 = PyObject_CallFunctionObjArgs(r10, r7, 0) L6: @@ -129,30 +129,30 @@ r27 :: bit L0: L1: - r0 = 'a' + r0 = load_global CPyStatic_unicode_1 :: static ('a') r1 = builtins :: module - r2 = 'print' + r2 = load_global CPyStatic_unicode_2 :: static ('print') r3 = CPyObject_GetAttr(r1, r2) r4 = PyObject_CallFunctionObjArgs(r3, r0, 0) L2: r5 = builtins :: module - r6 = 'object' + r6 = load_global CPyStatic_unicode_3 :: static ('object') r7 = CPyObject_GetAttr(r5, r6) r8 = PyObject_CallFunctionObjArgs(r7, 0) goto L8 L3: (handler for L2) r9 = CPy_CatchError() r10 = builtins :: module - r11 = 'AttributeError' + r11 = load_global CPyStatic_unicode_4 :: static ('AttributeError') r12 = CPyObject_GetAttr(r10, r11) r13 = CPy_ExceptionMatches(r12) if r13 goto L4 else goto L5 :: bool L4: r14 = CPy_GetExcValue() e = r14 - r15 = 'b' + r15 = load_global CPyStatic_unicode_5 :: static ('b') r16 = builtins :: module - r17 = 'print' + r17 = load_global CPyStatic_unicode_2 :: static ('print') r18 = CPyObject_GetAttr(r16, r17) r19 = PyObject_CallFunctionObjArgs(r18, r15, e, 0) goto L6 @@ -170,9 +170,9 @@ goto L12 L9: (handler for L1, L6, L7, L8) r21 = CPy_CatchError() - r22 = 'weeee' + r22 = load_global CPyStatic_unicode_6 :: static ('weeee') r23 = builtins :: module - r24 = 'print' + r24 = load_global CPyStatic_unicode_2 :: static ('print') r25 = CPyObject_GetAttr(r23, r24) r26 = PyObject_CallFunctionObjArgs(r25, r22, 0) L10: @@ -218,27 +218,27 @@ L2: (handler for L1) r0 = CPy_CatchError() r1 = builtins :: module - r2 = 'KeyError' + r2 = load_global CPyStatic_unicode_1 :: static ('KeyError') r3 = CPyObject_GetAttr(r1, r2) r4 = CPy_ExceptionMatches(r3) if r4 goto L3 else goto L4 :: bool L3: - r5 = 'weeee' + r5 = load_global CPyStatic_unicode_2 :: static ('weeee') r6 = builtins :: module - r7 = 'print' + r7 = load_global CPyStatic_unicode_3 :: static ('print') r8 = CPyObject_GetAttr(r6, r7) r9 = PyObject_CallFunctionObjArgs(r8, r5, 0) goto L7 L4: r10 = builtins :: module - r11 = 'IndexError' + r11 = load_global CPyStatic_unicode_4 :: static ('IndexError') r12 = CPyObject_GetAttr(r10, r11) r13 = CPy_ExceptionMatches(r12) if r13 goto L5 else goto L6 :: bool L5: - r14 = 'yo' + r14 = load_global CPyStatic_unicode_5 :: static ('yo') r15 = builtins :: module - r16 = 'print' + r16 = load_global CPyStatic_unicode_3 :: static ('print') r17 = CPyObject_GetAttr(r15, r16) r18 = PyObject_CallFunctionObjArgs(r17, r14, 0) goto L7 @@ -279,9 +279,9 @@ L1: if b goto L2 else goto L3 :: bool L2: - r0 = 'hi' + r0 = load_global CPyStatic_unicode_1 :: static ('hi') r1 = builtins :: module - r2 = 'Exception' + r2 = load_global CPyStatic_unicode_2 :: static ('Exception') r3 = CPyObject_GetAttr(r1, r2) r4 = PyObject_CallFunctionObjArgs(r3, r0, 0) CPy_Raise(r4) @@ -296,9 +296,9 @@ r7 = CPy_CatchError() r6 = r7 L7: - r8 = 'finally' + r8 = load_global CPyStatic_unicode_3 :: static ('finally') r9 = builtins :: module - r10 = 'print' + r10 = load_global CPyStatic_unicode_4 :: static ('print') r11 = CPyObject_GetAttr(r9, r10) r12 = PyObject_CallFunctionObjArgs(r11, r8, 0) if is_error(r6) goto L9 else goto L8 @@ -347,18 +347,18 @@ L0: r0 = PyObject_CallFunctionObjArgs(x, 0) r1 = PyObject_Type(r0) - r2 = '__exit__' + r2 = load_global CPyStatic_unicode_3 :: static ('__exit__') r3 = CPyObject_GetAttr(r1, r2) - r4 = '__enter__' + r4 = load_global CPyStatic_unicode_4 :: static ('__enter__') r5 = CPyObject_GetAttr(r1, r4) r6 = PyObject_CallFunctionObjArgs(r5, r0, 0) r7 = 1 L1: L2: y = r6 - r8 = 'hello' + r8 = load_global CPyStatic_unicode_5 :: static ('hello') r9 = builtins :: module - r10 = 'print' + r10 = load_global CPyStatic_unicode_6 :: static ('print') r11 = CPyObject_GetAttr(r9, r10) r12 = PyObject_CallFunctionObjArgs(r11, r8, 0) goto L8 @@ -415,4 +415,3 @@ unreachable L20: return 1 -
diff --git a/mypyc/test-data/refcount.test b/mypyc/test-data/refcount.test index 804e1da..7134529 100644 --- a/mypyc/test-data/refcount.test +++ b/mypyc/test-data/refcount.test
@@ -661,7 +661,7 @@ def f(): r0 :: str L0: - r0 = 'some string' + r0 = load_global CPyStatic_unicode_1 :: static ('some string') inc_ref r0 return r0 @@ -680,7 +680,7 @@ r6 :: int L0: r0 = load_address PyLong_Type - r1 = 'base' + r1 = load_global CPyStatic_unicode_1 :: static ('base') r2 = PyTuple_Pack(1, x) r3 = box(short_int, 4) r4 = CPyDict_Build(1, r1, r3)
diff --git a/mypyc/test-data/run-misc.test b/mypyc/test-data/run-misc.test index cc9ef44..cdfa7da 100644 --- a/mypyc/test-data/run-misc.test +++ b/mypyc/test-data/run-misc.test
@@ -1014,43 +1014,3 @@ assert foo(None) == None assert foo([1, 2, 3]) == ((1, 2, 3), [1, 2, 3]) - -[case testAllLiterals] -# Test having all sorts of literals in a single file - -def test_str() -> None: - assert '' == eval("''") - assert len('foo bar' + str()) == 7 - assert 'foo bar' == eval("'foo bar'") - assert 'foo\u1245\0bar' == eval("'foo' + chr(0x1245) + chr(0) + 'bar'") - assert 'foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345' == eval("'foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345'") - assert 'Zoobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar123' == eval("'Zoobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar123'") - -def test_bytes() -> None: - assert b'' == eval("b''") - assert b'foo bar' == eval("b'foo bar'") - assert b'\xafde' == eval(r"b'\xafde'") - assert b'foo\xde\0bar' == eval("b'foo' + bytes([0xde, 0]) + b'bar'") - assert b'foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345' == eval("b'foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345'") - -def test_int() -> None: - assert 2875872359823758923758923759 == eval('2875872359823758923758923759') - assert -552875872359823758923758923759 == eval('-552875872359823758923758923759') - -def test_float() -> None: - assert 1.5 == eval('1.5') - assert -3.75 == eval('-3.75') - assert 2.5e10 == eval('2.5e10') - assert 2.5e50 == eval('2.5e50') - assert 2.5e1000 == eval('2.5e1000') - assert -2.5e1000 == eval('-2.5e1000') - -def test_complex() -> None: - assert 1.5j == eval('1.5j') - assert 1.5j + 2.5 == eval('2.5 + 1.5j') - assert -3.75j == eval('-3.75j') - assert 2.5e10j == eval('2.5e10j') - assert 2.5e50j == eval('2.5e50j') - assert 2.5e1000j == eval('2.5e1000j') - assert 2.5e1000j + 3.5e2000 == eval('3.5e2000 + 2.5e1000j') - assert -2.5e1000j == eval('-2.5e1000j')
diff --git a/mypyc/test-data/run-primitives.test b/mypyc/test-data/run-primitives.test index 9611c0c..450480d 100644 --- a/mypyc/test-data/run-primitives.test +++ b/mypyc/test-data/run-primitives.test
@@ -241,7 +241,7 @@ return int(x) def get_complex() -> complex: - return 5.2j + 3.5 + 1j + return 5.0j + 3.0 [file driver.py] from native import assign_and_return_float_sum, from_int, to_int, get_complex @@ -253,7 +253,7 @@ assert str(from_int(10)) == '10.0' assert str(to_int(3.14)) == '3' assert str(to_int(3)) == '3' -assert get_complex() == 3.5 + 6.2j +assert get_complex() == 3+5j [case testBytes] def f(x: bytes) -> bytes:
diff --git a/mypyc/test/test_literals.py b/mypyc/test/test_literals.py deleted file mode 100644 index a9a6c51..0000000 --- a/mypyc/test/test_literals.py +++ /dev/null
@@ -1,14 +0,0 @@ -"""Test code geneneration for literals.""" - -import unittest - -from mypyc.codegen.literals import format_str_literal - - -class TestLiterals(unittest.TestCase): - def test_format_str_literal(self) -> None: - assert format_str_literal('') == b'\x00' - assert format_str_literal('xyz') == b'\x03xyz' - assert format_str_literal('x' * 127) == b'\x7f' + b'x' * 127 - assert format_str_literal('x' * 128) == b'\x81\x00' + b'x' * 128 - assert format_str_literal('x' * 131) == b'\x81\x03' + b'x' * 131