[pypy-commit] pypy py3k: merge default

pjenvey noreply at buildbot.pypy.org
Mon May 5 21:08:10 CEST 2014


Author: Philip Jenvey <pjenvey at underboss.org>
Branch: py3k
Changeset: r71280:00ddc2f3a097
Date: 2014-05-05 11:44 -0700
http://bitbucket.org/pypy/pypy/changeset/00ddc2f3a097/

Log:	merge default

diff too long, truncating to 2000 out of 3049 lines

diff --git a/pypy/doc/release-2.3.0.rst b/pypy/doc/release-2.3.0.rst
--- a/pypy/doc/release-2.3.0.rst
+++ b/pypy/doc/release-2.3.0.rst
@@ -87,6 +87,10 @@
 
 * Support for corner cases on objects with __int__ and __float__ methods
 
+* Fix multithreaded support for gethostbyname_ex and gethostbyaddr
+
+* Fix handling of tp_name for type objects
+
 .. _`HippyVM`: http://www.hippyvm.com
 
 New Platforms and Features
diff --git a/pypy/doc/whatsnew-2.3.0.rst b/pypy/doc/whatsnew-2.3.0.rst
--- a/pypy/doc/whatsnew-2.3.0.rst
+++ b/pypy/doc/whatsnew-2.3.0.rst
@@ -154,7 +154,7 @@
 Improve optimization of small allocation-heavy loops in the JIT
 
 .. branch: reflex-support
-   
+
 .. branch: asmosoinio/fixed-pip-installation-url-github-githu-1398674840188
 
 .. branch: lexer_token_position_class
@@ -165,3 +165,5 @@
 .. branch: issue1430
 Add a lock for unsafe calls to gethostbyname and gethostbyaddr
 
+.. branch: fix-tpname
+Changes hacks surrounding W_TypeObject.name to match CPython's tp_name
diff --git a/pypy/doc/whatsnew-head.rst b/pypy/doc/whatsnew-head.rst
--- a/pypy/doc/whatsnew-head.rst
+++ b/pypy/doc/whatsnew-head.rst
@@ -3,5 +3,4 @@
 =======================
 
 .. this is a revision shortly after release-2.3.x
-.. startrev: 0f75ad4d14ce
-
+.. startrev: ec864bd08d50
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
@@ -121,10 +121,9 @@
     for field, w_value in kwargs_w.iteritems():
         space.setattr(w_self, space.wrap(field), w_value)
 
-AST.typedef = typedef.TypeDef("AST",
+AST.typedef = typedef.TypeDef("_ast.AST",
     _fields=_FieldsWrapper([]),
     _attributes=_FieldsWrapper([]),
-    __module__='_ast',
     __reduce__=interp2app(AST.reduce_w),
     __setstate__=interp2app(AST.setstate_w),
     __dict__ = typedef.GetSetProperty(typedef.descr_get_dict,
@@ -2883,6 +2882,7 @@
     _attributes=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(mod)),
 )
+mod.typedef.heaptype = True
 
 def Module_get_body(space, w_self):
     if not w_self.initialization_state & 1:
@@ -2930,6 +2930,7 @@
     __new__=interp2app(get_AST_new(Module)),
     __init__=interp2app(Module_init),
 )
+Module.typedef.heaptype = True
 
 def Interactive_get_body(space, w_self):
     if not w_self.initialization_state & 1:
@@ -2977,6 +2978,7 @@
     __new__=interp2app(get_AST_new(Interactive)),
     __init__=interp2app(Interactive_init),
 )
+Interactive.typedef.heaptype = True
 
 def Expression_get_body(space, w_self):
     if w_self.w_dict is not None:
@@ -3030,6 +3032,7 @@
     __new__=interp2app(get_AST_new(Expression)),
     __init__=interp2app(Expression_init),
 )
+Expression.typedef.heaptype = True
 
 def Suite_get_body(space, w_self):
     if not w_self.initialization_state & 1:
@@ -3077,6 +3080,7 @@
     __new__=interp2app(get_AST_new(Suite)),
     __init__=interp2app(Suite_init),
 )
+Suite.typedef.heaptype = True
 
 def stmt_get_lineno(space, w_self):
     if w_self.w_dict is not None:
@@ -3142,6 +3146,7 @@
     col_offset=typedef.GetSetProperty(stmt_get_col_offset, stmt_set_col_offset, stmt_del_col_offset, cls=stmt),
     __new__=interp2app(get_AST_new(stmt)),
 )
+stmt.typedef.heaptype = True
 
 def FunctionDef_get_name(space, w_self):
     if w_self.w_dict is not None:
@@ -3302,6 +3307,7 @@
     __new__=interp2app(get_AST_new(FunctionDef)),
     __init__=interp2app(FunctionDef_init),
 )
+FunctionDef.typedef.heaptype = True
 
 def ClassDef_get_name(space, w_self):
     if w_self.w_dict is not None:
@@ -3512,6 +3518,7 @@
     __new__=interp2app(get_AST_new(ClassDef)),
     __init__=interp2app(ClassDef_init),
 )
+ClassDef.typedef.heaptype = True
 
 def Return_get_value(space, w_self):
     if w_self.w_dict is not None:
@@ -3565,6 +3572,7 @@
     __new__=interp2app(get_AST_new(Return)),
     __init__=interp2app(Return_init),
 )
+Return.typedef.heaptype = True
 
 def Delete_get_targets(space, w_self):
     if not w_self.initialization_state & 4:
@@ -3612,6 +3620,7 @@
     __new__=interp2app(get_AST_new(Delete)),
     __init__=interp2app(Delete_init),
 )
+Delete.typedef.heaptype = True
 
 def Assign_get_targets(space, w_self):
     if not w_self.initialization_state & 4:
@@ -3689,6 +3698,7 @@
     __new__=interp2app(get_AST_new(Assign)),
     __init__=interp2app(Assign_init),
 )
+Assign.typedef.heaptype = True
 
 def AugAssign_get_target(space, w_self):
     if w_self.w_dict is not None:
@@ -3802,6 +3812,7 @@
     __new__=interp2app(get_AST_new(AugAssign)),
     __init__=interp2app(AugAssign_init),
 )
+AugAssign.typedef.heaptype = True
 
 def For_get_target(space, w_self):
     if w_self.w_dict is not None:
@@ -3933,6 +3944,7 @@
     __new__=interp2app(get_AST_new(For)),
     __init__=interp2app(For_init),
 )
+For.typedef.heaptype = True
 
 def While_get_test(space, w_self):
     if w_self.w_dict is not None:
@@ -4034,6 +4046,7 @@
     __new__=interp2app(get_AST_new(While)),
     __init__=interp2app(While_init),
 )
+While.typedef.heaptype = True
 
 def If_get_test(space, w_self):
     if w_self.w_dict is not None:
@@ -4135,6 +4148,7 @@
     __new__=interp2app(get_AST_new(If)),
     __init__=interp2app(If_init),
 )
+If.typedef.heaptype = True
 
 def With_get_context_expr(space, w_self):
     if w_self.w_dict is not None:
@@ -4242,6 +4256,7 @@
     __new__=interp2app(get_AST_new(With)),
     __init__=interp2app(With_init),
 )
+With.typedef.heaptype = True
 
 def Raise_get_exc(space, w_self):
     if w_self.w_dict is not None:
@@ -4325,6 +4340,7 @@
     __new__=interp2app(get_AST_new(Raise)),
     __init__=interp2app(Raise_init),
 )
+Raise.typedef.heaptype = True
 
 def TryExcept_get_body(space, w_self):
     if not w_self.initialization_state & 4:
@@ -4420,6 +4436,7 @@
     __new__=interp2app(get_AST_new(TryExcept)),
     __init__=interp2app(TryExcept_init),
 )
+TryExcept.typedef.heaptype = True
 
 def TryFinally_get_body(space, w_self):
     if not w_self.initialization_state & 4:
@@ -4491,6 +4508,7 @@
     __new__=interp2app(get_AST_new(TryFinally)),
     __init__=interp2app(TryFinally_init),
 )
+TryFinally.typedef.heaptype = True
 
 def Assert_get_test(space, w_self):
     if w_self.w_dict is not None:
@@ -4574,6 +4592,7 @@
     __new__=interp2app(get_AST_new(Assert)),
     __init__=interp2app(Assert_init),
 )
+Assert.typedef.heaptype = True
 
 def Import_get_names(space, w_self):
     if not w_self.initialization_state & 4:
@@ -4621,6 +4640,7 @@
     __new__=interp2app(get_AST_new(Import)),
     __init__=interp2app(Import_init),
 )
+Import.typedef.heaptype = True
 
 def ImportFrom_get_module(space, w_self):
     if w_self.w_dict is not None:
@@ -4731,6 +4751,7 @@
     __new__=interp2app(get_AST_new(ImportFrom)),
     __init__=interp2app(ImportFrom_init),
 )
+ImportFrom.typedef.heaptype = True
 
 def Global_get_names(space, w_self):
     if not w_self.initialization_state & 4:
@@ -4778,6 +4799,7 @@
     __new__=interp2app(get_AST_new(Global)),
     __init__=interp2app(Global_init),
 )
+Global.typedef.heaptype = True
 
 def Nonlocal_get_names(space, w_self):
     if not w_self.initialization_state & 4:
@@ -4825,6 +4847,7 @@
     __new__=interp2app(get_AST_new(Nonlocal)),
     __init__=interp2app(Nonlocal_init),
 )
+Nonlocal.typedef.heaptype = True
 
 def Expr_get_value(space, w_self):
     if w_self.w_dict is not None:
@@ -4878,6 +4901,7 @@
     __new__=interp2app(get_AST_new(Expr)),
     __init__=interp2app(Expr_init),
 )
+Expr.typedef.heaptype = True
 
 def Pass_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Pass, w_self)
@@ -4895,6 +4919,7 @@
     __new__=interp2app(get_AST_new(Pass)),
     __init__=interp2app(Pass_init),
 )
+Pass.typedef.heaptype = True
 
 def Break_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Break, w_self)
@@ -4912,6 +4937,7 @@
     __new__=interp2app(get_AST_new(Break)),
     __init__=interp2app(Break_init),
 )
+Break.typedef.heaptype = True
 
 def Continue_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Continue, w_self)
