switched classobject.cs to the new style references

lostmsu · lostmsu · commit 2095b4625eea · 2021-10-17T19:44:36.000-07:00
diff --git a/src/runtime/classobject.cs b/src/runtime/classobject.cs
@@ -80,14 +80,13 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,
                 }
 
                 BorrowedReference op = Runtime.PyTuple_GetItem(args, 0);
-                object result;
 
-                if (!Converter.ToManaged(op, type, out result, true))
+                if (!Converter.ToManaged(op, type, out var result, true))
                 {
                     return default;
                 }
 
-                return CLRObject.GetReference(result, tp);
+                return CLRObject.GetReference(result!, tp);
             }
 
             if (type.IsAbstract)
@@ -101,13 +100,13 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,
                 return NewEnum(type, args, tp);
             }
 
-            object obj = self.binder.InvokeRaw(null, args, kw);
+            object? obj = self.binder.InvokeRaw(null, args, kw);
             if (obj == null)
             {
-                return IntPtr.Zero;
+                return default;
             }
 
-            return CLRObject.GetReference(obj, tp).DangerousMoveToPointerOrNull();
+            return CLRObject.GetReference(obj, tp);
         }
 
         private static NewReference NewEnum(Type type, BorrowedReference args, BorrowedReference tp)
@@ -132,7 +131,7 @@ private static NewReference NewEnum(Type type, BorrowedReference args, BorrowedR
             }
 
             var op = Runtime.PyTuple_GetItem(args, 0);
-            if (!Converter.ToManaged(op, type.GetEnumUnderlyingType(), out object result, true))
+            if (!Converter.ToManaged(op, type.GetEnumUnderlyingType(), out object? result, true))
             {
                 return default;
             }
@@ -169,21 +168,20 @@ public override NewReference type_subscript(BorrowedReference idx)
                     return Exceptions.RaiseTypeError("type expected");
                 }
                 var c = GetManagedObject(idx) as ClassBase;
-                Type t = c != null ? c.type.Value : Converter.GetTypeByAlias(idx);
+                Type? t = c != null ? c.type.Value : Converter.GetTypeByAlias(idx);
                 if (t == null)
                 {
                     return Exceptions.RaiseTypeError("type expected");
                 }
                 Type a = t.MakeArrayType();
                 ClassBase o = ClassManager.GetClass(a);
-                Runtime.XIncref(o.pyHandle);
-                return o.pyHandle;
+                return new NewReference(o.ObjectReference);
             }
 
             // If there are generics in our namespace with the same base name
             // as the current type, then [<type>] means the caller wants to
             // bind the generic type matching the given type parameters.
-            Type[] types = Runtime.PythonArgsToTypeArray(idx);
+            Type[]? types = Runtime.PythonArgsToTypeArray(idx);
             if (types == null)
             {
                 return Exceptions.RaiseTypeError("type(s) expected");
@@ -192,10 +190,8 @@ public override NewReference type_subscript(BorrowedReference idx)
             Type gtype = AssemblyManager.LookupTypes($"{type.Value.FullName}`{types.Length}").FirstOrDefault();
             if (gtype != null)
             {
-                var g = ClassManager.GetClass(gtype) as GenericType;
+                var g = (GenericType)ClassManager.GetClass(gtype);
                 return g.type_subscript(idx);
-                //Runtime.XIncref(g.pyHandle);
-                //return g.pyHandle;
             }
             return Exceptions.RaiseTypeError("unsubscriptable object");
         }

