Rename pure None to pyston_None, and use Py_None as much as possible. …

When try to support tk. The Py_None is a wrapper of pyston `None`. It
will conflict with other library's None. So rename the pure pyston
`None` to pyston_None. And use Py_None instead pyston_None when
possible. Just like dropbox#1231 for Py_True and Py_False

Author: Boxiang Sun

from_cpython/Include/object.h

@@ -902,9 +902,9 @@ where NULL (nil) is not suitable (since NULL often means 'error').
 
 Don't forget to apply Py_INCREF() when returning this value!!!
 */
-// Pyston change: replaced Py_None with just None
-PyAPI_DATA(PyObject*) None;
-#define Py_None None
+// Pyston change: replaced _Py_NoneStruct with pyston_None
+PyAPI_DATA(PyObject*) pyston_None;
+#define Py_None pyston_None
 //PyAPI_DATA(PyObject) _Py_NoneStruct; /* Don't use this directly */
 //#define Py_None (&_Py_NoneStruct)
 

src/capi/modsupport.cpp

@@ -372,7 +372,7 @@ static PyObject* va_build_value(const char* fmt, va_list va, int flags) noexcept
         return NULL;
 
     if (n == 0)
-        return incref(None);
+        return incref(Py_None);
 
     va_list lva;
     __va_copy(lva, va);