@@ -4929,6 +4955,7 @@
     __new__=interp2app(get_AST_new(Continue)),
     __init__=interp2app(Continue_init),
 )
+Continue.typedef.heaptype = True
 
 def expr_get_lineno(space, w_self):
     if w_self.w_dict is not None:
@@ -4994,6 +5021,7 @@
     col_offset=typedef.GetSetProperty(expr_get_col_offset, expr_set_col_offset, expr_del_col_offset, cls=expr),
     __new__=interp2app(get_AST_new(expr)),
 )
+expr.typedef.heaptype = True
 
 def BoolOp_get_op(space, w_self):
     if w_self.w_dict is not None:
@@ -5071,6 +5099,7 @@
     __new__=interp2app(get_AST_new(BoolOp)),
     __init__=interp2app(BoolOp_init),
 )
+BoolOp.typedef.heaptype = True
 
 def BinOp_get_left(space, w_self):
     if w_self.w_dict is not None:
@@ -5184,6 +5213,7 @@
     __new__=interp2app(get_AST_new(BinOp)),
     __init__=interp2app(BinOp_init),
 )
+BinOp.typedef.heaptype = True
 
 def UnaryOp_get_op(space, w_self):
     if w_self.w_dict is not None:
@@ -5267,6 +5297,7 @@
     __new__=interp2app(get_AST_new(UnaryOp)),
     __init__=interp2app(UnaryOp_init),
 )
+UnaryOp.typedef.heaptype = True
 
 def Lambda_get_args(space, w_self):
     if w_self.w_dict is not None:
@@ -5348,6 +5379,7 @@
     __new__=interp2app(get_AST_new(Lambda)),
     __init__=interp2app(Lambda_init),
 )
+Lambda.typedef.heaptype = True
 
 def IfExp_get_test(space, w_self):
     if w_self.w_dict is not None:
@@ -5461,6 +5493,7 @@
     __new__=interp2app(get_AST_new(IfExp)),
     __init__=interp2app(IfExp_init),
 )
+IfExp.typedef.heaptype = True
 
 def Dict_get_keys(space, w_self):
     if not w_self.initialization_state & 4:
@@ -5532,6 +5565,7 @@
     __new__=interp2app(get_AST_new(Dict)),
     __init__=interp2app(Dict_init),
 )
+Dict.typedef.heaptype = True
 
 def Set_get_elts(space, w_self):
     if not w_self.initialization_state & 4:
@@ -5579,6 +5613,7 @@
     __new__=interp2app(get_AST_new(Set)),
     __init__=interp2app(Set_init),
 )
+Set.typedef.heaptype = True
 
 def ListComp_get_elt(space, w_self):
     if w_self.w_dict is not None:
@@ -5656,6 +5691,7 @@
     __new__=interp2app(get_AST_new(ListComp)),
     __init__=interp2app(ListComp_init),
 )
+ListComp.typedef.heaptype = True
 
 def SetComp_get_elt(space, w_self):
     if w_self.w_dict is not None:
@@ -5733,6 +5769,7 @@
     __new__=interp2app(get_AST_new(SetComp)),
     __init__=interp2app(SetComp_init),
 )
+SetComp.typedef.heaptype = True
 
 def DictComp_get_key(space, w_self):
     if w_self.w_dict is not None:
@@ -5840,6 +5877,7 @@
     __new__=interp2app(get_AST_new(DictComp)),
     __init__=interp2app(DictComp_init),
 )
+DictComp.typedef.heaptype = True
 
 def GeneratorExp_get_elt(space, w_self):
     if w_self.w_dict is not None:
@@ -5917,6 +5955,7 @@
     __new__=interp2app(get_AST_new(GeneratorExp)),
     __init__=interp2app(GeneratorExp_init),
 )
+GeneratorExp.typedef.heaptype = True
 
 def Yield_get_value(space, w_self):
     if w_self.w_dict is not None:
@@ -5970,6 +6009,7 @@
     __new__=interp2app(get_AST_new(Yield)),
     __init__=interp2app(Yield_init),
 )
+Yield.typedef.heaptype = True
 
 def Compare_get_left(space, w_self):
     if w_self.w_dict is not None:
@@ -6071,6 +6111,7 @@
     __new__=interp2app(get_AST_new(Compare)),
     __init__=interp2app(Compare_init),
 )
+Compare.typedef.heaptype = True
 
 def Call_get_func(space, w_self):
     if w_self.w_dict is not None:
@@ -6232,6 +6273,7 @@
     __new__=interp2app(get_AST_new(Call)),
     __init__=interp2app(Call_init),
 )
+Call.typedef.heaptype = True
 
 def Num_get_n(space, w_self):
     if w_self.w_dict is not None:
@@ -6284,6 +6326,7 @@
     __new__=interp2app(get_AST_new(Num)),
     __init__=interp2app(Num_init),
 )
+Num.typedef.heaptype = True
 
 def Str_get_s(space, w_self):
     if w_self.w_dict is not None:
@@ -6336,6 +6379,7 @@
     __new__=interp2app(get_AST_new(Str)),
     __init__=interp2app(Str_init),
 )
+Str.typedef.heaptype = True
 
 def Bytes_get_s(space, w_self):
     if w_self.w_dict is not None:
@@ -6388,6 +6432,7 @@
     __new__=interp2app(get_AST_new(Bytes)),
     __init__=interp2app(Bytes_init),
 )
+Bytes.typedef.heaptype = True
 
 def Ellipsis_init(space, w_self, __args__):
     w_self = space.descr_self_interp_w(Ellipsis, w_self)
@@ -6405,6 +6450,7 @@
     __new__=interp2app(get_AST_new(Ellipsis)),
     __init__=interp2app(Ellipsis_init),
 )
+Ellipsis.typedef.heaptype = True
 
 def Attribute_get_value(space, w_self):
     if w_self.w_dict is not None:
@@ -6519,6 +6565,7 @@
     __new__=interp2app(get_AST_new(Attribute)),
     __init__=interp2app(Attribute_init),
 )
+Attribute.typedef.heaptype = True
 
 def Subscript_get_value(space, w_self):
     if w_self.w_dict is not None:
@@ -6632,6 +6679,7 @@
     __new__=interp2app(get_AST_new(Subscript)),
     __init__=interp2app(Subscript_init),
 )
+Subscript.typedef.heaptype = True
 
 def Starred_get_value(space, w_self):
     if w_self.w_dict is not None:
@@ -6715,6 +6763,7 @@
     __new__=interp2app(get_AST_new(Starred)),
     __init__=interp2app(Starred_init),
 )
+Starred.typedef.heaptype = True
 
 def Name_get_id(space, w_self):
     if w_self.w_dict is not None:
@@ -6799,6 +6848,7 @@
     __new__=interp2app(get_AST_new(Name)),
     __init__=interp2app(Name_init),
 )
+Name.typedef.heaptype = True
 
 def List_get_elts(space, w_self):
     if not w_self.initialization_state & 4:
@@ -6876,6 +6926,7 @@
     __new__=interp2app(get_AST_new(List)),
     __init__=interp2app(List_init),
 )
+List.typedef.heaptype = True
 
 def Tuple_get_elts(space, w_self):
     if not w_self.initialization_state & 4:
@@ -6953,6 +7004,7 @@
     __new__=interp2app(get_AST_new(Tuple)),
     __init__=interp2app(Tuple_init),
 )
+Tuple.typedef.heaptype = True
 
 def Const_get_value(space, w_self):
     if w_self.w_dict is not None:
@@ -7005,6 +7057,7 @@
     __new__=interp2app(get_AST_new(Const)),
     __init__=interp2app(Const_init),
 )
+Const.typedef.heaptype = True
 
 expr_context.typedef = typedef.TypeDef("expr_context",
     AST.typedef,
@@ -7012,6 +7065,7 @@
     _attributes=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(expr_context)),
 )
+expr_context.typedef.heaptype = True
 
 _Load.typedef = typedef.TypeDef("Load",
     expr_context.typedef,
@@ -7019,6 +7073,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Load)),
 )
+_Load.typedef.heaptype = True
 
 _Store.typedef = typedef.TypeDef("Store",
     expr_context.typedef,
@@ -7026,6 +7081,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Store)),
 )
+_Store.typedef.heaptype = True
 
 _Del.typedef = typedef.TypeDef("Del",
     expr_context.typedef,
@@ -7033,6 +7089,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Del)),
 )
+_Del.typedef.heaptype = True
 
 _AugLoad.typedef = typedef.TypeDef("AugLoad",
     expr_context.typedef,
@@ -7040,6 +7097,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_AugLoad)),
 )
+_AugLoad.typedef.heaptype = True
 
 _AugStore.typedef = typedef.TypeDef("AugStore",
     expr_context.typedef,
@@ -7047,6 +7105,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_AugStore)),
 )
+_AugStore.typedef.heaptype = True
 
 _Param.typedef = typedef.TypeDef("Param",
     expr_context.typedef,
@@ -7054,6 +7113,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Param)),
 )
+_Param.typedef.heaptype = True
 
 slice.typedef = typedef.TypeDef("slice",
     AST.typedef,
@@ -7061,6 +7121,7 @@
     _attributes=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(slice)),
 )
+slice.typedef.heaptype = True
 
 def Slice_get_lower(space, w_self):
     if w_self.w_dict is not None:
@@ -7174,6 +7235,7 @@
     __new__=interp2app(get_AST_new(Slice)),
     __init__=interp2app(Slice_init),
 )
+Slice.typedef.heaptype = True
 
 def ExtSlice_get_dims(space, w_self):
     if not w_self.initialization_state & 1:
@@ -7221,6 +7283,7 @@
     __new__=interp2app(get_AST_new(ExtSlice)),
     __init__=interp2app(ExtSlice_init),
 )
+ExtSlice.typedef.heaptype = True
 
 def Index_get_value(space, w_self):
     if w_self.w_dict is not None:
@@ -7274,6 +7337,7 @@
     __new__=interp2app(get_AST_new(Index)),
     __init__=interp2app(Index_init),
 )
+Index.typedef.heaptype = True
 
 boolop.typedef = typedef.TypeDef("boolop",
     AST.typedef,
@@ -7281,6 +7345,7 @@
     _attributes=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(boolop)),
 )
+boolop.typedef.heaptype = True
 
 _And.typedef = typedef.TypeDef("And",
     boolop.typedef,
@@ -7288,6 +7353,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_And)),
 )