Original file line number	Diff line number	Diff line change
`@@ -80,14 +80,13 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`BorrowedReference op = Runtime.PyTuple_GetItem(args, 0);`
`83`		`- object result;`
`84`	`83`
`85`		`- if (!Converter.ToManaged(op, type, out result, true))`
	`84`	`+ if (!Converter.ToManaged(op, type, out var result, true))`
`86`	`85`	`{`
`87`	`86`	`return default;`
`88`	`87`	`}`
`89`	`88`
`90`		`- return CLRObject.GetReference(result, tp);`
	`89`	`+ return CLRObject.GetReference(result!, tp);`
`91`	`90`	`}`
`92`	`91`
`93`	`92`	`if (type.IsAbstract)`
`@@ -101,13 +100,13 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,`
`101`	`100`	`return NewEnum(type, args, tp);`
`102`	`101`	`}`
`103`	`102`
`104`		`- object obj = self.binder.InvokeRaw(null, args, kw);`
	`103`	`+ object? obj = self.binder.InvokeRaw(null, args, kw);`
`105`	`104`	`if (obj == null)`
`106`	`105`	`{`
`107`		`- return IntPtr.Zero;`
	`106`	`+ return default;`
`108`	`107`	`}`
`109`	`108`
`110`		`- return CLRObject.GetReference(obj, tp).DangerousMoveToPointerOrNull();`
	`109`	`+ return CLRObject.GetReference(obj, tp);`
`111`	`110`	`}`
`112`	`111`
`113`	`112`	`private static NewReference NewEnum(Type type, BorrowedReference args, BorrowedReference tp)`
`@@ -132,7 +131,7 @@ private static NewReference NewEnum(Type type, BorrowedReference args, BorrowedR`
`132`	`131`	`}`
`133`	`132`
`134`	`133`	`var op = Runtime.PyTuple_GetItem(args, 0);`
`135`		`- if (!Converter.ToManaged(op, type.GetEnumUnderlyingType(), out object result, true))`
	`134`	`+ if (!Converter.ToManaged(op, type.GetEnumUnderlyingType(), out object? result, true))`
`136`	`135`	`{`
`137`	`136`	`return default;`
`138`	`137`	`}`
`@@ -169,21 +168,20 @@ public override NewReference type_subscript(BorrowedReference idx)`
`169`	`168`	`return Exceptions.RaiseTypeError("type expected");`
`170`	`169`	`}`
`171`	`170`	`var c = GetManagedObject(idx) as ClassBase;`
`172`		`- Type t = c != null ? c.type.Value : Converter.GetTypeByAlias(idx);`
	`171`	`+ Type? t = c != null ? c.type.Value : Converter.GetTypeByAlias(idx);`
`173`	`172`	`if (t == null)`
`174`	`173`	`{`
`175`	`174`	`return Exceptions.RaiseTypeError("type expected");`
`176`	`175`	`}`
`177`	`176`	`Type a = t.MakeArrayType();`
`178`	`177`	`ClassBase o = ClassManager.GetClass(a);`
`179`		`- Runtime.XIncref(o.pyHandle);`
`180`		`- return o.pyHandle;`
	`178`	`+ return new NewReference(o.ObjectReference);`
`181`	`179`	`}`
`182`	`180`
`183`	`181`	`// If there are generics in our namespace with the same base name`
`184`	`182`	`// as the current type, then [<type>] means the caller wants to`
`185`	`183`	`// bind the generic type matching the given type parameters.`
`186`		`- Type[] types = Runtime.PythonArgsToTypeArray(idx);`
	`184`	`+ Type[]? types = Runtime.PythonArgsToTypeArray(idx);`
`187`	`185`	`if (types == null)`
`188`	`186`	`{`
`189`	`187`	`return Exceptions.RaiseTypeError("type(s) expected");`
`@@ -192,10 +190,8 @@ public override NewReference type_subscript(BorrowedReference idx)`
`192`	`190`	Type gtype = AssemblyManager.LookupTypes($"{type.Value.FullName}`{types.Length}").FirstOrDefault();
`193`	`191`	`if (gtype != null)`
`194`	`192`	`{`
`195`		`- var g = ClassManager.GetClass(gtype) as GenericType;`
	`193`	`+ var g = (GenericType)ClassManager.GetClass(gtype);`
`196`	`194`	`return g.type_subscript(idx);`
`197`		`- //Runtime.XIncref(g.pyHandle);`
`198`		`- //return g.pyHandle;`
`199`	`195`	`}`
`200`	`196`	`return Exceptions.RaiseTypeError("unsubscriptable object");`
`201`	`197`	`}`