@@ -482,8 +482,8 @@ extern "C" int PyModule_AddIntConstant(PyObject* _m, const char* name, long valu
 extern "C" PyObject* PyModule_New(const char* name) noexcept {
     BoxedModule* module = new BoxedModule();
     module->giveAttr("__name__", boxString(name));
-    module->giveAttr("__doc__", incref(None));
-    module->giveAttr("__package__", incref(None));
+    module->giveAttr("__doc__", incref(Py_None));
+    module->giveAttr("__package__", incref(Py_None));
     return module;
 }
 

src/capi/typeobject.cpp

@@ -1137,7 +1137,7 @@ template Box* slotTpGetattrHookInternal<CXX, NOT_REWRITABLE>(Box* self, BoxedStr
         static BoxedString* _new_str = getStaticString("__new__");
         Box* new_attr = typeLookup(self, _new_str);
         assert(new_attr);
-        new_attr = processDescriptor(new_attr, None, self);
+        new_attr = processDescriptor(new_attr, Py_None, self);
         AUTO_DECREF(new_attr);
 
         return runtimeCall(new_attr, ArgPassSpec(1, 0, true, true), self, args, kwds, NULL, NULL);
@@ -2184,7 +2184,7 @@ void add_operators(BoxedClass* cls) noexcept {
             continue;
 
         if (*ptr == PyObject_HashNotImplemented) {
-            cls->setattr(static_cast<BoxedString*>(p.name_strobj), None, NULL);
+            cls->setattr(static_cast<BoxedString*>(p.name_strobj), Py_None, NULL);
         } else {
             auto descr = PyDescr_NewWrapper(cls, &p, *ptr);
             assert(descr);
@@ -3614,7 +3614,7 @@ extern "C" int PyType_Ready(PyTypeObject* cls) noexcept {
         if (cls->tp_doc) {
             cls->giveAttr(incref(doc_str), boxString(cls->tp_doc));
         } else {
-            cls->giveAttr(incref(doc_str), incref(None));
+            cls->giveAttr(incref(doc_str), incref(Py_None));
         }
     }
 

src/capi/types.h

@@ -59,15 +59,15 @@ class BoxedCApiFunction : public Box {
         const char* s = static_cast<BoxedCApiFunction*>(b)->method_def->ml_name;
         if (s)
             return boxString(s);
-        return incref(None);
+        return incref(Py_None);
     }
 
     static Box* doc(Box* b, void*) noexcept {
         RELEASE_ASSERT(b->cls == capifunc_cls, "");
         const char* s = static_cast<BoxedCApiFunction*>(b)->method_def->ml_doc;
         if (s)
             return boxString(s);
-        return incref(None);
+        return incref(Py_None);
     }
 
     static void dealloc(Box* _o) noexcept {

src/codegen/ast_interpreter.cpp

@@ -605,9 +605,9 @@ void ASTInterpreter::doStore(AST_expr* node, STOLEN(Value) value) {
 Value ASTInterpreter::getNone() {
     RewriterVar* v = NULL;
     if (jit) {
-        v = jit->imm(None)->setType(RefType::BORROWED);
+        v = jit->imm(Py_None)->setType(RefType::BORROWED);
     }
-    return Value(incref(None), v);
+    return Value(incref(Py_None), v);
 }
 
 Value ASTInterpreter::visit_unaryop(AST_UnaryOp* node) {
@@ -783,7 +783,7 @@ Box* ASTInterpreter::doOSR(AST_Jump* node) {
     // TODO: maybe use a different placeholder (=NULL)?
     // - new issue with that -- we can no longer distinguish NULL from unset-in-sorted_symbol_table
     // Currently we pass None because the LLVM jit will decref this value even though it may not be set.
-    static Box* const VAL_UNDEFINED = (Box*)None;
+    static Box* const VAL_UNDEFINED = (Box*)Py_None;
 
     const VRegSet& defined = phis->definedness.getDefinedVregsAtEnd(current_block);
     for (int vreg : defined) {
@@ -1915,8 +1915,8 @@ Box* ASTInterpreterJitInterface::landingpadHelper(void* _interpreter) {
     ASTInterpreter* interpreter = (ASTInterpreter*)_interpreter;
     ExcInfo& last_exception = interpreter->last_exception;
     Box* type = last_exception.type;
-    Box* value = last_exception.value ? last_exception.value : None;
-    Box* traceback = last_exception.traceback ? last_exception.traceback : None;
+    Box* value = last_exception.value ? last_exception.value : Py_None;
+    Box* traceback = last_exception.traceback ? last_exception.traceback : Py_None;
     Box* rtn = BoxedTuple::create({ type, value, traceback });
     Py_CLEAR(last_exception.type);
     Py_CLEAR(last_exception.value);
@@ -2080,7 +2080,7 @@ Box* astInterpretFunction(FunctionMetadata* md, Box* closure, Box* generator, Bo
 
     interpreter.initArguments((BoxedClosure*)closure, (BoxedGenerator*)generator, arg1, arg2, arg3, args);
     Box* v = ASTInterpreter::execute(interpreter);
-    return v ? v : incref(None);
+    return v ? v : incref(Py_None);
 }
 
 Box* astInterpretFunctionEval(FunctionMetadata* md, Box* globals, Box* boxedLocals) {
@@ -2113,7 +2113,7 @@ Box* astInterpretFunctionEval(FunctionMetadata* md, Box* globals, Box* boxedLoca
     interpreter.setGlobals(globals);
 
     Box* v = ASTInterpreter::execute(interpreter);
-    return v ? v : incref(None);
+    return v ? v : incref(Py_None);
 }
 
 // caution when changing the function arguments: this function gets called from an assembler wrapper!
@@ -2220,7 +2220,7 @@ extern "C" Box* astInterpretDeoptFromASM(FunctionMetadata* md, AST_expr* after_e
     Py_CLEAR(frame_state.locals);
 
     Box* v = ASTInterpreter::execute(interpreter, start_block, starting_statement);
-    return v ? v : incref(None);
+    return v ? v : incref(Py_None);
 }
 
 extern "C" void printExprHelper(Box* obj) {

src/codegen/baseline_jit.cpp

@@ -404,7 +404,7 @@ RewriterVar* JitFragmentWriter::emitGetClsAttr(RewriterVar* obj, BoxedString* s)
 
 RewriterVar* JitFragmentWriter::emitGetGlobal(BoxedString* s) {
     if (s->s() == "None") {
-        RewriterVar* r = imm(None)->setType(RefType::BORROWED);
+        RewriterVar* r = imm(Py_None)->setType(RefType::BORROWED);
         return r;
     }
 

src/codegen/compvars.cpp

@@ -2136,7 +2136,7 @@ class NormalObjectType : public ConcreteCompilerType {
     }
 
     CompilerVariable* nonzero(IREmitter& emitter, const OpInfo& info, ConcreteCompilerVariable* var) override {
-        if (cls == None->cls)
+        if (cls == Py_None->cls)
             return makeBool(false);
 
         static BoxedString* attr = getStaticString("__nonzero__");

src/codegen/irgen/hooks.cpp

@@ -142,7 +142,7 @@ Box* SourceInfo::getDocString() {
         return boxString(static_cast<AST_Str*>(static_cast<AST_Expr*>(body[0])->value)->str_data);
     }
 
-    return incref(None);
+    return incref(Py_None);
 }
 
 ScopeInfo* SourceInfo::getScopeInfo() {
@@ -344,7 +344,7 @@ void compileAndRunModule(AST_Module* m, BoxedModule* bm) {
 
     UNAVOIDABLE_STAT_TIMER(t0, "us_timer_interpreted_module_toplevel");
     Box* r = astInterpretFunction(md, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
-    assert(r == None);
+    assert(r == Py_None);
     Py_DECREF(r);
 
     // XXX for bjit testing
@@ -359,7 +359,7 @@ Box* evalOrExec(FunctionMetadata* md, Box* globals, Box* boxedLocals) {
     assert(globals && (globals->cls == module_cls || globals->cls == dict_cls));
 
     Box* doc_string = md->source->getDocString();
-    if (doc_string != None) {
+    if (doc_string != Py_None) {
         static BoxedString* doc_box = getStaticString("__doc__");
         setGlobal(boxedLocals, doc_box, doc_string);
     } else {
@@ -478,10 +478,10 @@ extern "C" int PyEval_MergeCompilerFlags(PyCompilerFlags* cf) noexcept {
 }
 
 static void pickGlobalsAndLocals(Box*& globals, Box*& locals) {
-    if (globals == None)
+    if (globals == Py_None)
         globals = NULL;
 
-    if (locals == None)
+    if (locals == Py_None)
         locals = NULL;
 
     if (locals == NULL) {
@@ -535,9 +535,9 @@ extern "C" PyObject* PyEval_EvalCode(PyCodeObject* co, PyObject* globals, PyObje
 
 void exec(Box* boxedCode, Box* globals, Box* locals, FutureFlags caller_future_flags) {
     if (!globals)
-        globals = None;
+        globals = Py_None;
     if (!locals)
-        locals = None;
+        locals = Py_None;
 
     // this is based on cpythons exec_statement() but (heavily) adopted
     Box* v = NULL;
@@ -628,7 +628,7 @@ void exec(Box* boxedCode, Box* globals, Box* locals, FutureFlags caller_future_f
     if (!v)
         throwCAPIException();
 
-    assert(v == None); // not really necessary but I think this should be true
+    assert(v == Py_None); // not really necessary but I think this should be true
     Py_DECREF(v);
 }
 

src/codegen/irgen/irgenerator.cpp

@@ -745,7 +745,7 @@ class IREmitterImpl : public IREmitter {
     }
 
     ConcreteCompilerVariable* getNone() override {
-        llvm::Constant* none = embedRelocatablePtr(None, g.llvm_value_type_ptr, "cNone");
+        llvm::Constant* none = embedRelocatablePtr(Py_None, g.llvm_value_type_ptr, "cNone");
         setType(none, RefType::BORROWED);
         return new ConcreteCompilerVariable(typeFromClass(none_cls), none);
     }

src/codegen/unwinding.cpp

@@ -750,7 +750,7 @@ ExcInfo* getFrameExcInfo() {
 
     if (!copy_from_exc->type) {
         // No exceptions found:
-        *copy_from_exc = ExcInfo(incref(None), incref(None), NULL);
+        *copy_from_exc = ExcInfo(incref(Py_None), incref(Py_None), NULL);
     }
 
     for (auto* ex : to_update) {