+_And.typedef.heaptype = True
 
 _Or.typedef = typedef.TypeDef("Or",
     boolop.typedef,
@@ -7295,6 +7361,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Or)),
 )
+_Or.typedef.heaptype = True
 
 operator.typedef = typedef.TypeDef("operator",
     AST.typedef,
@@ -7302,6 +7369,7 @@
     _attributes=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(operator)),
 )
+operator.typedef.heaptype = True
 
 _Add.typedef = typedef.TypeDef("Add",
     operator.typedef,
@@ -7309,6 +7377,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Add)),
 )
+_Add.typedef.heaptype = True
 
 _Sub.typedef = typedef.TypeDef("Sub",
     operator.typedef,
@@ -7316,6 +7385,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Sub)),
 )
+_Sub.typedef.heaptype = True
 
 _Mult.typedef = typedef.TypeDef("Mult",
     operator.typedef,
@@ -7323,6 +7393,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Mult)),
 )
+_Mult.typedef.heaptype = True
 
 _Div.typedef = typedef.TypeDef("Div",
     operator.typedef,
@@ -7330,6 +7401,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Div)),
 )
+_Div.typedef.heaptype = True
 
 _Mod.typedef = typedef.TypeDef("Mod",
     operator.typedef,
@@ -7337,6 +7409,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Mod)),
 )
+_Mod.typedef.heaptype = True
 
 _Pow.typedef = typedef.TypeDef("Pow",
     operator.typedef,
@@ -7344,6 +7417,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Pow)),
 )
+_Pow.typedef.heaptype = True
 
 _LShift.typedef = typedef.TypeDef("LShift",
     operator.typedef,
@@ -7351,6 +7425,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_LShift)),
 )
+_LShift.typedef.heaptype = True
 
 _RShift.typedef = typedef.TypeDef("RShift",
     operator.typedef,
@@ -7358,6 +7433,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_RShift)),
 )
+_RShift.typedef.heaptype = True
 
 _BitOr.typedef = typedef.TypeDef("BitOr",
     operator.typedef,
@@ -7365,6 +7441,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_BitOr)),
 )
+_BitOr.typedef.heaptype = True
 
 _BitXor.typedef = typedef.TypeDef("BitXor",
     operator.typedef,
@@ -7372,6 +7449,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_BitXor)),
 )
+_BitXor.typedef.heaptype = True
 
 _BitAnd.typedef = typedef.TypeDef("BitAnd",
     operator.typedef,
@@ -7379,6 +7457,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_BitAnd)),
 )
+_BitAnd.typedef.heaptype = True
 
 _FloorDiv.typedef = typedef.TypeDef("FloorDiv",
     operator.typedef,
@@ -7386,6 +7465,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_FloorDiv)),
 )
+_FloorDiv.typedef.heaptype = True
 
 unaryop.typedef = typedef.TypeDef("unaryop",
     AST.typedef,
@@ -7393,6 +7473,7 @@
     _attributes=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(unaryop)),
 )
+unaryop.typedef.heaptype = True
 
 _Invert.typedef = typedef.TypeDef("Invert",
     unaryop.typedef,
@@ -7400,6 +7481,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Invert)),
 )
+_Invert.typedef.heaptype = True
 
 _Not.typedef = typedef.TypeDef("Not",
     unaryop.typedef,
@@ -7407,6 +7489,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Not)),
 )
+_Not.typedef.heaptype = True
 
 _UAdd.typedef = typedef.TypeDef("UAdd",
     unaryop.typedef,
@@ -7414,6 +7497,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_UAdd)),
 )
+_UAdd.typedef.heaptype = True
 
 _USub.typedef = typedef.TypeDef("USub",
     unaryop.typedef,
@@ -7421,6 +7505,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_USub)),
 )
+_USub.typedef.heaptype = True
 
 cmpop.typedef = typedef.TypeDef("cmpop",
     AST.typedef,
@@ -7428,6 +7513,7 @@
     _attributes=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(cmpop)),
 )
+cmpop.typedef.heaptype = True
 
 _Eq.typedef = typedef.TypeDef("Eq",
     cmpop.typedef,
@@ -7435,6 +7521,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Eq)),
 )
+_Eq.typedef.heaptype = True
 
 _NotEq.typedef = typedef.TypeDef("NotEq",
     cmpop.typedef,
@@ -7442,6 +7529,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_NotEq)),
 )
+_NotEq.typedef.heaptype = True
 
 _Lt.typedef = typedef.TypeDef("Lt",
     cmpop.typedef,
@@ -7449,6 +7537,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Lt)),
 )
+_Lt.typedef.heaptype = True
 
 _LtE.typedef = typedef.TypeDef("LtE",
     cmpop.typedef,
@@ -7456,6 +7545,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_LtE)),
 )
+_LtE.typedef.heaptype = True
 
 _Gt.typedef = typedef.TypeDef("Gt",
     cmpop.typedef,
@@ -7463,6 +7553,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Gt)),
 )
+_Gt.typedef.heaptype = True
 
 _GtE.typedef = typedef.TypeDef("GtE",
     cmpop.typedef,
@@ -7470,6 +7561,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_GtE)),
 )
+_GtE.typedef.heaptype = True
 
 _Is.typedef = typedef.TypeDef("Is",
     cmpop.typedef,
@@ -7477,6 +7569,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_Is)),
 )
+_Is.typedef.heaptype = True
 
 _IsNot.typedef = typedef.TypeDef("IsNot",
     cmpop.typedef,
@@ -7484,6 +7577,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_IsNot)),
 )
+_IsNot.typedef.heaptype = True
 
 _In.typedef = typedef.TypeDef("In",
     cmpop.typedef,
@@ -7491,6 +7585,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_In)),
 )
+_In.typedef.heaptype = True
 
 _NotIn.typedef = typedef.TypeDef("NotIn",
     cmpop.typedef,
@@ -7498,6 +7593,7 @@
     _fields=_FieldsWrapper([]),
     __new__=interp2app(get_AST_new(_NotIn)),
 )
+_NotIn.typedef.heaptype = True
 
 def comprehension_get_target(space, w_self):
     if w_self.w_dict is not None:
@@ -7605,6 +7701,7 @@
     __new__=interp2app(get_AST_new(comprehension)),
     __init__=interp2app(comprehension_init),
 )
+comprehension.typedef.heaptype = True
 
 def excepthandler_get_lineno(space, w_self):
     if w_self.w_dict is not None:
@@ -7670,6 +7767,7 @@
     col_offset=typedef.GetSetProperty(excepthandler_get_col_offset, excepthandler_set_col_offset, excepthandler_del_col_offset, cls=excepthandler),
     __new__=interp2app(get_AST_new(excepthandler)),
 )
+excepthandler.typedef.heaptype = True
 
 def ExceptHandler_get_type(space, w_self):
     if w_self.w_dict is not None:
@@ -7781,6 +7879,7 @@
     __new__=interp2app(get_AST_new(ExceptHandler)),
     __init__=interp2app(ExceptHandler_init),
 )
+ExceptHandler.typedef.heaptype = True
 
 def arguments_get_args(space, w_self):
     if not w_self.initialization_state & 1:
@@ -8028,6 +8127,7 @@
     __new__=interp2app(get_AST_new(arguments)),
     __init__=interp2app(arguments_init),
 )
+arguments.typedef.heaptype = True
 
 def arg_get_arg(space, w_self):
     if w_self.w_dict is not None:
@@ -8112,6 +8212,7 @@
     __new__=interp2app(get_AST_new(arg)),
     __init__=interp2app(arg_init),
 )
+arg.typedef.heaptype = True
 
 def keyword_get_arg(space, w_self):
     if w_self.w_dict is not None:
@@ -8196,6 +8297,7 @@
     __new__=interp2app(get_AST_new(keyword)),
     __init__=interp2app(keyword_init),
 )
+keyword.typedef.heaptype = True
 
 def alias_get_name(space, w_self):
     if w_self.w_dict is not None:
@@ -8284,4 +8386,5 @@
     __new__=interp2app(get_AST_new(alias)),
     __init__=interp2app(alias_init),
 )
-
+alias.typedef.heaptype = True
+
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
@@ -359,6 +359,7 @@
         if needs_init:
             self.emit("__init__=interp2app(%s_init)," % (name,), 1)
         self.emit(")")
+        self.emit("%s.typedef.heaptype = True" % name)
         self.emit("")
 
     def make_init(self, name, fields):
@@ -680,10 +681,9 @@
     for field, w_value in kwargs_w.iteritems():
         space.setattr(w_self, space.wrap(field), w_value)
 
