isnot null

benaadams · benaadams · commit c0884ae65315 · 2019-01-01T22:41:00.000Z
diff --git a/src/System.Private.CoreLib/shared/System/Type.Helpers.cs b/src/System.Private.CoreLib/shared/System/Type.Helpers.cs
@@ -270,47 +270,47 @@ public virtual MemberInfo[] FindMembers(MemberTypes memberType, BindingFlags bin
             if (m != null)
             {
                 for (i = 0; i < m.Length; i++)
-                    if (!(m[i] is null))
+                    if (m[i] is object)
                         ret[cnt++] = m[i];
             }
 
             // Copy the Constructors
             if (c != null)
             {
                 for (i = 0; i < c.Length; i++)
-                    if (!(c[i] is null))
+                    if (c[i] is object)
                         ret[cnt++] = c[i];
             }
 
             // Copy the Fields
             if (f != null)
             {
                 for (i = 0; i < f.Length; i++)
-                    if (!(f[i] is null))
+                    if (f[i] is object)
                         ret[cnt++] = f[i];
             }
 
             // Copy the Properties
             if (p != null)
             {
                 for (i = 0; i < p.Length; i++)
-                    if (!(p[i] is null))
+                    if (p[i] is object)
                         ret[cnt++] = p[i];
             }
 
             // Copy the Events
             if (e != null)
             {
                 for (i = 0; i < e.Length; i++)
-                    if (!(e[i] is null))
+                    if (e[i] is object)
                         ret[cnt++] = e[i];
             }
 
             // Copy the Types
             if (t != null)
             {
                 for (i = 0; i < t.Length; i++)
-                    if (t[i] != null)
+                    if (t[i] is object)
                         ret[cnt++] = t[i];
             }
 
@@ -322,7 +322,7 @@ public virtual bool IsSubclassOf(Type c)
             Type p = this;
             if (p == c)
                 return false;
-            while (p != null)
+            while (p is object)
             {
                 if (p == c)
                     return true;
@@ -369,7 +369,7 @@ public virtual bool IsAssignableFrom(Type c)
         internal bool ImplementInterface(Type ifaceType)
         {
             Type t = this;
-            while (t != null)
+            while (t is object)
             {
                 Type[] interfaces = t.GetInterfaces();
                 if (interfaces != null)
diff --git a/src/System.Private.CoreLib/shared/System/Type.cs b/src/System.Private.CoreLib/shared/System/Type.cs
@@ -42,7 +42,7 @@ protected Type() { }
         public virtual bool IsConstructedGenericType { get { throw NotImplemented.ByDesign; } }
         public virtual bool IsGenericParameter => false;
         public virtual bool IsGenericTypeParameter => IsGenericParameter && DeclaringMethod is null;
-        public virtual bool IsGenericMethodParameter => IsGenericParameter && !(DeclaringMethod is null);
+        public virtual bool IsGenericMethodParameter => IsGenericParameter && DeclaringMethod is object;
         public virtual bool IsGenericType => false;
         public virtual bool IsGenericTypeDefinition => false;
 
@@ -281,7 +281,7 @@ public static TypeCode GetTypeCode(Type type)
         }
         protected virtual TypeCode GetTypeCodeImpl()
         {
-            if (this != UnderlyingSystemType && !(UnderlyingSystemType is null))
+            if (this != UnderlyingSystemType && (UnderlyingSystemType is object))
                 return Type.GetTypeCode(UnderlyingSystemType);
 
             return TypeCode.Object;
diff --git a/src/System.Private.CoreLib/shared/System/Version.cs b/src/System.Private.CoreLib/shared/System/Version.cs
@@ -170,7 +170,7 @@ public override bool Equals(object obj)
         public bool Equals(Version obj)
         {
             return object.ReferenceEquals(obj, this) ||
-                (!(obj is null) &&
+                ((obj is object) &&
                 _Major == obj._Major &&
                 _Minor == obj._Minor &&
                 _Build == obj._Build &&
diff --git a/src/System.Private.CoreLib/src/System/Attribute.cs b/src/System.Private.CoreLib/src/System/Attribute.cs
@@ -41,7 +41,7 @@ private static Attribute[] InternalGetCustomAttributes(PropertyInfo element, Typ
 
 
             PropertyInfo baseProp = GetParentDefinition(element, indexParamTypes);
-            while (!(baseProp is null))
+            while (baseProp is object)
             {
                 attributes = GetCustomAttributes(baseProp, type, false);
                 AddAttributesToList(attributeList, attributes, types);
@@ -70,7 +70,7 @@ private static bool InternalIsDefined(PropertyInfo element, Type attributeType,
 
                 PropertyInfo baseProp = GetParentDefinition(element, indexParamTypes);
 
-                while (!(baseProp is null))
+                while (baseProp is object)
                 {
                     if (baseProp.IsDefined(attributeType, false))
                         return true;
@@ -97,7 +97,7 @@ private static PropertyInfo GetParentDefinition(PropertyInfo property, Type[] pr
             {
                 rtPropAccessor = rtPropAccessor.GetParentDefinition();
 
-                if (!(rtPropAccessor is null))
+                if (rtPropAccessor is object)
                 {
                     // There is a public overload of Type.GetProperty that takes both a BingingFlags enum and a return type.
                     // However, we cannot use that because it doesn't accept null for "types".
@@ -134,7 +134,7 @@ private static Attribute[] InternalGetCustomAttributes(EventInfo element, Type t
                 CopyToArrayList(attributeList, attributes, types);
 
                 EventInfo baseEvent = GetParentDefinition(element);
-                while (!(baseEvent is null))
+                while (baseEvent is object)
                 {
                     attributes = GetCustomAttributes(baseEvent, type, false);
                     AddAttributesToList(attributeList, attributes, types);
@@ -158,7 +158,7 @@ private static EventInfo GetParentDefinition(EventInfo ev)
             if (add is RuntimeMethodInfo rtAdd)
             {
                 rtAdd = rtAdd.GetParentDefinition();
-                if (!(rtAdd is null))
+                if (rtAdd is object)
                     return rtAdd.DeclaringType.GetEvent(ev.Name);
             }
             return null;
@@ -181,7 +181,7 @@ private static bool InternalIsDefined(EventInfo element, Type attributeType, boo
 
                 EventInfo baseEvent = GetParentDefinition(element);
 
-                while (!(baseEvent is null))
+                while (baseEvent is object)
                 {
                     if (baseEvent.IsDefined(attributeType, false))
                         return true;
diff --git a/src/System.Private.CoreLib/src/System/Delegate.cs b/src/System.Private.CoreLib/src/System/Delegate.cs
@@ -242,7 +242,7 @@ private MethodInfo InitalizeMethodBase()
                         // walking won't be we compare using the generic type definition forms instead.
                         Type currentType = _target.GetType();
                         Type targetType = declaringType.GetGenericTypeDefinition();
-                        while (!(currentType is null))
+                        while (currentType is object)
                         {
                             if (currentType.IsGenericType &&
                                 currentType.GetGenericTypeDefinition() == targetType)
diff --git a/src/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs b/src/System.Private.CoreLib/src/System/Reflection/CustomAttribute.cs
@@ -1129,7 +1129,7 @@ internal static bool IsDefined(RuntimeMethodInfo method, RuntimeType caType, boo
 
             method = method.GetParentDefinition();
 
-            while (!(method is null))
+            while (method is object)
             {
                 if (IsCustomAttributeDefined(method.GetRuntimeModule(), method.MetadataToken, caType, 0, inherit))
                     return true;
@@ -1285,7 +1285,7 @@ internal static object[] GetCustomAttributes(RuntimeMethodInfo method, RuntimeTy
             for (var i = 0; i < pcas.Count; i++)
                 result.Add(pcas[i]);
 
-            while (!(method is null))
+            while (method is object)
             {
                 AddCustomAttributes(ref result, method.GetRuntimeModule(), method.MetadataToken, caType, mustBeInheritable, ref result);
                 mustBeInheritable = true;
diff --git a/src/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs b/src/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs
@@ -456,7 +456,7 @@ private int GetMemberRefToken(MethodBase methodInfo, Type[] optionalParameterTyp
                                                      parameterTypes,
                                                      optionalParameterTypes);
 
-            if (!(rtMeth is null))
+            if (rtMeth is object)
                 return GetTokenForVarArgMethod(rtMeth, sig);
             else
                 return GetTokenForVarArgMethod(dm, sig);
diff --git a/src/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs b/src/System.Private.CoreLib/src/System/Reflection/RuntimePropertyInfo.cs
@@ -322,7 +322,7 @@ internal ParameterInfo[] GetIndexParametersNoCopy()
 
                 // First try to get the Get method.
                 MethodInfo m = GetGetMethod(true);
-                if (!(m is null))
+                if (m is object)
                 {
                     // There is a Get method so use it.
                     methParams = m.GetParametersNoCopy();
@@ -333,7 +333,7 @@ internal ParameterInfo[] GetIndexParametersNoCopy()
                     // If there is no Get method then use the Set method.
                     m = GetSetMethod(true);
 
-                    if (!(m is null))
+                    if (m is object)
                     {
                         methParams = m.GetParametersNoCopy();
                         numParams = methParams.Length - 1;
diff --git a/src/System.Private.CoreLib/src/System/RtType.cs b/src/System.Private.CoreLib/src/System/RtType.cs
@@ -691,7 +691,7 @@ private unsafe RuntimeMethodInfo[] PopulateMethods(Filter filter)
                             }
 
                             declaringType = RuntimeTypeHandle.GetBaseType(declaringType);
-                        } while (!(declaringType is null));
+                        } while (declaringType is object);
                     }
 
                     return list.ToArray();
@@ -763,7 +763,7 @@ private unsafe RuntimeFieldInfo[] PopulateFields(Filter filter)
                     while (RuntimeTypeHandle.IsGenericVariable(declaringType))
                         declaringType = declaringType.GetBaseType();
 
-                    while (!(declaringType is null))
+                    while (declaringType is object)
                     {
                         PopulateRtFields(filter, declaringType, ref list);
 
@@ -1112,7 +1112,7 @@ private unsafe RuntimeEventInfo[] PopulateEvents(Filter filter)
                             declaringType = declaringType.GetBaseType();
 
                         // Populate associates off of the class hierarchy
-                        while (!(declaringType is null))
+                        while (declaringType is object)
                         {
                             PopulateEvents(filter, declaringType, csEventInfos, ref list);
                             declaringType = RuntimeTypeHandle.GetBaseType(declaringType);
@@ -1216,7 +1216,7 @@ private unsafe RuntimePropertyInfo[] PopulateProperties(Filter filter)
                         {
                             PopulateProperties(filter, declaringType, csPropertyInfos, usedSlots, ref list);
                             declaringType = RuntimeTypeHandle.GetBaseType(declaringType);
-                        } while (!(declaringType is null));
+                        } while (declaringType is object);
                     }
                     else
                     {
@@ -1303,7 +1303,7 @@ private unsafe void PopulateProperties(
                                 associateMethod = propertyInfo.GetSetMethod();
                             }
 
-                            if (!(associateMethod is null))
+                            if (associateMethod is object)
                             {
                                 int slot = RuntimeMethodHandle.GetSlot((RuntimeMethodInfo)associateMethod);
 
@@ -1565,7 +1565,7 @@ internal string GetDefaultMemberName()
                 {
                     CustomAttributeData attr = null;
                     Type DefaultMemberAttrType = typeof(DefaultMemberAttribute);
-                    for (RuntimeType t = m_runtimeType; !(t is null); t = t.GetBaseType())
+                    for (RuntimeType t = m_runtimeType; t is object; t = t.GetBaseType())
                     {
                         IList<CustomAttributeData> attrs = CustomAttributeData.GetCustomAttributes(t);
                         for (int i = 0; i < attrs.Count; i++)
@@ -1612,7 +1612,7 @@ internal MethodInfo GetGenericMethodInfo(RuntimeMethodHandleInternal genericMeth
                 {
                     crmi = s_methodInstantiations[rmi];
                 }
-                if (!(crmi is null))
+                if (crmi is object)
                     return crmi;
 
                 if (s_methodInstantiationsLock == null)
@@ -1627,14 +1627,14 @@ internal MethodInfo GetGenericMethodInfo(RuntimeMethodHandleInternal genericMeth
                     if (la != null)
                     {
                         crmi = la.m_methodInstantiations[rmi];
-                        if (!(crmi is null))
+                        if (crmi is object)
                             return crmi;
                         la.m_methodInstantiations[rmi] = rmi;
                     }
                     else
                     {
                         crmi = s_methodInstantiations[rmi];
-                        if (!(crmi is null))
+                        if (crmi is object)
                             return crmi;
                         s_methodInstantiations[rmi] = rmi;
                     }
@@ -1795,7 +1795,7 @@ internal static unsafe MethodBase GetMethodBase(RuntimeType reflectedType, Runti
 
                     RuntimeType baseType = reflectedType;
 
-                    while (!(baseType is null))
+                    while (baseType is object)
                     {
                         RuntimeType baseDefinition = baseType;
 
@@ -2340,7 +2340,7 @@ private static bool FilterApplyMethodBase(
                             for (int i = 0; i < parameterInfos.Length; i++)
                             {
                                 // a null argument type implies a null arg which is always a perfect match
-                                if (!(argumentTypes[i] is null) && !argumentTypes[i].MatchesParameterTypeExactly(parameterInfos[i]))
+                                if (argumentTypes[i] is object && !argumentTypes[i].MatchesParameterTypeExactly(parameterInfos[i]))
                                     return false;
                             }
                         }
@@ -2806,7 +2806,7 @@ protected override PropertyInfo GetPropertyImpl(
                 {
                     PropertyInfo firstCandidate = candidates[0];
 
-                    if (!(returnType is null) && !returnType.IsEquivalentTo(firstCandidate.PropertyType))
+                    if (returnType is object && !returnType.IsEquivalentTo(firstCandidate.PropertyType))
                         return null;
 
                     return firstCandidate;
@@ -2847,7 +2847,7 @@ public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
                 RuntimeEventInfo eventInfo = cache[i];
                 if ((bindingAttr & eventInfo.BindingFlags) == eventInfo.BindingFlags)
                 {
-                    if (!(match is null))
+                    if (match is object)
                         throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
 
                     match = eventInfo;
@@ -2876,7 +2876,7 @@ public override FieldInfo GetField(string name, BindingFlags bindingAttr)
                 RuntimeFieldInfo fieldInfo = cache[i];
                 if ((bindingAttr & fieldInfo.BindingFlags) == fieldInfo.BindingFlags)
                 {
-                    if (!(match is null))
+                    if (match is object)
                     {
                         if (ReferenceEquals(fieldInfo.DeclaringType, match.DeclaringType))
                             throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
@@ -2923,7 +2923,7 @@ public override Type GetInterface(string fullname, bool ignoreCase)
                 RuntimeType iface = cache[i];
                 if (FilterApplyType(iface, bindingAttr, name, false, ns))
                 {
-                    if (!(match is null))
+                    if (match is object)
                         throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
 
                     match = iface;
@@ -2953,7 +2953,7 @@ public override Type GetNestedType(string fullname, BindingFlags bindingAttr)
                 RuntimeType nestedType = cache[i];
                 if (FilterApplyType(nestedType, bindingAttr, name, false, ns))
                 {
-                    if (!(match is null))
+                    if (match is object)
                         throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
 
                     match = nestedType;
@@ -3151,7 +3151,7 @@ public override bool IsSubclassOf(Type type)
 
             RuntimeType baseType = GetBaseType();
 
-            while (!(baseType is null))
+            while (baseType is object)
             {
                 if (baseType == rtType)
                     return true;
@@ -3962,7 +3962,7 @@ public override object InvokeMember(
                     selFld = binder.BindToField(bindingFlags, flds, IsGetField ? Empty.Value : providedArgs[0], culture);
                 }
 
-                if (!(selFld is null))
+                if (selFld is object)
                 {
                     // Invocation on a field
                     if (selFld.FieldType.IsArray || ReferenceEquals(selFld.FieldType, typeof(Array)))
@@ -4148,7 +4148,7 @@ public override object InvokeMember(
                 }
             }
 
-            if (!(finalist is null))
+            if (finalist is object)
             {
                 // Invoke
                 if (finalists == null &&
diff --git a/src/System.Private.CoreLib/src/System/StartupHookProvider.cs b/src/System.Private.CoreLib/src/System/StartupHookProvider.cs
@@ -89,7 +89,7 @@ private static void CallStartupHook(string assemblyPath)
                     Debug.Assert(initializeMethod == null);
                     wrongSignature = true;
                 }
-                if (!(initializeMethod is null))
+                if (initializeMethod is object)
                 {
                     // Found one
                     wrongSignature = true;

Original file line number	Diff line number	Diff line change
`@@ -270,47 +270,47 @@ public virtual MemberInfo[] FindMembers(MemberTypes memberType, BindingFlags bin`
`270`	`270`	`if (m != null)`
`271`	`271`	`{`
`272`	`272`	`for (i = 0; i < m.Length; i++)`
`273`		`- if (!(m[i] is null))`
	`273`	`+ if (m[i] is object)`
`274`	`274`	`ret[cnt++] = m[i];`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`// Copy the Constructors`
`278`	`278`	`if (c != null)`
`279`	`279`	`{`
`280`	`280`	`for (i = 0; i < c.Length; i++)`
`281`		`- if (!(c[i] is null))`
	`281`	`+ if (c[i] is object)`
`282`	`282`	`ret[cnt++] = c[i];`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`// Copy the Fields`
`286`	`286`	`if (f != null)`
`287`	`287`	`{`
`288`	`288`	`for (i = 0; i < f.Length; i++)`
`289`		`- if (!(f[i] is null))`
	`289`	`+ if (f[i] is object)`
`290`	`290`	`ret[cnt++] = f[i];`
`291`	`291`	`}`
`292`	`292`
`293`	`293`	`// Copy the Properties`
`294`	`294`	`if (p != null)`
`295`	`295`	`{`
`296`	`296`	`for (i = 0; i < p.Length; i++)`
`297`		`- if (!(p[i] is null))`
	`297`	`+ if (p[i] is object)`
`298`	`298`	`ret[cnt++] = p[i];`
`299`	`299`	`}`
`300`	`300`
`301`	`301`	`// Copy the Events`
`302`	`302`	`if (e != null)`
`303`	`303`	`{`
`304`	`304`	`for (i = 0; i < e.Length; i++)`
`305`		`- if (!(e[i] is null))`
	`305`	`+ if (e[i] is object)`
`306`	`306`	`ret[cnt++] = e[i];`
`307`	`307`	`}`
`308`	`308`
`309`	`309`	`// Copy the Types`
`310`	`310`	`if (t != null)`
`311`	`311`	`{`
`312`	`312`	`for (i = 0; i < t.Length; i++)`
`313`		`- if (t[i] != null)`
	`313`	`+ if (t[i] is object)`
`314`	`314`	`ret[cnt++] = t[i];`
`315`	`315`	`}`
`316`	`316`
`@@ -322,7 +322,7 @@ public virtual bool IsSubclassOf(Type c)`
`322`	`322`	`Type p = this;`
`323`	`323`	`if (p == c)`
`324`	`324`	`return false;`
`325`		`- while (p != null)`
	`325`	`+ while (p is object)`
`326`	`326`	`{`
`327`	`327`	`if (p == c)`
`328`	`328`	`return true;`
`@@ -369,7 +369,7 @@ public virtual bool IsAssignableFrom(Type c)`
`369`	`369`	`internal bool ImplementInterface(Type ifaceType)`
`370`	`370`	`{`
`371`	`371`	`Type t = this;`
`372`		`- while (t != null)`
	`372`	`+ while (t is object)`
`373`	`373`	`{`
`374`	`374`	`Type[] interfaces = t.GetInterfaces();`
`375`	`375`	`if (interfaces != null)`
Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ public override bool Equals(object obj)`
`170`	`170`	`public bool Equals(Version obj)`
`171`	`171`	`{`
`172`	`172`	`return object.ReferenceEquals(obj, this) \|\|`
`173`		`- (!(obj is null) &&`
	`173`	`+ ((obj is object) &&`
`174`	`174`	`_Major == obj._Major &&`
`175`	`175`	`_Minor == obj._Minor &&`
`176`	`176`	`_Build == obj._Build &&`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ private static Attribute[] InternalGetCustomAttributes(PropertyInfo element, Typ`
`41`	`41`
`42`	`42`
`43`	`43`	`PropertyInfo baseProp = GetParentDefinition(element, indexParamTypes);`
`44`		`- while (!(baseProp is null))`
	`44`	`+ while (baseProp is object)`
`45`	`45`	`{`
`46`	`46`	`attributes = GetCustomAttributes(baseProp, type, false);`
`47`	`47`	`AddAttributesToList(attributeList, attributes, types);`
`@@ -70,7 +70,7 @@ private static bool InternalIsDefined(PropertyInfo element, Type attributeType,`
`70`	`70`
`71`	`71`	`PropertyInfo baseProp = GetParentDefinition(element, indexParamTypes);`
`72`	`72`
`73`		`- while (!(baseProp is null))`
	`73`	`+ while (baseProp is object)`
`74`	`74`	`{`
`75`	`75`	`if (baseProp.IsDefined(attributeType, false))`
`76`	`76`	`return true;`
`@@ -97,7 +97,7 @@ private static PropertyInfo GetParentDefinition(PropertyInfo property, Type[] pr`
`97`	`97`	`{`
`98`	`98`	`rtPropAccessor = rtPropAccessor.GetParentDefinition();`
`99`	`99`
`100`		`- if (!(rtPropAccessor is null))`
	`100`	`+ if (rtPropAccessor is object)`
`101`	`101`	`{`
`102`	`102`	`// There is a public overload of Type.GetProperty that takes both a BingingFlags enum and a return type.`
`103`	`103`	`// However, we cannot use that because it doesn't accept null for "types".`
`@@ -134,7 +134,7 @@ private static Attribute[] InternalGetCustomAttributes(EventInfo element, Type t`
`134`	`134`	`CopyToArrayList(attributeList, attributes, types);`
`135`	`135`
`136`	`136`	`EventInfo baseEvent = GetParentDefinition(element);`
`137`		`- while (!(baseEvent is null))`
	`137`	`+ while (baseEvent is object)`
`138`	`138`	`{`
`139`	`139`	`attributes = GetCustomAttributes(baseEvent, type, false);`
`140`	`140`	`AddAttributesToList(attributeList, attributes, types);`
`@@ -158,7 +158,7 @@ private static EventInfo GetParentDefinition(EventInfo ev)`
`158`	`158`	`if (add is RuntimeMethodInfo rtAdd)`
`159`	`159`	`{`
`160`	`160`	`rtAdd = rtAdd.GetParentDefinition();`
`161`		`- if (!(rtAdd is null))`
	`161`	`+ if (rtAdd is object)`
`162`	`162`	`return rtAdd.DeclaringType.GetEvent(ev.Name);`
`163`	`163`	`}`
`164`	`164`	`return null;`
`@@ -181,7 +181,7 @@ private static bool InternalIsDefined(EventInfo element, Type attributeType, boo`
`181`	`181`
`182`	`182`	`EventInfo baseEvent = GetParentDefinition(element);`
`183`	`183`
`184`		`- while (!(baseEvent is null))`
	`184`	`+ while (baseEvent is object)`
`185`	`185`	`{`
`186`	`186`	`if (baseEvent.IsDefined(attributeType, false))`
`187`	`187`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -242,7 +242,7 @@ private MethodInfo InitalizeMethodBase()`
`242`	`242`	`// walking won't be we compare using the generic type definition forms instead.`
`243`	`243`	`Type currentType = _target.GetType();`
`244`	`244`	`Type targetType = declaringType.GetGenericTypeDefinition();`
`245`		`- while (!(currentType is null))`
	`245`	`+ while (currentType is object)`
`246`	`246`	`{`
`247`	`247`	`if (currentType.IsGenericType &&`
`248`	`248`	`currentType.GetGenericTypeDefinition() == targetType)`
Original file line number	Diff line number	Diff line change
`@@ -1129,7 +1129,7 @@ internal static bool IsDefined(RuntimeMethodInfo method, RuntimeType caType, boo`
`1129`	`1129`
`1130`	`1130`	`method = method.GetParentDefinition();`
`1131`	`1131`
`1132`		`- while (!(method is null))`
	`1132`	`+ while (method is object)`
`1133`	`1133`	`{`
`1134`	`1134`	`if (IsCustomAttributeDefined(method.GetRuntimeModule(), method.MetadataToken, caType, 0, inherit))`
`1135`	`1135`	`return true;`
`@@ -1285,7 +1285,7 @@ internal static object[] GetCustomAttributes(RuntimeMethodInfo method, RuntimeTy`
`1285`	`1285`	`for (var i = 0; i < pcas.Count; i++)`
`1286`	`1286`	`result.Add(pcas[i]);`
`1287`	`1287`
`1288`		`- while (!(method is null))`
	`1288`	`+ while (method is object)`
`1289`	`1289`	`{`
`1290`	`1290`	`AddCustomAttributes(ref result, method.GetRuntimeModule(), method.MetadataToken, caType, mustBeInheritable, ref result);`
`1291`	`1291`	`mustBeInheritable = true;`
Original file line number	Diff line number	Diff line change
`@@ -691,7 +691,7 @@ private unsafe RuntimeMethodInfo[] PopulateMethods(Filter filter)`
`691`	`691`	`}`
`692`	`692`
`693`	`693`	`declaringType = RuntimeTypeHandle.GetBaseType(declaringType);`
`694`		`- } while (!(declaringType is null));`
	`694`	`+ } while (declaringType is object);`
`695`	`695`	`}`
`696`	`696`
`697`	`697`	`return list.ToArray();`
`@@ -763,7 +763,7 @@ private unsafe RuntimeFieldInfo[] PopulateFields(Filter filter)`
`763`	`763`	`while (RuntimeTypeHandle.IsGenericVariable(declaringType))`
`764`	`764`	`declaringType = declaringType.GetBaseType();`
`765`	`765`
`766`		`- while (!(declaringType is null))`
	`766`	`+ while (declaringType is object)`
`767`	`767`	`{`
`768`	`768`	`PopulateRtFields(filter, declaringType, ref list);`
`769`	`769`
`@@ -1112,7 +1112,7 @@ private unsafe RuntimeEventInfo[] PopulateEvents(Filter filter)`
`1112`	`1112`	`declaringType = declaringType.GetBaseType();`
`1113`	`1113`
`1114`	`1114`	`// Populate associates off of the class hierarchy`
`1115`		`- while (!(declaringType is null))`
	`1115`	`+ while (declaringType is object)`
`1116`	`1116`	`{`
`1117`	`1117`	`PopulateEvents(filter, declaringType, csEventInfos, ref list);`
`1118`	`1118`	`declaringType = RuntimeTypeHandle.GetBaseType(declaringType);`
`@@ -1216,7 +1216,7 @@ private unsafe RuntimePropertyInfo[] PopulateProperties(Filter filter)`
`1216`	`1216`	`{`
`1217`	`1217`	`PopulateProperties(filter, declaringType, csPropertyInfos, usedSlots, ref list);`
`1218`	`1218`	`declaringType = RuntimeTypeHandle.GetBaseType(declaringType);`
`1219`		`- } while (!(declaringType is null));`
	`1219`	`+ } while (declaringType is object);`
`1220`	`1220`	`}`
`1221`	`1221`	`else`
`1222`	`1222`	`{`
`@@ -1303,7 +1303,7 @@ private unsafe void PopulateProperties(`
`1303`	`1303`	`associateMethod = propertyInfo.GetSetMethod();`
`1304`	`1304`	`}`
`1305`	`1305`
`1306`		`- if (!(associateMethod is null))`
	`1306`	`+ if (associateMethod is object)`
`1307`	`1307`	`{`
`1308`	`1308`	`int slot = RuntimeMethodHandle.GetSlot((RuntimeMethodInfo)associateMethod);`
`1309`	`1309`
`@@ -1565,7 +1565,7 @@ internal string GetDefaultMemberName()`
`1565`	`1565`	`{`
`1566`	`1566`	`CustomAttributeData attr = null;`
`1567`	`1567`	`Type DefaultMemberAttrType = typeof(DefaultMemberAttribute);`
`1568`		`- for (RuntimeType t = m_runtimeType; !(t is null); t = t.GetBaseType())`
	`1568`	`+ for (RuntimeType t = m_runtimeType; t is object; t = t.GetBaseType())`
`1569`	`1569`	`{`
`1570`	`1570`	`IList<CustomAttributeData> attrs = CustomAttributeData.GetCustomAttributes(t);`
`1571`	`1571`	`for (int i = 0; i < attrs.Count; i++)`
`@@ -1612,7 +1612,7 @@ internal MethodInfo GetGenericMethodInfo(RuntimeMethodHandleInternal genericMeth`
`1612`	`1612`	`{`
`1613`	`1613`	`crmi = s_methodInstantiations[rmi];`
`1614`	`1614`	`}`
`1615`		`- if (!(crmi is null))`
	`1615`	`+ if (crmi is object)`
`1616`	`1616`	`return crmi;`
`1617`	`1617`
`1618`	`1618`	`if (s_methodInstantiationsLock == null)`
`@@ -1627,14 +1627,14 @@ internal MethodInfo GetGenericMethodInfo(RuntimeMethodHandleInternal genericMeth`
`1627`	`1627`	`if (la != null)`
`1628`	`1628`	`{`
`1629`	`1629`	`crmi = la.m_methodInstantiations[rmi];`
`1630`		`- if (!(crmi is null))`
	`1630`	`+ if (crmi is object)`
`1631`	`1631`	`return crmi;`
`1632`	`1632`	`la.m_methodInstantiations[rmi] = rmi;`
`1633`	`1633`	`}`
`1634`	`1634`	`else`
`1635`	`1635`	`{`
`1636`	`1636`	`crmi = s_methodInstantiations[rmi];`
`1637`		`- if (!(crmi is null))`
	`1637`	`+ if (crmi is object)`
`1638`	`1638`	`return crmi;`
`1639`	`1639`	`s_methodInstantiations[rmi] = rmi;`
`1640`	`1640`	`}`
`@@ -1795,7 +1795,7 @@ internal static unsafe MethodBase GetMethodBase(RuntimeType reflectedType, Runti`
`1795`	`1795`
`1796`	`1796`	`RuntimeType baseType = reflectedType;`
`1797`	`1797`
`1798`		`- while (!(baseType is null))`
	`1798`	`+ while (baseType is object)`
`1799`	`1799`	`{`
`1800`	`1800`	`RuntimeType baseDefinition = baseType;`
`1801`	`1801`
`@@ -2340,7 +2340,7 @@ private static bool FilterApplyMethodBase(`
`2340`	`2340`	`for (int i = 0; i < parameterInfos.Length; i++)`
`2341`	`2341`	`{`
`2342`	`2342`	`// a null argument type implies a null arg which is always a perfect match`
`2343`		`- if (!(argumentTypes[i] is null) && !argumentTypes[i].MatchesParameterTypeExactly(parameterInfos[i]))`
	`2343`	`+ if (argumentTypes[i] is object && !argumentTypes[i].MatchesParameterTypeExactly(parameterInfos[i]))`
`2344`	`2344`	`return false;`
`2345`	`2345`	`}`
`2346`	`2346`	`}`
`@@ -2806,7 +2806,7 @@ protected override PropertyInfo GetPropertyImpl(`
`2806`	`2806`	`{`
`2807`	`2807`	`PropertyInfo firstCandidate = candidates[0];`
`2808`	`2808`
`2809`		`- if (!(returnType is null) && !returnType.IsEquivalentTo(firstCandidate.PropertyType))`
	`2809`	`+ if (returnType is object && !returnType.IsEquivalentTo(firstCandidate.PropertyType))`
`2810`	`2810`	`return null;`
`2811`	`2811`
`2812`	`2812`	`return firstCandidate;`
`@@ -2847,7 +2847,7 @@ public override EventInfo GetEvent(string name, BindingFlags bindingAttr)`
`2847`	`2847`	`RuntimeEventInfo eventInfo = cache[i];`
`2848`	`2848`	`if ((bindingAttr & eventInfo.BindingFlags) == eventInfo.BindingFlags)`
`2849`	`2849`	`{`
`2850`		`- if (!(match is null))`
	`2850`	`+ if (match is object)`
`2851`	`2851`	`throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);`
`2852`	`2852`
`2853`	`2853`	`match = eventInfo;`
`@@ -2876,7 +2876,7 @@ public override FieldInfo GetField(string name, BindingFlags bindingAttr)`
`2876`	`2876`	`RuntimeFieldInfo fieldInfo = cache[i];`
`2877`	`2877`	`if ((bindingAttr & fieldInfo.BindingFlags) == fieldInfo.BindingFlags)`
`2878`	`2878`	`{`
`2879`		`- if (!(match is null))`
	`2879`	`+ if (match is object)`
`2880`	`2880`	`{`
`2881`	`2881`	`if (ReferenceEquals(fieldInfo.DeclaringType, match.DeclaringType))`
`2882`	`2882`	`throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);`
`@@ -2923,7 +2923,7 @@ public override Type GetInterface(string fullname, bool ignoreCase)`
`2923`	`2923`	`RuntimeType iface = cache[i];`
`2924`	`2924`	`if (FilterApplyType(iface, bindingAttr, name, false, ns))`
`2925`	`2925`	`{`
`2926`		`- if (!(match is null))`
	`2926`	`+ if (match is object)`
`2927`	`2927`	`throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);`
`2928`	`2928`
`2929`	`2929`	`match = iface;`
`@@ -2953,7 +2953,7 @@ public override Type GetNestedType(string fullname, BindingFlags bindingAttr)`
`2953`	`2953`	`RuntimeType nestedType = cache[i];`
`2954`	`2954`	`if (FilterApplyType(nestedType, bindingAttr, name, false, ns))`
`2955`	`2955`	`{`
`2956`		`- if (!(match is null))`
	`2956`	`+ if (match is object)`
`2957`	`2957`	`throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);`
`2958`	`2958`
`2959`	`2959`	`match = nestedType;`
`@@ -3151,7 +3151,7 @@ public override bool IsSubclassOf(Type type)`
`3151`	`3151`
`3152`	`3152`	`RuntimeType baseType = GetBaseType();`
`3153`	`3153`
`3154`		`- while (!(baseType is null))`
	`3154`	`+ while (baseType is object)`
`3155`	`3155`	`{`
`3156`	`3156`	`if (baseType == rtType)`
`3157`	`3157`	`return true;`
`@@ -3962,7 +3962,7 @@ public override object InvokeMember(`
`3962`	`3962`	`selFld = binder.BindToField(bindingFlags, flds, IsGetField ? Empty.Value : providedArgs[0], culture);`
`3963`	`3963`	`}`
`3964`	`3964`
`3965`		`- if (!(selFld is null))`
	`3965`	`+ if (selFld is object)`
`3966`	`3966`	`{`
`3967`	`3967`	`// Invocation on a field`
`3968`	`3968`	`if (selFld.FieldType.IsArray \|\| ReferenceEquals(selFld.FieldType, typeof(Array)))`
`@@ -4148,7 +4148,7 @@ public override object InvokeMember(`
`4148`	`4148`	`}`
`4149`	`4149`	`}`
`4150`	`4150`
`4151`		`- if (!(finalist is null))`
	`4151`	`+ if (finalist is object)`
`4152`	`4152`	`{`
`4153`	`4153`	`// Invoke`
`4154`	`4154`	`if (finalists == null &&`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ private static void CallStartupHook(string assemblyPath)`
`89`	`89`	`Debug.Assert(initializeMethod == null);`
`90`	`90`	`wrongSignature = true;`
`91`	`91`	`}`
`92`		`- if (!(initializeMethod is null))`
	`92`	`+ if (initializeMethod is object)`
`93`	`93`	`{`
`94`	`94`	`// Found one`
`95`	`95`	`wrongSignature = true;`