Author: Armin Rigo <[email protected]>
Branch: py3.5-newtext
Changeset: r89203:5050884b7a39
Date: 2016-12-20 15:16 +0100
http://bitbucket.org/pypy/pypy/changeset/5050884b7a39/
Log: hg merge 1fb2fca52214, regenerate ast.py
diff --git a/pypy/interpreter/astcompiler/ast.py
b/pypy/interpreter/astcompiler/ast.py
--- a/pypy/interpreter/astcompiler/ast.py
+++ b/pypy/interpreter/astcompiler/ast.py
@@ -66,14 +66,14 @@
if w_dict is None:
w_dict = space.newdict()
w_type = space.type(self)
- w_fields = space.getattr(w_type, space.wrap("_fields"))
+ w_fields = space.getattr(w_type, space.newtext("_fields"))
for w_name in space.fixedview(w_fields):
try:
space.setitem(w_dict, w_name,
space.getattr(self, w_name))
except OperationError:
pass
- w_attrs = space.findattr(w_type, space.wrap("_attributes"))
+ w_attrs = space.findattr(w_type, space.newtext("_attributes"))
if w_attrs:
for w_name in space.fixedview(w_attrs):
try:
@@ -92,12 +92,12 @@
def W_AST_new(space, w_type, __args__):
node = space.allocate_instance(W_AST, w_type)
- return space.wrap(node)
+ return node
def W_AST_init(space, w_self, __args__):
args_w, kwargs_w = __args__.unpack()
fields_w = space.fixedview(space.getattr(space.type(w_self),
- space.wrap("_fields")))
+ space.newtext("_fields")))
num_fields = len(fields_w) if fields_w else 0
if args_w and len(args_w) != num_fields:
if num_fields == 0:
@@ -113,7 +113,7 @@
for i, w_field in enumerate(fields_w):
space.setattr(w_self, w_field, args_w[i])
for field, w_value in kwargs_w.iteritems():
- space.setattr(w_self, space.wrap(field), w_value)
+ space.setattr(w_self, space.newtext(field), w_value)
W_AST.typedef = typedef.TypeDef("_ast.AST",
@@ -142,16 +142,16 @@
def make_new_type(self, space, name, base, fields, attributes):
w_base = getattr(self, 'w_%s' % base)
w_dict = space.newdict()
- space.setitem_str(w_dict, '__module__', space.wrap('_ast'))
+ space.setitem_str(w_dict, '__module__', space.newtext('_ast'))
if fields is not None:
space.setitem_str(w_dict, "_fields",
- space.newtuple([space.wrap(f) for f in fields]))
+ space.newtuple([space.newtext(f) for f in
fields]))
if attributes is not None:
space.setitem_str(w_dict, "_attributes",
- space.newtuple([space.wrap(a) for a in
attributes]))
+ space.newtuple([space.newtext(a) for a in
attributes]))
w_type = space.call_function(
space.w_type,
- space.wrap(name), space.newtuple([w_base]), w_dict)
+ space.newtext(name), space.newtuple([w_base]), w_dict)
setattr(self, 'w_%s' % name, w_type)
def get(space):
@@ -194,7 +194,7 @@
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
return w_node
@staticmethod
@@ -227,7 +227,7 @@
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
return w_node
@staticmethod
@@ -255,7 +255,7 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Expression)
w_body = self.body.to_object(space) # expr
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
return w_node
@staticmethod
@@ -289,7 +289,7 @@
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
return w_node
@staticmethod
@@ -389,28 +389,28 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_FunctionDef)
- w_name = space.wrap(self.name.decode('utf-8')) # identifier
- space.setattr(w_node, space.wrap('name'), w_name)
+ w_name = space.newtext(self.name) # identifier
+ space.setattr(w_node, space.newtext('name'), w_name)
w_args = self.args.to_object(space) # arguments
- space.setattr(w_node, space.wrap('args'), w_args)
+ space.setattr(w_node, space.newtext('args'), w_args)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.decorator_list is None:
decorator_list_w = []
else:
decorator_list_w = [node.to_object(space) for node in
self.decorator_list] # expr
w_decorator_list = space.newlist(decorator_list_w)
- space.setattr(w_node, space.wrap('decorator_list'), w_decorator_list)
+ space.setattr(w_node, space.newtext('decorator_list'),
w_decorator_list)
w_returns = self.returns.to_object(space) if self.returns is not None
else space.w_None # expr
- space.setattr(w_node, space.wrap('returns'), w_returns)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('returns'), w_returns)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -465,28 +465,28 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_AsyncFunctionDef)
- w_name = space.wrap(self.name.decode('utf-8')) # identifier
- space.setattr(w_node, space.wrap('name'), w_name)
+ w_name = space.newtext(self.name) # identifier
+ space.setattr(w_node, space.newtext('name'), w_name)
w_args = self.args.to_object(space) # arguments
- space.setattr(w_node, space.wrap('args'), w_args)
+ space.setattr(w_node, space.newtext('args'), w_args)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.decorator_list is None:
decorator_list_w = []
else:
decorator_list_w = [node.to_object(space) for node in
self.decorator_list] # expr
w_decorator_list = space.newlist(decorator_list_w)
- space.setattr(w_node, space.wrap('decorator_list'), w_decorator_list)
+ space.setattr(w_node, space.newtext('decorator_list'),
w_decorator_list)
w_returns = self.returns.to_object(space) if self.returns is not None
else space.w_None # expr
- space.setattr(w_node, space.wrap('returns'), w_returns)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('returns'), w_returns)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -542,36 +542,36 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_ClassDef)
- w_name = space.wrap(self.name.decode('utf-8')) # identifier
- space.setattr(w_node, space.wrap('name'), w_name)
+ w_name = space.newtext(self.name) # identifier
+ space.setattr(w_node, space.newtext('name'), w_name)
if self.bases is None:
bases_w = []
else:
bases_w = [node.to_object(space) for node in self.bases] # expr
w_bases = space.newlist(bases_w)
- space.setattr(w_node, space.wrap('bases'), w_bases)
+ space.setattr(w_node, space.newtext('bases'), w_bases)
if self.keywords is None:
keywords_w = []
else:
keywords_w = [node.to_object(space) for node in self.keywords] #
keyword
w_keywords = space.newlist(keywords_w)
- space.setattr(w_node, space.wrap('keywords'), w_keywords)
+ space.setattr(w_node, space.newtext('keywords'), w_keywords)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.decorator_list is None:
decorator_list_w = []
else:
decorator_list_w = [node.to_object(space) for node in
self.decorator_list] # expr
w_decorator_list = space.newlist(decorator_list_w)
- space.setattr(w_node, space.wrap('decorator_list'), w_decorator_list)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('decorator_list'),
w_decorator_list)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -618,11 +618,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Return)
w_value = self.value.to_object(space) if self.value is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -659,11 +659,11 @@
else:
targets_w = [node.to_object(space) for node in self.targets] # expr
w_targets = space.newlist(targets_w)
- space.setattr(w_node, space.wrap('targets'), w_targets)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('targets'), w_targets)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -703,13 +703,13 @@
else:
targets_w = [node.to_object(space) for node in self.targets] # expr
w_targets = space.newlist(targets_w)
- space.setattr(w_node, space.wrap('targets'), w_targets)
+ space.setattr(w_node, space.newtext('targets'), w_targets)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -749,15 +749,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_AugAssign)
w_target = self.target.to_object(space) # expr
- space.setattr(w_node, space.wrap('target'), w_target)
+ space.setattr(w_node, space.newtext('target'), w_target)
w_op = operator_to_class[self.op - 1]().to_object(space) # operator
- space.setattr(w_node, space.wrap('op'), w_op)
+ space.setattr(w_node, space.newtext('op'), w_op)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -807,25 +807,25 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_For)
w_target = self.target.to_object(space) # expr
- space.setattr(w_node, space.wrap('target'), w_target)
+ space.setattr(w_node, space.newtext('target'), w_target)
w_iter = self.iter.to_object(space) # expr
- space.setattr(w_node, space.wrap('iter'), w_iter)
+ space.setattr(w_node, space.newtext('iter'), w_iter)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.orelse is None:
orelse_w = []
else:
orelse_w = [node.to_object(space) for node in self.orelse] # stmt
w_orelse = space.newlist(orelse_w)
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -877,25 +877,25 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_AsyncFor)
w_target = self.target.to_object(space) # expr
- space.setattr(w_node, space.wrap('target'), w_target)
+ space.setattr(w_node, space.newtext('target'), w_target)
w_iter = self.iter.to_object(space) # expr
- space.setattr(w_node, space.wrap('iter'), w_iter)
+ space.setattr(w_node, space.newtext('iter'), w_iter)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.orelse is None:
orelse_w = []
else:
orelse_w = [node.to_object(space) for node in self.orelse] # stmt
w_orelse = space.newlist(orelse_w)
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -945,23 +945,23 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_While)
w_test = self.test.to_object(space) # expr
- space.setattr(w_node, space.wrap('test'), w_test)
+ space.setattr(w_node, space.newtext('test'), w_test)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.orelse is None:
orelse_w = []
else:
orelse_w = [node.to_object(space) for node in self.orelse] # stmt
w_orelse = space.newlist(orelse_w)
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1007,23 +1007,23 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_If)
w_test = self.test.to_object(space) # expr
- space.setattr(w_node, space.wrap('test'), w_test)
+ space.setattr(w_node, space.newtext('test'), w_test)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.orelse is None:
orelse_w = []
else:
orelse_w = [node.to_object(space) for node in self.orelse] # stmt
w_orelse = space.newlist(orelse_w)
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1071,17 +1071,17 @@
else:
items_w = [node.to_object(space) for node in self.items] # withitem
w_items = space.newlist(items_w)
- space.setattr(w_node, space.wrap('items'), w_items)
+ space.setattr(w_node, space.newtext('items'), w_items)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('body'), w_body)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1125,17 +1125,17 @@
else:
items_w = [node.to_object(space) for node in self.items] # withitem
w_items = space.newlist(items_w)
- space.setattr(w_node, space.wrap('items'), w_items)
+ space.setattr(w_node, space.newtext('items'), w_items)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('body'), w_body)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1175,13 +1175,13 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Raise)
w_exc = self.exc.to_object(space) if self.exc is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('exc'), w_exc)
+ space.setattr(w_node, space.newtext('exc'), w_exc)
w_cause = self.cause.to_object(space) if self.cause is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('cause'), w_cause)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('cause'), w_cause)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1229,29 +1229,29 @@
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
if self.handlers is None:
handlers_w = []
else:
handlers_w = [node.to_object(space) for node in self.handlers] #
excepthandler
w_handlers = space.newlist(handlers_w)
- space.setattr(w_node, space.wrap('handlers'), w_handlers)
+ space.setattr(w_node, space.newtext('handlers'), w_handlers)
if self.orelse is None:
orelse_w = []
else:
orelse_w = [node.to_object(space) for node in self.orelse] # stmt
w_orelse = space.newlist(orelse_w)
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
if self.finalbody is None:
finalbody_w = []
else:
finalbody_w = [node.to_object(space) for node in self.finalbody] #
stmt
w_finalbody = space.newlist(finalbody_w)
- space.setattr(w_node, space.wrap('finalbody'), w_finalbody)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('finalbody'), w_finalbody)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1296,13 +1296,13 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Assert)
w_test = self.test.to_object(space) # expr
- space.setattr(w_node, space.wrap('test'), w_test)
+ space.setattr(w_node, space.newtext('test'), w_test)
w_msg = self.msg.to_object(space) if self.msg is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('msg'), w_msg)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('msg'), w_msg)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1343,11 +1343,11 @@
else:
names_w = [node.to_object(space) for node in self.names] # alias
w_names = space.newlist(names_w)
- space.setattr(w_node, space.wrap('names'), w_names)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('names'), w_names)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1382,20 +1382,20 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_ImportFrom)
- w_module = space.wrap(self.module.decode('utf-8')) if self.module is
not None else space.w_None # identifier
- space.setattr(w_node, space.wrap('module'), w_module)
+ w_module = space.newtext(self.module) if self.module is not None else
space.w_None # identifier
+ space.setattr(w_node, space.newtext('module'), w_module)
if self.names is None:
names_w = []
else:
names_w = [node.to_object(space) for node in self.names] # alias
w_names = space.newlist(names_w)
- space.setattr(w_node, space.wrap('names'), w_names)
- w_level = space.wrap(self.level) # int
- space.setattr(w_node, space.wrap('level'), w_level)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('names'), w_names)
+ w_level = space.newint(self.level) # int
+ space.setattr(w_node, space.newtext('level'), w_level)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1433,13 +1433,13 @@
if self.names is None:
names_w = []
else:
- names_w = [space.wrap(node.decode('utf-8')) for node in
self.names] # identifier
+ names_w = [space.newtext(node) for node in self.names] # identifier
w_names = space.newlist(names_w)
- space.setattr(w_node, space.wrap('names'), w_names)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('names'), w_names)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1473,13 +1473,13 @@
if self.names is None:
names_w = []
else:
- names_w = [space.wrap(node.decode('utf-8')) for node in
self.names] # identifier
+ names_w = [space.newtext(node) for node in self.names] # identifier
w_names = space.newlist(names_w)
- space.setattr(w_node, space.wrap('names'), w_names)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('names'), w_names)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1512,11 +1512,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Expr)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1547,10 +1547,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Pass)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1577,10 +1577,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Break)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1607,10 +1607,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Continue)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1712,17 +1712,17 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_BoolOp)
w_op = boolop_to_class[self.op - 1]().to_object(space) # boolop
- space.setattr(w_node, space.wrap('op'), w_op)
+ space.setattr(w_node, space.newtext('op'), w_op)
if self.values is None:
values_w = []
else:
values_w = [node.to_object(space) for node in self.values] # expr
w_values = space.newlist(values_w)
- space.setattr(w_node, space.wrap('values'), w_values)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('values'), w_values)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1762,15 +1762,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_BinOp)
w_left = self.left.to_object(space) # expr
- space.setattr(w_node, space.wrap('left'), w_left)
+ space.setattr(w_node, space.newtext('left'), w_left)
w_op = operator_to_class[self.op - 1]().to_object(space) # operator
- space.setattr(w_node, space.wrap('op'), w_op)
+ space.setattr(w_node, space.newtext('op'), w_op)
w_right = self.right.to_object(space) # expr
- space.setattr(w_node, space.wrap('right'), w_right)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('right'), w_right)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1813,13 +1813,13 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_UnaryOp)
w_op = unaryop_to_class[self.op - 1]().to_object(space) # unaryop
- space.setattr(w_node, space.wrap('op'), w_op)
+ space.setattr(w_node, space.newtext('op'), w_op)
w_operand = self.operand.to_object(space) # expr
- space.setattr(w_node, space.wrap('operand'), w_operand)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('operand'), w_operand)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1859,13 +1859,13 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Lambda)
w_args = self.args.to_object(space) # arguments
- space.setattr(w_node, space.wrap('args'), w_args)
+ space.setattr(w_node, space.newtext('args'), w_args)
w_body = self.body.to_object(space) # expr
- space.setattr(w_node, space.wrap('body'), w_body)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('body'), w_body)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1907,15 +1907,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_IfExp)
w_test = self.test.to_object(space) # expr
- space.setattr(w_node, space.wrap('test'), w_test)
+ space.setattr(w_node, space.newtext('test'), w_test)
w_body = self.body.to_object(space) # expr
- space.setattr(w_node, space.wrap('body'), w_body)
+ space.setattr(w_node, space.newtext('body'), w_body)
w_orelse = self.orelse.to_object(space) # expr
- space.setattr(w_node, space.wrap('orelse'), w_orelse)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('orelse'), w_orelse)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -1965,17 +1965,17 @@
else:
keys_w = [node.to_object(space) if node is not None else
space.w_None for node in self.keys] # expr
w_keys = space.newlist(keys_w)
- space.setattr(w_node, space.wrap('keys'), w_keys)
+ space.setattr(w_node, space.newtext('keys'), w_keys)
if self.values is None:
values_w = []
else:
values_w = [node.to_object(space) for node in self.values] # expr
w_values = space.newlist(values_w)
- space.setattr(w_node, space.wrap('values'), w_values)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('values'), w_values)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2016,11 +2016,11 @@
else:
elts_w = [node.to_object(space) for node in self.elts] # expr
w_elts = space.newlist(elts_w)
- space.setattr(w_node, space.wrap('elts'), w_elts)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('elts'), w_elts)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2056,17 +2056,17 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_ListComp)
w_elt = self.elt.to_object(space) # expr
- space.setattr(w_node, space.wrap('elt'), w_elt)
+ space.setattr(w_node, space.newtext('elt'), w_elt)
if self.generators is None:
generators_w = []
else:
generators_w = [node.to_object(space) for node in self.generators]
# comprehension
w_generators = space.newlist(generators_w)
- space.setattr(w_node, space.wrap('generators'), w_generators)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('generators'), w_generators)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2106,17 +2106,17 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_SetComp)
w_elt = self.elt.to_object(space) # expr
- space.setattr(w_node, space.wrap('elt'), w_elt)
+ space.setattr(w_node, space.newtext('elt'), w_elt)
if self.generators is None:
generators_w = []
else:
generators_w = [node.to_object(space) for node in self.generators]
# comprehension
w_generators = space.newlist(generators_w)
- space.setattr(w_node, space.wrap('generators'), w_generators)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('generators'), w_generators)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2158,19 +2158,19 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_DictComp)
w_key = self.key.to_object(space) # expr
- space.setattr(w_node, space.wrap('key'), w_key)
+ space.setattr(w_node, space.newtext('key'), w_key)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
+ space.setattr(w_node, space.newtext('value'), w_value)
if self.generators is None:
generators_w = []
else:
generators_w = [node.to_object(space) for node in self.generators]
# comprehension
w_generators = space.newlist(generators_w)
- space.setattr(w_node, space.wrap('generators'), w_generators)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('generators'), w_generators)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2214,17 +2214,17 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_GeneratorExp)
w_elt = self.elt.to_object(space) # expr
- space.setattr(w_node, space.wrap('elt'), w_elt)
+ space.setattr(w_node, space.newtext('elt'), w_elt)
if self.generators is None:
generators_w = []
else:
generators_w = [node.to_object(space) for node in self.generators]
# comprehension
w_generators = space.newlist(generators_w)
- space.setattr(w_node, space.wrap('generators'), w_generators)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('generators'), w_generators)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2261,11 +2261,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Await)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2300,11 +2300,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Yield)
w_value = self.value.to_object(space) if self.value is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2336,11 +2336,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_YieldFrom)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2378,23 +2378,23 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Compare)
w_left = self.left.to_object(space) # expr
- space.setattr(w_node, space.wrap('left'), w_left)
+ space.setattr(w_node, space.newtext('left'), w_left)
if self.ops is None:
ops_w = []
else:
ops_w = [cmpop_to_class[node - 1]().to_object(space) for node in
self.ops] # cmpop
w_ops = space.newlist(ops_w)
- space.setattr(w_node, space.wrap('ops'), w_ops)
+ space.setattr(w_node, space.newtext('ops'), w_ops)
if self.comparators is None:
comparators_w = []
else:
comparators_w = [node.to_object(space) for node in
self.comparators] # expr
w_comparators = space.newlist(comparators_w)
- space.setattr(w_node, space.wrap('comparators'), w_comparators)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('comparators'), w_comparators)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2440,23 +2440,23 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Call)
w_func = self.func.to_object(space) # expr
- space.setattr(w_node, space.wrap('func'), w_func)
+ space.setattr(w_node, space.newtext('func'), w_func)
if self.args is None:
args_w = []
else:
args_w = [node.to_object(space) for node in self.args] # expr
w_args = space.newlist(args_w)
- space.setattr(w_node, space.wrap('args'), w_args)
+ space.setattr(w_node, space.newtext('args'), w_args)
if self.keywords is None:
keywords_w = []
else:
keywords_w = [node.to_object(space) for node in self.keywords] #
keyword
w_keywords = space.newlist(keywords_w)
- space.setattr(w_node, space.wrap('keywords'), w_keywords)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('keywords'), w_keywords)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2495,11 +2495,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Num)
w_n = self.n # object
- space.setattr(w_node, space.wrap('n'), w_n)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('n'), w_n)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2532,11 +2532,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Str)
w_s = self.s # string
- space.setattr(w_node, space.wrap('s'), w_s)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('s'), w_s)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2569,11 +2569,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Bytes)
w_s = self.s # bytes
- space.setattr(w_node, space.wrap('s'), w_s)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('s'), w_s)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2606,11 +2606,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_NameConstant)
w_single = self.single # singleton
- space.setattr(w_node, space.wrap('single'), w_single)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('single'), w_single)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2641,10 +2641,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Ellipsis)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2676,15 +2676,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Attribute)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
- w_attr = space.wrap(self.attr.decode('utf-8')) # identifier
- space.setattr(w_node, space.wrap('attr'), w_attr)
+ space.setattr(w_node, space.newtext('value'), w_value)
+ w_attr = space.newtext(self.attr) # identifier
+ space.setattr(w_node, space.newtext('attr'), w_attr)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2729,15 +2729,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Subscript)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
+ space.setattr(w_node, space.newtext('value'), w_value)
w_slice = self.slice.to_object(space) # slice
- space.setattr(w_node, space.wrap('slice'), w_slice)
+ space.setattr(w_node, space.newtext('slice'), w_slice)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2780,13 +2780,13 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Starred)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
+ space.setattr(w_node, space.newtext('value'), w_value)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2823,14 +2823,14 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Name)
- w_id = space.wrap(self.id.decode('utf-8')) # identifier
- space.setattr(w_node, space.wrap('id'), w_id)
+ w_id = space.newtext(self.id) # identifier
+ space.setattr(w_node, space.newtext('id'), w_id)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2874,13 +2874,13 @@
else:
elts_w = [node.to_object(space) for node in self.elts] # expr
w_elts = space.newlist(elts_w)
- space.setattr(w_node, space.wrap('elts'), w_elts)
+ space.setattr(w_node, space.newtext('elts'), w_elts)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2923,13 +2923,13 @@
else:
elts_w = [node.to_object(space) for node in self.elts] # expr
w_elts = space.newlist(elts_w)
- space.setattr(w_node, space.wrap('elts'), w_elts)
+ space.setattr(w_node, space.newtext('elts'), w_elts)
w_ctx = expr_context_to_class[self.ctx - 1]().to_object(space) #
expr_context
- space.setattr(w_node, space.wrap('ctx'), w_ctx)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('ctx'), w_ctx)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -2965,11 +2965,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Const)
w_obj = self.obj # object
- space.setattr(w_node, space.wrap('obj'), w_obj)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('obj'), w_obj)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -3089,11 +3089,11 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Slice)
w_lower = self.lower.to_object(space) if self.lower is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('lower'), w_lower)
+ space.setattr(w_node, space.newtext('lower'), w_lower)
w_upper = self.upper.to_object(space) if self.upper is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('upper'), w_upper)
+ space.setattr(w_node, space.newtext('upper'), w_upper)
w_step = self.step.to_object(space) if self.step is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('step'), w_step)
+ space.setattr(w_node, space.newtext('step'), w_step)
return w_node
@staticmethod
@@ -3129,7 +3129,7 @@
else:
dims_w = [node.to_object(space) for node in self.dims] # slice
w_dims = space.newlist(dims_w)
- space.setattr(w_node, space.wrap('dims'), w_dims)
+ space.setattr(w_node, space.newtext('dims'), w_dims)
return w_node
@staticmethod
@@ -3157,7 +3157,7 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_Index)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
+ space.setattr(w_node, space.newtext('value'), w_value)
return w_node
@staticmethod
@@ -3496,15 +3496,15 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_comprehension)
w_target = self.target.to_object(space) # expr
- space.setattr(w_node, space.wrap('target'), w_target)
+ space.setattr(w_node, space.newtext('target'), w_target)
w_iter = self.iter.to_object(space) # expr
- space.setattr(w_node, space.wrap('iter'), w_iter)
+ space.setattr(w_node, space.newtext('iter'), w_iter)
if self.ifs is None:
ifs_w = []
else:
ifs_w = [node.to_object(space) for node in self.ifs] # expr
w_ifs = space.newlist(ifs_w)
- space.setattr(w_node, space.wrap('ifs'), w_ifs)
+ space.setattr(w_node, space.newtext('ifs'), w_ifs)
return w_node
@staticmethod
@@ -3561,19 +3561,19 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_ExceptHandler)
w_type = self.type.to_object(space) if self.type is not None else
space.w_None # expr
- space.setattr(w_node, space.wrap('type'), w_type)
- w_name = space.wrap(self.name.decode('utf-8')) if self.name is not
None else space.w_None # identifier
- space.setattr(w_node, space.wrap('name'), w_name)
+ space.setattr(w_node, space.newtext('type'), w_type)
+ w_name = space.newtext(self.name) if self.name is not None else
space.w_None # identifier
+ space.setattr(w_node, space.newtext('name'), w_name)
if self.body is None:
body_w = []
else:
body_w = [node.to_object(space) for node in self.body] # stmt
w_body = space.newlist(body_w)
- space.setattr(w_node, space.wrap('body'), w_body)
- w_lineno = space.wrap(self.lineno) # int
- space.setattr(w_node, space.wrap('lineno'), w_lineno)
- w_col_offset = space.wrap(self.col_offset) # int
- space.setattr(w_node, space.wrap('col_offset'), w_col_offset)
+ space.setattr(w_node, space.newtext('body'), w_body)
+ w_lineno = space.newint(self.lineno) # int
+ space.setattr(w_node, space.newtext('lineno'), w_lineno)
+ w_col_offset = space.newint(self.col_offset) # int
+ space.setattr(w_node, space.newtext('col_offset'), w_col_offset)
return w_node
@staticmethod
@@ -3629,29 +3629,29 @@
else:
args_w = [node.to_object(space) for node in self.args] # arg
w_args = space.newlist(args_w)
- space.setattr(w_node, space.wrap('args'), w_args)
+ space.setattr(w_node, space.newtext('args'), w_args)
w_vararg = self.vararg.to_object(space) if self.vararg is not None
else space.w_None # arg
- space.setattr(w_node, space.wrap('vararg'), w_vararg)
+ space.setattr(w_node, space.newtext('vararg'), w_vararg)
if self.kwonlyargs is None:
kwonlyargs_w = []
else:
kwonlyargs_w = [node.to_object(space) for node in self.kwonlyargs]
# arg
w_kwonlyargs = space.newlist(kwonlyargs_w)
- space.setattr(w_node, space.wrap('kwonlyargs'), w_kwonlyargs)
+ space.setattr(w_node, space.newtext('kwonlyargs'), w_kwonlyargs)
if self.kw_defaults is None:
kw_defaults_w = []
else:
kw_defaults_w = [node.to_object(space) if node is not None else
space.w_None for node in self.kw_defaults] # expr
w_kw_defaults = space.newlist(kw_defaults_w)
- space.setattr(w_node, space.wrap('kw_defaults'), w_kw_defaults)
+ space.setattr(w_node, space.newtext('kw_defaults'), w_kw_defaults)
w_kwarg = self.kwarg.to_object(space) if self.kwarg is not None else
space.w_None # arg
- space.setattr(w_node, space.wrap('kwarg'), w_kwarg)
+ space.setattr(w_node, space.newtext('kwarg'), w_kwarg)
if self.defaults is None:
defaults_w = []
else:
defaults_w = [node.to_object(space) for node in self.defaults] #
expr
w_defaults = space.newlist(defaults_w)
- space.setattr(w_node, space.wrap('defaults'), w_defaults)
+ space.setattr(w_node, space.newtext('defaults'), w_defaults)
return w_node
@staticmethod
@@ -3692,10 +3692,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_arg)
- w_arg = space.wrap(self.arg.decode('utf-8')) # identifier
- space.setattr(w_node, space.wrap('arg'), w_arg)
+ w_arg = space.newtext(self.arg) # identifier
+ space.setattr(w_node, space.newtext('arg'), w_arg)
w_annotation = self.annotation.to_object(space) if self.annotation is
not None else space.w_None # expr
- space.setattr(w_node, space.wrap('annotation'), w_annotation)
+ space.setattr(w_node, space.newtext('annotation'), w_annotation)
return w_node
@staticmethod
@@ -3725,10 +3725,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_keyword)
- w_arg = space.wrap(self.arg.decode('utf-8')) if self.arg is not None
else space.w_None # identifier
- space.setattr(w_node, space.wrap('arg'), w_arg)
+ w_arg = space.newtext(self.arg) if self.arg is not None else
space.w_None # identifier
+ space.setattr(w_node, space.newtext('arg'), w_arg)
w_value = self.value.to_object(space) # expr
- space.setattr(w_node, space.wrap('value'), w_value)
+ space.setattr(w_node, space.newtext('value'), w_value)
return w_node
@staticmethod
@@ -3757,10 +3757,10 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_alias)
- w_name = space.wrap(self.name.decode('utf-8')) # identifier
- space.setattr(w_node, space.wrap('name'), w_name)
- w_asname = space.wrap(self.asname.decode('utf-8')) if self.asname is
not None else space.w_None # identifier
- space.setattr(w_node, space.wrap('asname'), w_asname)
+ w_name = space.newtext(self.name) # identifier
+ space.setattr(w_node, space.newtext('name'), w_name)
+ w_asname = space.newtext(self.asname) if self.asname is not None else
space.w_None # identifier
+ space.setattr(w_node, space.newtext('asname'), w_asname)
return w_node
@staticmethod
@@ -3793,9 +3793,9 @@
def to_object(self, space):
w_node = space.call_function(get(space).w_withitem)
w_context_expr = self.context_expr.to_object(space) # expr
- space.setattr(w_node, space.wrap('context_expr'), w_context_expr)
+ space.setattr(w_node, space.newtext('context_expr'), w_context_expr)
w_optional_vars = self.optional_vars.to_object(space) if
self.optional_vars is not None else space.w_None # expr
- space.setattr(w_node, space.wrap('optional_vars'), w_optional_vars)
+ space.setattr(w_node, space.newtext('optional_vars'), w_optional_vars)
return w_node
@staticmethod
diff --git a/pypy/interpreter/astcompiler/tools/asdl_py.py
b/pypy/interpreter/astcompiler/tools/asdl_py.py
--- a/pypy/interpreter/astcompiler/tools/asdl_py.py
+++ b/pypy/interpreter/astcompiler/tools/asdl_py.py
@@ -125,15 +125,17 @@
def get_value_converter(self, field, value):
if field.type in self.data.simple_types:
return "%s_to_class[%s - 1]().to_object(space)" % (field.type,
value)
+ elif field.type in ("object", "singleton", "string", "bytes"):
+ return value
+ elif field.type == "bool":
+ return "space.newbool(%s)" % (value,)
+ elif field.type == "int":
+ return "space.newint(%s)" % (value,)
elif field.type == "identifier":
- wrapper = "space.wrap(%s.decode('utf-8'))" % (value,)
+ wrapper = "space.newtext(%s)" % (value,)
if field.opt:
wrapper += " if %s is not None else space.w_None" % (value,)
return wrapper
- elif field.type in ("object", "singleton", "string", "bytes"):
- return value
- elif field.type in ("int", "bool"):
- return "space.wrap(%s)" % (value,)
else:
wrapper = "%s.to_object(space)" % (value,)
allow_none = field.opt
@@ -218,7 +220,7 @@
wrapping_code = self.get_field_converter(field)
for line in wrapping_code:
self.emit(line, 2)
- self.emit("space.setattr(w_node, space.wrap(%r), w_%s)" % (
+ self.emit("space.setattr(w_node, space.newtext(%r), w_%s)" % (
str(field.name), field.name), 2)
self.emit("return w_node", 2)
self.emit("")
@@ -486,14 +488,14 @@
if w_dict is None:
w_dict = space.newdict()
w_type = space.type(self)
- w_fields = space.getattr(w_type, space.wrap("_fields"))
+ w_fields = space.getattr(w_type, space.newtext("_fields"))
for w_name in space.fixedview(w_fields):
try:
space.setitem(w_dict, w_name,
space.getattr(self, w_name))
except OperationError:
pass
- w_attrs = space.findattr(w_type, space.wrap("_attributes"))
+ w_attrs = space.findattr(w_type, space.newtext("_attributes"))
if w_attrs:
for w_name in space.fixedview(w_attrs):
try:
@@ -512,12 +514,12 @@
def W_AST_new(space, w_type, __args__):
node = space.allocate_instance(W_AST, w_type)
- return space.wrap(node)
+ return node
def W_AST_init(space, w_self, __args__):
args_w, kwargs_w = __args__.unpack()
fields_w = space.fixedview(space.getattr(space.type(w_self),
- space.wrap("_fields")))
+ space.newtext("_fields")))
num_fields = len(fields_w) if fields_w else 0
if args_w and len(args_w) != num_fields:
if num_fields == 0:
@@ -533,7 +535,7 @@
for i, w_field in enumerate(fields_w):
space.setattr(w_self, w_field, args_w[i])
for field, w_value in kwargs_w.iteritems():
- space.setattr(w_self, space.wrap(field), w_value)
+ space.setattr(w_self, space.newtext(field), w_value)
W_AST.typedef = typedef.TypeDef("_ast.AST",
@@ -562,16 +564,16 @@
def make_new_type(self, space, name, base, fields, attributes):
w_base = getattr(self, 'w_%s' % base)
w_dict = space.newdict()
- space.setitem_str(w_dict, '__module__', space.wrap('_ast'))
+ space.setitem_str(w_dict, '__module__', space.newtext('_ast'))
if fields is not None:
space.setitem_str(w_dict, "_fields",
- space.newtuple([space.wrap(f) for f in fields]))
+ space.newtuple([space.newtext(f) for f in
fields]))
if attributes is not None:
space.setitem_str(w_dict, "_attributes",
- space.newtuple([space.wrap(a) for a in
attributes]))
+ space.newtuple([space.newtext(a) for a in
attributes]))
w_type = space.call_function(
space.w_type,
- space.wrap(name), space.newtuple([w_base]), w_dict)
+ space.newtext(name), space.newtuple([w_base]), w_dict)
setattr(self, 'w_%s' % name, w_type)
def get(space):
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