-AST.typedef = typedef.TypeDef("AST",
+AST.typedef = typedef.TypeDef("_ast.AST",
     _fields=_FieldsWrapper([]),
     _attributes=_FieldsWrapper([]),
-    __module__='_ast',
     __reduce__=interp2app(AST.reduce_w),
     __setstate__=interp2app(AST.setstate_w),
     __dict__ = typedef.GetSetProperty(typedef.descr_get_dict,
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -392,11 +392,7 @@
         self.user_del_action = UserDelAction(self)
         self._code_of_sys_exc_info = None
 
-        from pypy.interpreter.pycode import cpython_magic, default_magic
-        self.our_magic = default_magic
-        self.host_magic = cpython_magic
         # can be overridden to a subclass
-
         self.initialize()
 
     def startup(self):
diff --git a/pypy/interpreter/error.py b/pypy/interpreter/error.py
--- a/pypy/interpreter/error.py
+++ b/pypy/interpreter/error.py
@@ -416,7 +416,7 @@
                     elif fmt == 'R':
                         result = space.unicode_w(space.repr(value))
                     elif fmt == 'T':
-                        result = space.type(value).get_module_type_name()
+                        result = space.type(value).name.decode('utf-8')
                     elif fmt == 'N':
                         result = value.getname(space)
                     elif fmt == '8':
@@ -461,7 +461,7 @@
     %8 - The result of arg.decode('utf-8')
     %N - The result of w_arg.getname(space)
     %R - The result of space.unicode_w(space.repr(w_arg))
-    %T - The result of space.type(w_arg).get_module_type_name()
+    %T - The result of space.type(w_arg).name
 
     """
     if not len(args):
diff --git a/pypy/interpreter/gateway.py b/pypy/interpreter/gateway.py
--- a/pypy/interpreter/gateway.py
+++ b/pypy/interpreter/gateway.py
@@ -1101,7 +1101,9 @@
                            return x+y
                     ''')
     """
+    prefix = ""
     if not isinstance(source, str):
+        flags = source.__code__.co_flags
         source = py.std.inspect.getsource(source).lstrip()
         while source.startswith(('@py.test.mark.', '@pytest.mark.')):
             # these decorators are known to return the same function
@@ -1110,12 +1112,21 @@
             source = source[source.find('\n') + 1:].lstrip()
         assert source.startswith("def "), "can only transform functions"
         source = source[4:]
+        import __future__
+        if flags & __future__.CO_FUTURE_DIVISION:
+            prefix += "from __future__ import division\n"
+        if flags & __future__.CO_FUTURE_ABSOLUTE_IMPORT:
+            prefix += "from __future__ import absolute_import\n"
+        if flags & __future__.CO_FUTURE_PRINT_FUNCTION:
+            prefix += "from __future__ import print_function\n"
+        if flags & __future__.CO_FUTURE_UNICODE_LITERALS:
+            prefix += "from __future__ import unicode_literals\n"
     p = source.find('(')
     assert p >= 0
     funcname = source[:p].strip()
     source = source[p:]
     assert source.strip()
-    funcsource = "def %s%s\n" % (funcname, source)
+    funcsource = prefix + "def %s%s\n" % (funcname, source)
     #for debugging of wrong source code: py.std.parser.suite(funcsource)
     a = applevel(funcsource, filename=filename)
     return a.interphook(funcname)
diff --git a/pypy/interpreter/test/test_gateway.py b/pypy/interpreter/test/test_gateway.py
--- a/pypy/interpreter/test/test_gateway.py
+++ b/pypy/interpreter/test/test_gateway.py
@@ -1,12 +1,13 @@
-
 # -*- coding: utf-8 -*-
 
+from __future__ import division, print_function  # for test_app2interp_future
 from pypy.interpreter import gateway, argument
 from pypy.interpreter.gateway import ObjSpace, W_Root, WrappedDefault
 from pypy.interpreter.signature import Signature
 import py
 import sys
 
+
 class FakeFunc(object):
     def __init__(self, space, name):
         self.space = space
@@ -14,6 +15,7 @@
         self.defs_w = []
         self.w_kw_defs = None
 
+
 class TestBuiltinCode:
     def test_signature(self):
         def c(space, w_x, w_y, hello_w):
@@ -90,8 +92,8 @@
         w_result = code.funcrun(FakeFunc(self.space, "c"), args)
         assert self.space.eq_w(w_result, w(1020))
 
+
 class TestGateway:
-
     def test_app2interp(self):
         w = self.space.wrap
         def app_g3(a, b):
@@ -118,6 +120,14 @@
         args = gateway.Arguments(self.space, [w(6)], ['hello', 'world'], [w(7), w(8)])
         assert self.space.int_w(gg(self.space, w(3), args)) == 213
 
+    def test_app2interp_future(self):
+        w = self.space.wrap
+        def app_g3(a, b):
+            print(end='')
+            return a / b
+        g3 = gateway.app2interp_temp(app_g3)
+        assert self.space.eq_w(g3(self.space, w(1), w(4),), w(0.25))
+
     def test_interp2app(self):
         space = self.space
         w = space.wrap
@@ -628,7 +638,7 @@
         w_app_f = self.space.wrap(app_f)
 
         assert isinstance(w_app_f.code, gateway.BuiltinCode2)
-        
+
         called = []
         fastcall_2 = w_app_f.code.fastcall_2
         def witness_fastcall_2(space, w_func, w_a, w_b):
@@ -768,7 +778,6 @@
 
 
 class TestPassThroughArguments:
-
     def test_pass_trough_arguments0(self):
         space = self.space
 
@@ -866,7 +875,6 @@
 
 
 class AppTestKeywordsToBuiltinSanity(object):
-
     def test_type(self):
         class X(object):
             def __init__(self, **kw):
@@ -905,4 +913,3 @@
 
         d.update(**{clash: 33})
         dict.update(d, **{clash: 33})
-
diff --git a/pypy/interpreter/typedef.py b/pypy/interpreter/typedef.py
--- a/pypy/interpreter/typedef.py
+++ b/pypy/interpreter/typedef.py
@@ -22,6 +22,7 @@
         else:
             bases = [__base]
         self.bases = bases
+        self.heaptype = False
         self.hasdict = '__dict__' in rawdict
         self.weakrefable = '__weakref__' in rawdict
         self.doc = rawdict.get('__doc__', None)
diff --git a/pypy/module/_ast/test/test_ast.py b/pypy/module/_ast/test/test_ast.py
--- a/pypy/module/_ast/test/test_ast.py
+++ b/pypy/module/_ast/test/test_ast.py
@@ -21,9 +21,9 @@
         assert isinstance(ast.__version__, str)
 
     def test_flags(self):
-        skip("broken")
         from copy_reg import _HEAPTYPE
-        assert self.ast.Module.__flags__ & _HEAPTYPE
+        assert self.ast.AST.__flags__ & _HEAPTYPE == 0
+        assert self.ast.Module.__flags__ & _HEAPTYPE == _HEAPTYPE
 
     def test_build_ast(self):
         ast = self.ast
@@ -239,19 +239,19 @@
         x = ast.Num()
         assert x._fields == ('n',)
         exc = raises(AttributeError, getattr, x, 'n')
-        assert "Num' object has no attribute 'n'" in exc.value.args[0]
+        assert str(exc.value) == "'Num' object has no attribute 'n'"
 
         x = ast.Num(42)
         assert x.n == 42
         exc = raises(AttributeError, getattr, x, 'lineno')
-        assert "Num' object has no attribute 'lineno'" in exc.value.args[0]
+        assert str(exc.value) == "'Num' object has no attribute 'lineno'"
 
         y = ast.Num()
         x.lineno = y
         assert x.lineno == y
 
         exc = raises(AttributeError, getattr, x, 'foobar')
-        assert "Num' object has no attribute 'foobar'" in exc.value.args[0]
+        assert str(exc.value) == "'Num' object has no attribute 'foobar'"
 
         x = ast.Num(lineno=2)
         assert x.lineno == 2
@@ -423,7 +423,7 @@
 
     def test_issue1673_Num_fullinit(self):
         import ast
-        import copy 
+        import copy
         num_node = ast.Num(n=2,lineno=2,col_offset=3)
         num_node2 = copy.deepcopy(num_node)
         assert num_node.n == num_node2.n
diff --git a/pypy/module/_cffi_backend/cbuffer.py b/pypy/module/_cffi_backend/cbuffer.py
--- a/pypy/module/_cffi_backend/cbuffer.py
+++ b/pypy/module/_cffi_backend/cbuffer.py
@@ -67,8 +67,7 @@
 
 
 MiniBuffer.typedef = TypeDef(
-    "buffer",
-    __module__ = "_cffi_backend",
+    "_cffi_backend.buffer",
     __len__ = interp2app(MiniBuffer.descr_len),
     __getitem__ = interp2app(MiniBuffer.descr_getitem),
     __setitem__ = interp2app(MiniBuffer.descr_setitem),
diff --git a/pypy/module/_cffi_backend/cdataobj.py b/pypy/module/_cffi_backend/cdataobj.py
--- a/pypy/module/_cffi_backend/cdataobj.py
+++ b/pypy/module/_cffi_backend/cdataobj.py
@@ -441,7 +441,7 @@
 
 
 W_CData.typedef = TypeDef(
-    'CData',
+    '_cffi_backend.CData',
     __module__ = '_cffi_backend',
     __name__ = '<cdata>',
     __repr__ = interp2app(W_CData.repr),
diff --git a/pypy/module/_cffi_backend/ctypearray.py b/pypy/module/_cffi_backend/ctypearray.py
--- a/pypy/module/_cffi_backend/ctypearray.py
+++ b/pypy/module/_cffi_backend/ctypearray.py
@@ -130,8 +130,7 @@
         return self.ctitem.convert_to_object(result)
 
 W_CDataIter.typedef = TypeDef(
-    'CDataIter',
-    __module__ = '_cffi_backend',
+    '_cffi_backend.CDataIter',
     __iter__ = interp2app(W_CDataIter.iter_w),
     __next__ = interp2app(W_CDataIter.next_w),
     )
diff --git a/pypy/module/_cffi_backend/ctypeobj.py b/pypy/module/_cffi_backend/ctypeobj.py
--- a/pypy/module/_cffi_backend/ctypeobj.py
+++ b/pypy/module/_cffi_backend/ctypeobj.py
@@ -210,8 +210,7 @@
 
 
 W_CType.typedef = TypeDef(
-    'CTypeDescr',
-    __module__ = '_cffi_backend',
+    '_cffi_backend.CTypeDescr',
     __repr__ = interp2app(W_CType.repr),
     __weakref__ = make_weakref_descr(W_CType),
     kind = GetSetProperty(W_CType.fget_kind, doc="kind"),
diff --git a/pypy/module/_cffi_backend/ctypestruct.py b/pypy/module/_cffi_backend/ctypestruct.py
--- a/pypy/module/_cffi_backend/ctypestruct.py
+++ b/pypy/module/_cffi_backend/ctypestruct.py
@@ -307,8 +307,7 @@
 
 
 W_CField.typedef = TypeDef(
-    'CField',
-    __module__ = '_cffi_backend',
+    '_cffi_backend.CField',
     type = interp_attrproperty('ctype', W_CField),
     offset = interp_attrproperty('offset', W_CField),
     bitshift = interp_attrproperty('bitshift', W_CField),
diff --git a/pypy/module/_cffi_backend/libraryobj.py b/pypy/module/_cffi_backend/libraryobj.py
--- a/pypy/module/_cffi_backend/libraryobj.py
+++ b/pypy/module/_cffi_backend/libraryobj.py
@@ -85,8 +85,7 @@
 
 
 W_Library.typedef = TypeDef(
-    'Library',
-    __module__ = '_cffi_backend',
+    '_cffi_backend.Library',
     __repr__ = interp2app(W_Library.repr),
     load_function = interp2app(W_Library.load_function),
     read_variable = interp2app(W_Library.read_variable),
diff --git a/pypy/module/_collections/interp_deque.py b/pypy/module/_collections/interp_deque.py
--- a/pypy/module/_collections/interp_deque.py
+++ b/pypy/module/_collections/interp_deque.py
@@ -463,11 +463,10 @@
     W_Deque.__init__(space.interp_w(W_Deque, w_self), space)
     return w_self
 
-W_Deque.typedef = TypeDef("deque",
+W_Deque.typedef = TypeDef("collections.deque",
     __doc__ = """deque(iterable[, maxlen]) --> deque object
 
 Build an ordered collection accessible from endpoints only.""",
-    __module__ = '_collections',
     __new__ = interp2app(descr__new__),
     __init__ = interp2app(W_Deque.init),
     append     = interp2app(W_Deque.append),
diff --git a/pypy/module/_collections/test/test_deque.py b/pypy/module/_collections/test/test_deque.py
--- a/pypy/module/_collections/test/test_deque.py
+++ b/pypy/module/_collections/test/test_deque.py
@@ -4,6 +4,8 @@
 
     def test_basics(self):
         from _collections import deque
+        assert deque.__module__ == 'collections'
+
         d = deque(range(-5125, -5000))
         d.__init__(range(200))
         for i in range(200, 400):
diff --git a/pypy/module/_continuation/interp_continuation.py b/pypy/module/_continuation/interp_continuation.py
--- a/pypy/module/_continuation/interp_continuation.py
+++ b/pypy/module/_continuation/interp_continuation.py
@@ -136,8 +136,7 @@
 
 
 W_Continulet.typedef = TypeDef(
-    'continulet',
-    __module__ = '_continuation',
+    '_continuation.continulet',
     __new__     = interp2app(W_Continulet___new__),
     __init__    = interp2app(W_Continulet.descr_init),
     switch      = interp2app(W_Continulet.descr_switch),
diff --git a/pypy/module/_csv/interp_csv.py b/pypy/module/_csv/interp_csv.py
--- a/pypy/module/_csv/interp_csv.py
+++ b/pypy/module/_csv/interp_csv.py
@@ -154,8 +154,7 @@
 
 
 W_Dialect.typedef = TypeDef(
-        'Dialect',
-        __module__ = '_csv',
+        '_csv.Dialect',
         __new__ = interp2app(W_Dialect___new__),
 
         delimiter        = interp_attrproperty('delimiter', W_Dialect),
diff --git a/pypy/module/_csv/interp_reader.py b/pypy/module/_csv/interp_reader.py
--- a/pypy/module/_csv/interp_reader.py
+++ b/pypy/module/_csv/interp_reader.py
@@ -238,8 +238,7 @@
     return W_Reader(space, dialect, w_iter)
 
 W_Reader.typedef = TypeDef(
-        'reader',
-        __module__ = '_csv',
+        '_csv.reader',
         dialect = interp_attrproperty_w('dialect', W_Reader),
         line_num = interp_attrproperty('line_num', W_Reader),
         __iter__ = interp2app(W_Reader.iter_w),
diff --git a/pypy/module/_csv/interp_writer.py b/pypy/module/_csv/interp_writer.py
--- a/pypy/module/_csv/interp_writer.py
+++ b/pypy/module/_csv/interp_writer.py
@@ -160,8 +160,7 @@
     return W_Writer(space, dialect, w_fileobj)
 
 W_Writer.typedef = TypeDef(
-        'writer',
-        __module__ = '_csv',
+        '_csv.writer',
         dialect = interp_attrproperty_w('dialect', W_Writer),
         writerow = interp2app(W_Writer.writerow),
         writerows = interp2app(W_Writer.writerows),
diff --git a/pypy/module/_io/interp_bufferedio.py b/pypy/module/_io/interp_bufferedio.py
--- a/pypy/module/_io/interp_bufferedio.py
+++ b/pypy/module/_io/interp_bufferedio.py
@@ -217,17 +217,16 @@
         return space.call_method(self.w_raw, "isatty")
 
     def repr_w(self, space):
-        typename = space.type(self).getname(space)
-        module = space.unicode_w(space.type(self).get_module())
+        typename = space.type(self).name.decode('utf-8')
         try:
             w_name = space.getattr(self, space.wrap("name"))
         except OperationError, e:
             if not e.match(space, space.w_AttributeError):
                 raise
-            return space.wrap(u"<%s.%s>" % (module, typename,))
+            return space.wrap(u"<%s>" % (typename,))
         else:
             name_repr = space.unicode_w(space.repr(w_name))
-            return space.wrap(u"<%s.%s name=%s>" % (module, typename, name_repr))
+            return space.wrap(u"<%s name=%s>" % (typename, name_repr))
 
     # ______________________________________________
 
@@ -854,11 +853,10 @@
         self.state = STATE_OK
 
 W_BufferedReader.typedef = TypeDef(
-    'BufferedReader', W_BufferedIOBase.typedef,
+    '_io.BufferedReader', W_BufferedIOBase.typedef,
     __new__ = generic_new_descr(W_BufferedReader),
     __init__  = interp2app(W_BufferedReader.descr_init),
     __getstate__ = interp2app(W_BufferedReader.getstate_w),
-    __module__ = "_io",
 
     read = interp2app(W_BufferedReader.read_w),
     peek = interp2app(W_BufferedReader.peek_w),
@@ -903,11 +901,10 @@
         self.state = STATE_OK
 
 W_BufferedWriter.typedef = TypeDef(
-    'BufferedWriter', W_BufferedIOBase.typedef,
+    '_io.BufferedWriter', W_BufferedIOBase.typedef,
     __new__ = generic_new_descr(W_BufferedWriter),
     __init__  = interp2app(W_BufferedWriter.descr_init),
     __getstate__ = interp2app(W_BufferedWriter.getstate_w),
-    __module__ = "_io",
 
     write = interp2app(W_BufferedWriter.write_w),
     flush = interp2app(W_BufferedWriter.flush_w),
@@ -1028,11 +1025,10 @@
         self.state = STATE_OK
 
 W_BufferedRandom.typedef = TypeDef(
-    'BufferedRandom', W_BufferedIOBase.typedef,
+    '_io.BufferedRandom', W_BufferedIOBase.typedef,
     __new__ = generic_new_descr(W_BufferedRandom),
     __init__ = interp2app(W_BufferedRandom.descr_init),
     __getstate__ = interp2app(W_BufferedRandom.getstate_w),
-    __module__ = "_io",
 
     read = interp2app(W_BufferedRandom.read_w),
     peek = interp2app(W_BufferedRandom.peek_w),
diff --git a/pypy/module/_io/interp_stringio.py b/pypy/module/_io/interp_stringio.py
--- a/pypy/module/_io/interp_stringio.py
+++ b/pypy/module/_io/interp_stringio.py
@@ -264,8 +264,7 @@
 
 
 W_StringIO.typedef = TypeDef(
-    'StringIO', W_TextIOBase.typedef,
-    __module__ = "_io",
+    '_io.StringIO', W_TextIOBase.typedef,
     __new__  = generic_new_descr(W_StringIO),
     __init__ = interp2app(W_StringIO.descr_init),
     __getstate__ = interp2app(W_StringIO.descr_getstate),
diff --git a/pypy/module/_io/interp_textio.py b/pypy/module/_io/interp_textio.py
--- a/pypy/module/_io/interp_textio.py
+++ b/pypy/module/_io/interp_textio.py
@@ -1049,13 +1049,12 @@
         self.chunk_size = size
 
 W_TextIOWrapper.typedef = TypeDef(
-    'TextIOWrapper', W_TextIOBase.typedef,
+    '_io.TextIOWrapper', W_TextIOBase.typedef,
     __new__ = generic_new_descr(W_TextIOWrapper),
     __init__  = interp2app(W_TextIOWrapper.descr_init),
     __repr__ = interp2app(W_TextIOWrapper.descr_repr),
     __next__ = interp2app(W_TextIOWrapper.next_w),
     __getstate__ = interp2app(W_TextIOWrapper.getstate_w),
-    __module__ = "_io",
 
     read = interp2app(W_TextIOWrapper.read_w),
     readline = interp2app(W_TextIOWrapper.readline_w),
diff --git a/pypy/module/_lsprof/interp_lsprof.py b/pypy/module/_lsprof/interp_lsprof.py
--- a/pypy/module/_lsprof/interp_lsprof.py
+++ b/pypy/module/_lsprof/interp_lsprof.py
@@ -199,7 +199,7 @@
         if isinstance(w_type, W_TypeObject):
             w_realclass, _ = space.lookup_in_type_where(w_type, name)
             if isinstance(w_realclass, W_TypeObject):
-                class_name = w_realclass.get_module_type_name()
+                class_name = w_realclass.name
     else:
         name = '?'
     if class_name is None:
diff --git a/pypy/module/_multibytecodec/interp_incremental.py b/pypy/module/_multibytecodec/interp_incremental.py
--- a/pypy/module/_multibytecodec/interp_incremental.py
+++ b/pypy/module/_multibytecodec/interp_incremental.py
@@ -75,7 +75,6 @@
 
 MultibyteIncrementalDecoder.typedef = TypeDef(
     'MultibyteIncrementalDecoder',
-    __module__ = '_multibytecodec',
     __new__ = interp2app(mbidecoder_new),
     decode  = interp2app(MultibyteIncrementalDecoder.decode_w),
     reset   = interp2app(MultibyteIncrementalDecoder.reset_w),
@@ -124,7 +123,6 @@
 
 MultibyteIncrementalEncoder.typedef = TypeDef(
     'MultibyteIncrementalEncoder',
-    __module__ = '_multibytecodec',
     __new__ = interp2app(mbiencoder_new),
     encode  = interp2app(MultibyteIncrementalEncoder.encode_w),
     reset   = interp2app(MultibyteIncrementalEncoder.reset_w),
diff --git a/pypy/module/_multibytecodec/interp_multibytecodec.py b/pypy/module/_multibytecodec/interp_multibytecodec.py
--- a/pypy/module/_multibytecodec/interp_multibytecodec.py
+++ b/pypy/module/_multibytecodec/interp_multibytecodec.py
@@ -46,7 +46,6 @@
 
 MultibyteCodec.typedef = TypeDef(
     'MultibyteCodec',
-    __module__ = '_multibytecodec',
     decode = interp2app(MultibyteCodec.decode),
     encode = interp2app(MultibyteCodec.encode),
     )
diff --git a/pypy/module/_multiprocessing/interp_connection.py b/pypy/module/_multiprocessing/interp_connection.py
--- a/pypy/module/_multiprocessing/interp_connection.py
+++ b/pypy/module/_multiprocessing/interp_connection.py
@@ -354,9 +354,8 @@
         return bool(r)
 
 W_FileConnection.typedef = TypeDef(
-    'Connection', W_BaseConnection.typedef,
+    '_multiprocessing.Connection', W_BaseConnection.typedef,
     __new__ = interp2app(W_FileConnection.descr_new_file.im_func),
-    __module__ = '_multiprocessing',
     fileno = interp2app(W_FileConnection.fileno),
 )
 
@@ -535,8 +534,7 @@
 
 if sys.platform == 'win32':
     W_PipeConnection.typedef = TypeDef(
-        'PipeConnection', W_BaseConnection.typedef,
+        '_multiprocessing.PipeConnection', W_BaseConnection.typedef,
         __new__ = interp2app(W_PipeConnection.descr_new_pipe.im_func),
-        __module__ = '_multiprocessing',
         fileno = interp2app(W_PipeConnection.fileno),
     )
diff --git a/pypy/module/_socket/interp_socket.py b/pypy/module/_socket/interp_socket.py
--- a/pypy/module/_socket/interp_socket.py
+++ b/pypy/module/_socket/interp_socket.py
@@ -612,8 +612,7 @@
     method = getattr(W_RSocket, methodname + '_w')
     socketmethods[methodname] = interp2app(method)
 
-W_RSocket.typedef = TypeDef("socket",
-    __module__ = "_socket",
+W_RSocket.typedef = TypeDef("_socket.socket",
     __doc__ = """\
 socket([family[, type[, proto]]]) -> socket object
 
diff --git a/pypy/module/array/interp_array.py b/pypy/module/array/interp_array.py
--- a/pypy/module/array/interp_array.py
+++ b/pypy/module/array/interp_array.py
@@ -530,9 +530,8 @@
             return space.wrap(s)
 
 W_ArrayBase.typedef = TypeDef(
-    'array',
+    'array.array',
     __new__ = interp2app(w_array),
-    __module__ = 'array',
 
     __len__ = interp2app(W_ArrayBase.descr_len),
     __eq__ = interp2app(W_ArrayBase.descr_eq),
diff --git a/pypy/module/cppyy/capi/capi_types.py b/pypy/module/cppyy/capi/capi_types.py
--- a/pypy/module/cppyy/capi/capi_types.py
+++ b/pypy/module/cppyy/capi/capi_types.py
@@ -1,8 +1,8 @@
 from rpython.rtyper.lltypesystem import rffi, lltype
 
 # shared ll definitions
-_C_OPAQUE_PTR = rffi.LONG
-_C_OPAQUE_NULL = lltype.nullptr(rffi.LONGP.TO)# ALT: _C_OPAQUE_PTR.TO
+_C_OPAQUE_PTR = rffi.ULONG
+_C_OPAQUE_NULL = lltype.nullptr(rffi.ULONGP.TO)# ALT: _C_OPAQUE_PTR.TO
 
 C_SCOPE = _C_OPAQUE_PTR
 C_NULL_SCOPE = rffi.cast(C_SCOPE, _C_OPAQUE_NULL)
diff --git a/pypy/module/cppyy/capi/cint_capi.py b/pypy/module/cppyy/capi/cint_capi.py
--- a/pypy/module/cppyy/capi/cint_capi.py
+++ b/pypy/module/cppyy/capi/cint_capi.py
@@ -249,7 +249,7 @@
 
 def activate_branch(space, w_branch):
     w_branches = space.call_method(w_branch, "GetListOfBranches")
-    for i in range(space.int_w(space.call_method(w_branches, "GetEntriesFast"))):
+    for i in range(space.r_longlong_w(space.call_method(w_branches, "GetEntriesFast"))):
         w_b = space.call_method(w_branches, "At", space.wrap(i))
         activate_branch(space, w_b)
     space.call_method(w_branch, "SetStatus", space.wrap(1))
@@ -292,7 +292,7 @@
     activate_branch(space, w_branch)
 
     # figure out from where we're reading
-    entry = space.int_w(space.call_method(w_self, "GetReadEntry"))
+    entry = space.r_longlong_w(space.call_method(w_self, "GetReadEntry"))
     if entry == -1:
         entry = 0
 
@@ -341,7 +341,7 @@
         self.w_tree = w_tree
 
         self.current  = 0
-        self.maxentry = space.int_w(space.call_method(w_tree, "GetEntriesFast"))
+        self.maxentry = space.r_longlong_w(space.call_method(w_tree, "GetEntriesFast"))
 
         space = self.space = tree.space          # holds the class cache in State
         space.call_method(w_tree, "SetBranchStatus", space.wrap("*"), space.wrap(0))
diff --git a/pypy/module/cppyy/capi/loadable_capi.py b/pypy/module/cppyy/capi/loadable_capi.py
--- a/pypy/module/cppyy/capi/loadable_capi.py
+++ b/pypy/module/cppyy/capi/loadable_capi.py
@@ -21,10 +21,11 @@
 
 class _Arg:         # poor man's union
     _immutable_ = True
-    def __init__(self, l = 0, s = '', vp = rffi.cast(rffi.VOIDP, 0) ):
-        self._long = l
+    def __init__(self, h = 0, l = -1, s = '', vp = rffi.cast(rffi.VOIDP, 0)):
+        self._handle = h
+        self._long   = l
         self._string = s
-        self._voidp = vp
+        self._voidp  = vp
 
 # For the loadable CAPI, the calls start and end in RPython. Therefore, the standard
 # _call of W_CTypeFunc, which expects wrapped objects, does not quite work: some
@@ -57,7 +58,7 @@
                 if isinstance(argtype, ctypeprim.W_CTypePrimitiveSigned):
                     misc.write_raw_signed_data(data, rffi.cast(rffi.LONG, obj._long), argtype.size)
                 elif isinstance(argtype, ctypeprim.W_CTypePrimitiveUnsigned):
-                    misc.write_raw_unsigned_data(data, rffi.cast(rffi.ULONG, obj._long), argtype.size)
+                    misc.write_raw_unsigned_data(data, rffi.cast(rffi.ULONG, obj._handle), argtype.size)
                 elif obj._voidp != rffi.cast(rffi.VOIDP, 0):
                     data = rffi.cast(rffi.VOIDPP, data)
                     data[0] = obj._voidp
@@ -91,7 +92,7 @@
 
         # TODO: the following need to match up with the globally defined C_XYZ low-level
         # types (see capi/__init__.py), but by using strings here, that isn't guaranteed
-        c_opaque_ptr = nt.new_primitive_type(space, 'long')
+        c_opaque_ptr = nt.new_primitive_type(space, 'unsigned long')
  
         c_scope  = c_opaque_ptr
         c_type   = c_scope
@@ -116,6 +117,8 @@
         c_voidp  = nt.new_pointer_type(space, c_void)
         c_size_t = nt.new_primitive_type(space, 'size_t')
 
+        c_ptrdiff_t = nt.new_primitive_type(space, 'ptrdiff_t')
+
         self.capi_call_ifaces = {
             # name to opaque C++ scope representation
             'num_scopes'               : ([c_scope],                  c_int),
@@ -152,7 +155,7 @@
             'get_methptr_getter'       : ([c_scope, c_index],         c_voidp), # TODO: verify
 
             # handling of function argument buffer
-            'allocate_function_args'   : ([c_size_t],                 c_voidp),
+            'allocate_function_args'   : ([c_int],                    c_voidp),
             'deallocate_function_args' : ([c_voidp],                  c_void),
             'function_arg_sizeof'      : ([],                         c_size_t),
             'function_arg_typeoffset'  : ([],                         c_size_t),
@@ -169,7 +172,7 @@
             'base_name'                : ([c_type, c_int],            c_ccharp),
             'is_subtype'               : ([c_type, c_type],           c_int),
 
-            'base_offset'              : ([c_type, c_type, c_object, c_int],    c_long),
+            'base_offset'              : ([c_type, c_type, c_object, c_int],    c_ptrdiff_t),
 
             # method/function reflection information
             'num_methods'              : ([c_scope],                  c_int),
@@ -199,7 +202,7 @@
             'num_datamembers'          : ([c_scope],                  c_int),
             'datamember_name'          : ([c_scope, c_int],           c_ccharp),
             'datamember_type'          : ([c_scope, c_int],           c_ccharp),
-            'datamember_offset'        : ([c_scope, c_int],           c_size_t),
+            'datamember_offset'        : ([c_scope, c_int],           c_ptrdiff_t),
 
             'datamember_index'         : ([c_scope, c_ccharp],        c_int),
 
@@ -259,10 +262,13 @@
     return c_call.ctype.rcall(c_call._cdata, args)
 
 def _cdata_to_cobject(space, w_cdata):
-    return rffi.cast(C_OBJECT, space.int_w(w_cdata))
+    return rffi.cast(C_OBJECT, space.uint_w(w_cdata))
 
 def _cdata_to_size_t(space, w_cdata):
-    return rffi.cast(rffi.SIZE_T, space.int_w(w_cdata))
+    return rffi.cast(rffi.SIZE_T, space.uint_w(w_cdata))
+
+def _cdata_to_ptrdiff_t(space, w_cdata):
+    return rffi.cast(rffi.LONG, space.int_w(w_cdata))
 
 def _cdata_to_ptr(space, w_cdata): # TODO: this is both a hack and dreadfully slow
     return rffi.cast(rffi.VOIDP,
@@ -273,74 +279,74 @@
 
 # name to opaque C++ scope representation ------------------------------------
 def c_num_scopes(space, cppscope):
-    return space.int_w(call_capi(space, 'num_scopes', [_Arg(l=cppscope.handle)]))
+    return space.int_w(call_capi(space, 'num_scopes', [_Arg(h=cppscope.handle)]))
 def c_scope_name(space, cppscope, iscope):
-    args = [_Arg(l=cppscope.handle), _Arg(l=iscope)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=iscope)]
     return charp2str_free(space, call_capi(space, 'scope_name', args))
 
 def c_resolve_name(space, name):
     return charp2str_free(space, call_capi(space, 'resolve_name', [_Arg(s=name)]))
 def c_get_scope_opaque(space, name):
-    return rffi.cast(C_SCOPE, space.int_w(call_capi(space, 'get_scope', [_Arg(s=name)])))
+    return rffi.cast(C_SCOPE, space.uint_w(call_capi(space, 'get_scope', [_Arg(s=name)])))
 def c_get_template(space, name):
-    return rffi.cast(C_TYPE, space.int_w(call_capi(space, 'get_template', [_Arg(s=name)])))
+    return rffi.cast(C_TYPE, space.uint_w(call_capi(space, 'get_template', [_Arg(s=name)])))
 def c_actual_class(space, cppclass, cppobj):
-    args = [_Arg(l=cppclass.handle), _Arg(l=cppobj)]
-    return rffi.cast(C_TYPE, space.int_w(call_capi(space, 'actual_class', args)))
+    args = [_Arg(h=cppclass.handle), _Arg(h=cppobj)]
+    return rffi.cast(C_TYPE, space.uint_w(call_capi(space, 'actual_class', args)))
 
 # memory management ----------------------------------------------------------
 def c_allocate(space, cppclass):
-    return _cdata_to_cobject(space, call_capi(space, 'allocate', [_Arg(l=cppclass.handle)]))
+    return _cdata_to_cobject(space, call_capi(space, 'allocate', [_Arg(h=cppclass.handle)]))
 def c_deallocate(space, cppclass, cppobject):
-    call_capi(space, 'deallocate', [_Arg(l=cppclass.handle), _Arg(l=cppobject)])
+    call_capi(space, 'deallocate', [_Arg(h=cppclass.handle), _Arg(h=cppobject)])
 def c_destruct(space, cppclass, cppobject):
-    call_capi(space, 'destruct', [_Arg(l=cppclass.handle), _Arg(l=cppobject)])
+    call_capi(space, 'destruct', [_Arg(h=cppclass.handle), _Arg(h=cppobject)])
 
 # method/function dispatching ------------------------------------------------
 def c_call_v(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     call_capi(space, 'call_v', args)
 def c_call_b(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
-    return rffi.cast(rffi.UCHAR, space.c_int_w(call_capi(space, 'call_b', args)))
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    return rffi.cast(rffi.UCHAR, space.c_uint_w(call_capi(space, 'call_b', args)))
 def c_call_c(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     return rffi.cast(rffi.CHAR, space.str_w(call_capi(space, 'call_c', args))[0])
 def c_call_h(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     return rffi.cast(rffi.SHORT, space.int_w(call_capi(space, 'call_h', args)))
 def c_call_i(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     return rffi.cast(rffi.INT, space.c_int_w(call_capi(space, 'call_i', args)))
 def c_call_l(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     return rffi.cast(rffi.LONG, space.int_w(call_capi(space, 'call_l', args)))
 def c_call_ll(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     return rffi.cast(rffi.LONGLONG, space.r_longlong_w(call_capi(space, 'call_ll', args)))
 def c_call_f(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     return rffi.cast(rffi.FLOAT, r_singlefloat(space.float_w(call_capi(space, 'call_f', args))))
 def c_call_d(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     return rffi.cast(rffi.DOUBLE, space.float_w(call_capi(space, 'call_d', args)))
 
 def c_call_r(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     return _cdata_to_ptr(space, call_capi(space, 'call_r', args))
 def c_call_s(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     return call_capi(space, 'call_s', args)
 
 def c_constructor(space, cppmethod, cppobject, nargs, cargs):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs)]
     return _cdata_to_cobject(space, call_capi(space, 'constructor', args))
 def c_call_o(space, cppmethod, cppobject, nargs, cargs, cppclass):
-    args = [_Arg(l=cppmethod), _Arg(l=cppobject), _Arg(l=nargs), _Arg(vp=cargs), _Arg(l=cppclass.handle)]
+    args = [_Arg(h=cppmethod), _Arg(h=cppobject), _Arg(l=nargs), _Arg(vp=cargs), _Arg(h=cppclass.handle)]
     return _cdata_to_cobject(space, call_capi(space, 'call_o', args))
 
 def c_get_methptr_getter(space, cppscope, index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=index)]
     return rffi.cast(C_METHPTRGETTER_PTR,
         _cdata_to_ptr(space, call_capi(space, 'get_methptr_getter', args)))
 
@@ -358,47 +364,47 @@
 
 # scope reflection information -----------------------------------------------
 def c_is_namespace(space, scope):
-    return space.bool_w(call_capi(space, 'is_namespace', [_Arg(l=scope)]))
+    return space.bool_w(call_capi(space, 'is_namespace', [_Arg(h=scope)]))
 def c_is_enum(space, name):
     return space.bool_w(call_capi(space, 'is_enum', [_Arg(s=name)]))
 
 # type/class reflection information ------------------------------------------
 def c_final_name(space, cpptype):
-    return charp2str_free(space, call_capi(space, 'final_name', [_Arg(l=cpptype)]))
+    return charp2str_free(space, call_capi(space, 'final_name', [_Arg(h=cpptype)]))
 def c_scoped_final_name(space, cpptype):
-    return charp2str_free(space, call_capi(space, 'scoped_final_name', [_Arg(l=cpptype)]))
+    return charp2str_free(space, call_capi(space, 'scoped_final_name', [_Arg(h=cpptype)]))
 def c_has_complex_hierarchy(space, handle):
-    return space.bool_w(call_capi(space, 'has_complex_hierarchy', [_Arg(l=handle)]))
+    return space.bool_w(call_capi(space, 'has_complex_hierarchy', [_Arg(h=handle)]))
 def c_num_bases(space, cppclass):
-    return space.int_w(call_capi(space, 'num_bases', [_Arg(l=cppclass.handle)]))
+    return space.int_w(call_capi(space, 'num_bases', [_Arg(h=cppclass.handle)]))
 def c_base_name(space, cppclass, base_index):
-    args = [_Arg(l=cppclass.handle), _Arg(l=base_index)]
+    args = [_Arg(h=cppclass.handle), _Arg(l=base_index)]
     return charp2str_free(space, call_capi(space, 'base_name', args))
 def c_is_subtype(space, derived, base):
     jit.promote(base)
     if derived == base:
         return bool(1)
-    return space.bool_w(call_capi(space, 'is_subtype', [_Arg(l=derived.handle), _Arg(l=base.handle)]))
+    return space.bool_w(call_capi(space, 'is_subtype', [_Arg(h=derived.handle), _Arg(h=base.handle)]))
 
 def _c_base_offset(space, derived_h, base_h, address, direction):
-    args = [_Arg(l=derived_h), _Arg(l=base_h), _Arg(l=address), _Arg(l=direction)]
-    return _cdata_to_size_t(space, call_capi(space, 'base_offset', args))
+    args = [_Arg(h=derived_h), _Arg(h=base_h), _Arg(h=address), _Arg(l=direction)]
+    return _cdata_to_ptrdiff_t(space, call_capi(space, 'base_offset', args))
 def c_base_offset(space, derived, base, address, direction):
     if derived == base:
-        return rffi.cast(rffi.SIZE_T, 0)
+        return rffi.cast(rffi.LONG, 0)
     return _c_base_offset(space, derived.handle, base.handle, address, direction)
 def c_base_offset1(space, derived_h, base, address, direction):
     return _c_base_offset(space, derived_h, base.handle, address, direction)
 
 # method/function reflection information -------------------------------------
 def c_num_methods(space, cppscope):
-    args = [_Arg(l=cppscope.handle)]
+    args = [_Arg(h=cppscope.handle)]
     return space.int_w(call_capi(space, 'num_methods', args))
 def c_method_index_at(space, cppscope, imethod):
-    args = [_Arg(l=cppscope.handle), _Arg(l=imethod)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=imethod)]
     return space.int_w(call_capi(space, 'method_index_at', args))
 def c_method_indices_from_name(space, cppscope, name):
-    args = [_Arg(l=cppscope.handle), _Arg(s=name)]
+    args = [_Arg(h=cppscope.handle), _Arg(s=name)]
     indices = rffi.cast(C_INDEX_ARRAY,
                         _cdata_to_ptr(space, call_capi(space, 'method_indices_from_name', args)))
     if not indices:
@@ -414,36 +420,36 @@
     return py_indices
 
 def c_method_name(space, cppscope, index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=index)]
     return charp2str_free(space, call_capi(space, 'method_name', args))
 def c_method_result_type(space, cppscope, index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=index)]
     return charp2str_free(space, call_capi(space, 'method_result_type', args))
 def c_method_num_args(space, cppscope, index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=index)]
     return space.int_w(call_capi(space, 'method_num_args', args))
 def c_method_req_args(space, cppscope, index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=index)]
     return space.int_w(call_capi(space, 'method_req_args', args))
 def c_method_arg_type(space, cppscope, index, arg_index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index), _Arg(l=arg_index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=index), _Arg(l=arg_index)]
     return charp2str_free(space, call_capi(space, 'method_arg_type', args))
 def c_method_arg_default(space, cppscope, index, arg_index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index), _Arg(l=arg_index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=index), _Arg(l=arg_index)]
     return charp2str_free(space, call_capi(space, 'method_arg_default', args))
 def c_method_signature(space, cppscope, index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=index)]
     return charp2str_free(space, call_capi(space, 'method_signature', args))
 
 def c_method_is_template(space, cppscope, index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=index)]
     return space.bool_w(call_capi(space, 'method_is_template', args))
 def _c_method_num_template_args(space, cppscope, index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=index)]
     return space.int_w(call_capi(space, 'method_num_template_args', args)) 
 def c_template_args(space, cppscope, index):
     nargs = _c_method_num_template_args(space, cppscope, index)
-    arg1 = _Arg(l=cppscope.handle)
+    arg1 = _Arg(h=cppscope.handle)
     arg2 = _Arg(l=index)
     args = [c_resolve_name(space, charp2str_free(space,
                 call_capi(space, 'method_template_arg_name', [arg1, arg2, _Arg(l=iarg)]))
@@ -451,45 +457,45 @@
     return args
 
 def c_get_method(space, cppscope, index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=index)]
-    return rffi.cast(C_METHOD, space.int_w(call_capi(space, 'get_method', args)))
+    args = [_Arg(h=cppscope.handle), _Arg(l=index)]
+    return rffi.cast(C_METHOD, space.uint_w(call_capi(space, 'get_method', args)))
 def c_get_global_operator(space, nss, lc, rc, op):
     if nss is not None:
-        args = [_Arg(l=nss.handle), _Arg(l=lc.handle), _Arg(l=rc.handle), _Arg(s=op)]
+        args = [_Arg(h=nss.handle), _Arg(h=lc.handle), _Arg(h=rc.handle), _Arg(s=op)]
         return rffi.cast(WLAVC_INDEX, space.int_w(call_capi(space, 'get_global_operator', args)))
     return rffi.cast(WLAVC_INDEX, -1)
 
 # method properties ----------------------------------------------------------
 def c_is_constructor(space, cppclass, index):
-    args = [_Arg(l=cppclass.handle), _Arg(l=index)]
+    args = [_Arg(h=cppclass.handle), _Arg(l=index)]
     return space.bool_w(call_capi(space, 'is_constructor', args))
 def c_is_staticmethod(space, cppclass, index):
-    args = [_Arg(l=cppclass.handle), _Arg(l=index)]
+    args = [_Arg(h=cppclass.handle), _Arg(l=index)]
     return space.bool_w(call_capi(space, 'is_staticmethod', args))
 
 # data member reflection information -----------------------------------------
 def c_num_datamembers(space, cppscope):
-    return space.int_w(call_capi(space, 'num_datamembers', [_Arg(l=cppscope.handle)]))
+    return space.int_w(call_capi(space, 'num_datamembers', [_Arg(h=cppscope.handle)]))
 def c_datamember_name(space, cppscope, datamember_index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=datamember_index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=datamember_index)]
     return charp2str_free(space, call_capi(space, 'datamember_name', args))
 def c_datamember_type(space, cppscope, datamember_index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=datamember_index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=datamember_index)]
     return  charp2str_free(space, call_capi(space, 'datamember_type', args))
 def c_datamember_offset(space, cppscope, datamember_index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=datamember_index)]
-    return _cdata_to_size_t(space, call_capi(space, 'datamember_offset', args))
+    args = [_Arg(h=cppscope.handle), _Arg(l=datamember_index)]
+    return _cdata_to_ptrdiff_t(space, call_capi(space, 'datamember_offset', args))
 
 def c_datamember_index(space, cppscope, name):
-    args = [_Arg(l=cppscope.handle), _Arg(s=name)]
+    args = [_Arg(h=cppscope.handle), _Arg(s=name)]
     return space.int_w(call_capi(space, 'datamember_index', args))
 
 # data member properties -----------------------------------------------------
 def c_is_publicdata(space, cppscope, datamember_index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=datamember_index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=datamember_index)]
     return space.bool_w(call_capi(space, 'is_publicdata', args))
 def c_is_staticdata(space, cppscope, datamember_index):
-    args = [_Arg(l=cppscope.handle), _Arg(l=datamember_index)]
+    args = [_Arg(h=cppscope.handle), _Arg(l=datamember_index)]
     return space.bool_w(call_capi(space, 'is_staticdata', args))
 
 # misc helpers ---------------------------------------------------------------
@@ -509,7 +515,7 @@
 def c_charp2stdstring(space, svalue):
     return _cdata_to_cobject(space, call_capi(space, 'charp2stdstring', [_Arg(s=svalue)]))
 def c_stdstring2stdstring(space, cppobject):
-    return _cdata_to_cobject(space, call_capi(space, 'stdstring2stdstring', [_Arg(l=cppobject)]))
+    return _cdata_to_cobject(space, call_capi(space, 'stdstring2stdstring', [_Arg(h=cppobject)]))
 
 # loadable-capi-specific pythonizations (none, as the capi isn't known until runtime)
 def register_pythonizations(space):
diff --git a/pypy/module/cppyy/converter.py b/pypy/module/cppyy/converter.py
--- a/pypy/module/cppyy/converter.py
+++ b/pypy/module/cppyy/converter.py
@@ -386,7 +386,7 @@
             try:
                 # TODO: accept a 'capsule' rather than naked int
                 # (do accept int(0), though)
-                obj = rffi.cast(rffi.VOIDP, space.int_w(w_obj))
+                obj = rffi.cast(rffi.VOIDP, space.uint_w(w_obj))
             except Exception:
                 obj = rffi.cast(rffi.VOIDP, get_rawobject(space, w_obj))
         return obj
diff --git a/pypy/module/cppyy/ffitypes.py b/pypy/module/cppyy/ffitypes.py
--- a/pypy/module/cppyy/ffitypes.py
+++ b/pypy/module/cppyy/ffitypes.py
@@ -102,7 +102,7 @@
     _immutable_fields_ = ['libffitype', 'c_type', 'c_ptrtype']
 
     libffitype  = jit_libffi.types.slong
-    c_type      =  rffi.LONG
+    c_type      = rffi.LONG
     c_ptrtype   = rffi.LONGP
 
     def _unwrap_object(self, space, w_obj):
diff --git a/pypy/module/cppyy/include/capi.h b/pypy/module/cppyy/include/capi.h
--- a/pypy/module/cppyy/include/capi.h
+++ b/pypy/module/cppyy/include/capi.h
@@ -7,10 +7,10 @@
 extern "C" {
 #endif // ifdef __cplusplus
 
-    typedef long cppyy_scope_t;
+    typedef unsigned long cppyy_scope_t;
     typedef cppyy_scope_t cppyy_type_t;
-    typedef long cppyy_object_t;
-    typedef long cppyy_method_t;
+    typedef unsigned long cppyy_object_t;
+    typedef unsigned long cppyy_method_t;
     typedef long cppyy_index_t;
     typedef void* (*cppyy_methptrgetter_t)(cppyy_object_t);
 
@@ -48,7 +48,7 @@
     cppyy_methptrgetter_t cppyy_get_methptr_getter(cppyy_scope_t scope, cppyy_index_t idx);
 
     /* handling of function argument buffer ----------------------------------- */
-    void*  cppyy_allocate_function_args(size_t nargs);
+    void*  cppyy_allocate_function_args(int nargs);
     void   cppyy_deallocate_function_args(void* args);
     size_t cppyy_function_arg_sizeof();
     size_t cppyy_function_arg_typeoffset();
@@ -66,7 +66,7 @@
     int cppyy_is_subtype(cppyy_type_t derived, cppyy_type_t base);
 
     /* calculate offsets between declared and actual type, up-cast: direction > 0; down-cast: direction < 0 */
-    size_t cppyy_base_offset(cppyy_type_t derived, cppyy_type_t base, cppyy_object_t address, int direction);
+    ptrdiff_t cppyy_base_offset(cppyy_type_t derived, cppyy_type_t base, cppyy_object_t address, int direction);
 
     /* method/function reflection information --------------------------------- */
     int cppyy_num_methods(cppyy_scope_t scope);
@@ -97,7 +97,7 @@
     int cppyy_num_datamembers(cppyy_scope_t scope);
     char* cppyy_datamember_name(cppyy_scope_t scope, int datamember_index);
     char* cppyy_datamember_type(cppyy_scope_t scope, int datamember_index);
-    size_t cppyy_datamember_offset(cppyy_scope_t scope, int datamember_index);
+    ptrdiff_t cppyy_datamember_offset(cppyy_scope_t scope, int datamember_index);
 
     int cppyy_datamember_index(cppyy_scope_t scope, const char* name);
 
diff --git a/pypy/module/cppyy/interp_cppyy.py b/pypy/module/cppyy/interp_cppyy.py
--- a/pypy/module/cppyy/interp_cppyy.py
+++ b/pypy/module/cppyy/interp_cppyy.py
@@ -593,7 +593,7 @@
     @unwrap_spec(args_w='args_w')
     def call(self, w_cppinstance, args_w):
         w_result = W_CPPOverload.call(self, w_cppinstance, args_w)
-        newthis = rffi.cast(capi.C_OBJECT, self.space.int_w(w_result))
+        newthis = rffi.cast(capi.C_OBJECT, self.space.uint_w(w_result))
         cppinstance = self.space.interp_w(W_CPPInstance, w_cppinstance, can_be_None=True)
         if cppinstance is not None:
             cppinstance._rawobject = newthis
diff --git a/pypy/module/cppyy/src/cintcwrapper.cxx b/pypy/module/cppyy/src/cintcwrapper.cxx
--- a/pypy/module/cppyy/src/cintcwrapper.cxx
+++ b/pypy/module/cppyy/src/cintcwrapper.cxx
@@ -520,12 +520,12 @@
 
 
 /* handling of function argument buffer ----------------------------------- */
-void* cppyy_allocate_function_args(size_t nargs) {
+void* cppyy_allocate_function_args(int nargs) {
     assert(sizeof(CPPYY_G__value) == sizeof(G__value));
     G__param* libp = (G__param*)malloc(
         offsetof(G__param, para) + nargs*sizeof(CPPYY_G__value));
     libp->paran = (int)nargs;
-    for (size_t i = 0; i < nargs; ++i)
+    for (int i = 0; i < nargs; ++i)
         libp->para[i].type = 'l';
     return (void*)libp->para;
 }
@@ -613,7 +613,7 @@
     return derived_type->GetBaseClass(base_type) != 0;
 }
 
-size_t cppyy_base_offset(cppyy_type_t derived_handle, cppyy_type_t base_handle,
+ptrdiff_t cppyy_base_offset(cppyy_type_t derived_handle, cppyy_type_t base_handle,
                        cppyy_object_t address, int /* direction */) {
     R__LOCKGUARD2(gCINTMutex);
 
@@ -642,7 +642,7 @@
          }
     }
 
-    return (size_t) offset;   // may be negative (will roll over)
+    return (ptrdiff_t) offset;   // may be negative (will roll over)
 }
 
 
@@ -941,16 +941,16 @@
     return cppstring_to_cstring(gbl.GetFullTypeName());
 }
 
-size_t cppyy_datamember_offset(cppyy_scope_t handle, int datamember_index) {
+ptrdiff_t cppyy_datamember_offset(cppyy_scope_t handle, int datamember_index) {
     R__LOCKGUARD2(gCINTMutex);
     TClassRef& cr = type_from_handle(handle);
     if (cr.GetClass()) {
         TDataMember* m = (TDataMember*)cr->GetListOfDataMembers()->At(datamember_index);
-        return (size_t)m->GetOffsetCint();


More information about the pypy-commit mailing list