Mark some ReflectionUtils methods as Obsolete and remove their usages

Src/Microsoft.Dynamic/Actions/ActionBinder.cs

@@ -50,11 +50,11 @@ public abstract class ActionBinder {
         /// </summary>
         public virtual object Convert(object obj, Type toType) {
             if (obj == null) {
-                if (!toType.IsValueType()) {
+                if (!toType.IsValueType) {
                     return null;
                 }
             } else {
-                if (toType.IsValueType()) {
+                if (toType.IsValueType) {
                     if (toType == obj.GetType()) {
                         return obj;
                     }
@@ -89,7 +89,7 @@ public abstract class ActionBinder {
             Type exprType = expr.Type;
 
             if (toType == typeof(object)) {
-                if (exprType.IsValueType()) {
+                if (exprType.IsValueType) {
                     return AstUtils.Convert(expr, toType);
                 }
 

Src/Microsoft.Dynamic/Actions/Calls/OutArgBuilder.cs

@@ -49,7 +49,7 @@ public OutArgBuilder(ParameterInfo info)
         internal override Expression ByRefArgument => _isRef ? _tmp : null;
 
         private Expression GetDefaultValue() {
-            if (_parameterType.IsValueType()) {
+            if (_parameterType.IsValueType) {
                 // default(T)
                 return AstUtils.Constant(Activator.CreateInstance(_parameterType));
             }

Src/Microsoft.Dynamic/Actions/Calls/OverloadResolver.cs

@@ -590,7 +590,7 @@ public abstract partial class OverloadResolver {
                             return true;
                         }
                         parameterType = lastParameter.Type.GetElementType();
-                    } else if (parameter.Type.ContainsGenericParameters()) {
+                    } else if (parameter.Type.ContainsGenericParameters) {
                         return true;
                     } else {
                         parameterType = parameter.Type;
@@ -873,11 +873,11 @@ public abstract partial class OverloadResolver {
                     return false;
                 }
 
-                if (toType.IsGenericType() && toType.GetGenericTypeDefinition() == typeof(Nullable<>)) {
+                if (toType.IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>)) {
                     return true;
                 }
 
-                if (!toType.IsValueType()) {
+                if (!toType.IsValueType) {
                     return true;
                 }
             }

Src/Microsoft.Dynamic/Actions/Calls/ParameterMapping.cs

@@ -337,7 +337,7 @@ public sealed class ParameterMapping {
                         break;
                     }
 
-                    curType = curType.GetBaseType();
+                    curType = curType.BaseType;
                 }
 
                 if (mis.Length == 1) {

Src/Microsoft.Dynamic/Actions/Calls/ParamsDictArgBuilder.cs

@@ -89,7 +89,7 @@ public ParamsDictArgBuilder(ParameterInfo info, int argIndex, string[] names, in
 
             if (dictType == typeof(IDictionary)) {
                 func = BinderOps.MakeDictionary<object, object>;
-            } else if (dictType.IsGenericType()) {
+            } else if (dictType.IsGenericType) {
                 Type[] genArgs = dictType.GetGenericTypeArguments();
                 if (dictType.GetGenericTypeDefinition() == typeof(IDictionary<,>) ||
                     dictType.GetGenericTypeDefinition() == typeof(Dictionary<,>)) {

Src/Microsoft.Dynamic/Actions/Calls/TypeInferer.cs

@@ -108,7 +108,7 @@ public static class TypeInferer {
             foreach (ArgBuilder oldArgBuilder in candidate.ArgBuilders) {
                 var pi = oldArgBuilder.ParameterInfo;
 
-                if (pi != null && (pi.ParameterType.IsGenericParameter || pi.ParameterType.ContainsGenericParameters())) {
+                if (pi != null && (pi.ParameterType.IsGenericParameter || pi.ParameterType.ContainsGenericParameters)) {
                     ArgBuilder replacement = oldArgBuilder.Clone(newOverload.Parameters[pi.Position]);
 
                     if (replacement == null) {
@@ -243,7 +243,7 @@ public static class TypeInferer {
                 foreach (Type t in constraints) {
                     if (t.IsGenericParameter) {
                         AddDependency(dependencies, genArg, t);
-                    } else if (t.ContainsGenericParameters()) {
+                    } else if (t.ContainsGenericParameters) {
                         AddNestedDependencies(dependencies, genArg, t);
                     }
                 }
@@ -256,7 +256,7 @@ public static class TypeInferer {
             foreach (Type innerArg in innerArgs) {
                 if (innerArg.IsGenericParameter) {
                     AddDependency(dependencies, genArg, innerArg);
-                } else if (innerArg.ContainsGenericParameters()) {
+                } else if (innerArg.ContainsGenericParameters) {
                     AddNestedDependencies(dependencies, genArg, innerArg);
                 }
             }
@@ -295,7 +295,7 @@ public static class TypeInferer {
         /// Adds any additional ArgumentInputs entries for the given object and parameter type.
         /// </summary>
         private static void AddOneInput(Dictionary<Type, ArgumentInputs> inputs, DynamicMetaObject arg, Type paramType) {
-            if (paramType.ContainsGenericParameters()) {
+            if (paramType.ContainsGenericParameters) {
                 List<Type> containedGenArgs = new List<Type>();
                 CollectGenericParameters(paramType, containedGenArgs);
 
@@ -319,7 +319,7 @@ public static class TypeInferer {
                 if (!containedGenArgs.Contains(type)) {
                     containedGenArgs.Add(type);
                 }
-            } else if (type.ContainsGenericParameters()) {
+            } else if (type.ContainsGenericParameters) {
                 if (type.IsArray || type.IsByRef) {
                     CollectGenericParameters(type.GetElementType(), containedGenArgs);
                 } else {
@@ -446,7 +446,7 @@ private class ArgumentInputs {
                 return inputType;
             }
 
-            if (parameterType.IsInterface()) {
+            if (parameterType.IsInterface) {
                 return GetInferedTypeForInterface(genericParameter, parameterType, inputType, binding);
             }
 
@@ -464,11 +464,11 @@ private class ArgumentInputs {
             // see if we're anywhere in our base class hierarchy
             Type genType = parameterType.GetGenericTypeDefinition();
             while (argType != typeof(object)) {
-                if (argType.IsGenericType() && argType.GetGenericTypeDefinition() == genType) {
+                if (argType.IsGenericType && argType.GetGenericTypeDefinition() == genType) {
                     // TODO: Merge w/ the interface logic?
                     return binding[genericParameter] = MatchGenericParameter(genericParameter, argType, parameterType, binding);
                 }
-                argType = argType.GetBaseType();
+                argType = argType.BaseType;
             }
 
             return null;
@@ -482,12 +482,12 @@ private class ArgumentInputs {
         // Unless X == Y we can't infer T.
         //
         private static Type GetInferedTypeForInterface(Type/*!*/ genericParameter, Type/*!*/ interfaceType, Type inputType, Dictionary<Type, Type>/*!*/ binding) {
-            Debug.Assert(interfaceType.IsInterface());
+            Debug.Assert(interfaceType.IsInterface);
 
             Type match = null;
             Type genTypeDef = interfaceType.GetGenericTypeDefinition();
             foreach (Type ifaceType in inputType.GetInterfaces()) {
-                if (ifaceType.IsGenericType() && ifaceType.GetGenericTypeDefinition() == genTypeDef) {
+                if (ifaceType.IsGenericType && ifaceType.GetGenericTypeDefinition() == genTypeDef) {
                     if (!MatchGenericParameter(genericParameter, ifaceType, interfaceType, binding, ref match)) {
                         return null;
                     }

Src/Microsoft.Dynamic/Actions/DefaultBinder.Conversions.cs

@@ -41,7 +41,7 @@ public partial class DefaultBinder : ActionBinder {
                 errorSuggestion ??
                 MakeErrorTarget(toType, kind, typeRestrictions, arg);
 
-            if ((kind == ConversionResultKind.ExplicitTry || kind == ConversionResultKind.ImplicitTry) && toType.IsValueType()) {
+            if ((kind == ConversionResultKind.ExplicitTry || kind == ConversionResultKind.ImplicitTry) && toType.IsValueType) {
                 res = new DynamicMetaObject(
                     AstUtils.Convert(
                         res.Expression,
@@ -60,7 +60,7 @@ public partial class DefaultBinder : ActionBinder {
         /// </summary>
         private static DynamicMetaObject TryConvertToObject(Type toType, Type knownType, DynamicMetaObject arg, BindingRestrictions restrictions) {
             if (toType == typeof(object)) {
-                if (knownType.IsValueType()) {
+                if (knownType.IsValueType) {
                     return MakeBoxingTarget(arg, restrictions);
                 }
 
@@ -87,7 +87,7 @@ public partial class DefaultBinder : ActionBinder {
         /// </summary>
         private static DynamicMetaObject TryAssignableConversion(Type toType, Type type, BindingRestrictions restrictions, DynamicMetaObject arg) {
             if (toType.IsAssignableFrom(type) ||
-                (type == typeof(DynamicNull) && (toType.IsClass() || toType.IsInterface()))) {
+                (type == typeof(DynamicNull) && (toType.IsClass || toType.IsInterface))) {
                 // MakeSimpleConversionTarget handles the ConversionResultKind check
                 return MakeSimpleConversionTarget(toType, restrictions, arg);
             }
@@ -180,7 +180,7 @@ public partial class DefaultBinder : ActionBinder {
         /// </summary>
         private static DynamicMetaObject TryImplicitNumericConversion(Type toType, Type type, BindingRestrictions restrictions, DynamicMetaObject arg) {
             Type checkType = type;
-            if (type.IsGenericType() && type.GetGenericTypeDefinition() == typeof(Extensible<>)) {
+            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Extensible<>)) {
                 checkType = type.GetGenericArguments()[0];
             }
 
@@ -205,7 +205,7 @@ public partial class DefaultBinder : ActionBinder {
         /// Checks if there's a conversion to/from Nullable of T.
         /// </summary>
         private DynamicMetaObject TryNullableConversion(OverloadResolverFactory factory, Type toType, ConversionResultKind kind, Type knownType, BindingRestrictions restrictions, DynamicMetaObject arg) {
-            if (toType.IsGenericType() && toType.GetGenericTypeDefinition() == typeof(Nullable<>)) {
+            if (toType.IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>)) {
                 if (knownType == typeof(DynamicNull)) {
                     // null -> Nullable<T>
                     return MakeNullToNullableOfTTarget(toType, restrictions);
@@ -230,7 +230,7 @@ public partial class DefaultBinder : ActionBinder {
         /// Checks to see if there's a conversion of null to a reference type
         /// </summary>
         private static DynamicMetaObject TryNullConversion(Type toType, Type knownType, BindingRestrictions restrictions) {
-            if (knownType == typeof(DynamicNull) && !toType.IsValueType()) {
+            if (knownType == typeof(DynamicNull) && !toType.IsValueType) {
                 return MakeNullTarget(toType, restrictions);
             }
             return null;
@@ -455,19 +455,12 @@ public partial class DefaultBinder : ActionBinder {
         }
 
         /// <summary>
-        /// Returns a value which indicates failure when a OldConvertToAction of ImplicitTry or
-        /// ExplicitTry.
+        /// Returns a value which indicates failure when a OldConvertToAction of ImplicitTry or ExplicitTry.
         /// </summary>
-        public static Expression GetTryConvertReturnValue(Type type) {
-            Expression res;
-            if (type.IsInterface() || type.IsClass()) {
-                res = AstUtils.Constant(null, type);
-            } else {
-                res = AstUtils.Constant(null);
-            }
-
-            return res;
-        }
+        public static Expression GetTryConvertReturnValue(Type type) =>
+            type.IsInterface || type.IsClass
+                ? AstUtils.Constant(null, type)
+                : AstUtils.Constant(null);
 
         /// <summary>
         /// Helper to extract the Value of an Extensible of T from the
@@ -492,10 +485,10 @@ public partial class DefaultBinder : ActionBinder {
         private static Type GetUnderlyingType(Type fromType) {
             Type curType = fromType;
             do {
-                if (curType.IsGenericType() && curType.GetGenericTypeDefinition() == typeof(Extensible<>)) {
+                if (curType.IsGenericType && curType.GetGenericTypeDefinition() == typeof(Extensible<>)) {
                     fromType = curType.GetGenericArguments()[0];
                 }
-                curType = curType.GetBaseType();
+                curType = curType.BaseType;
             } while (curType != null);
             return fromType;
         }

Src/Microsoft.Dynamic/Actions/DefaultBinder.GetMember.cs

@@ -195,7 +195,7 @@ public partial class DefaultBinder : ActionBinder {
                     // Throws an exception if we don't have a non-generic type, and if we do report an error now.  This matches
                     // the rule version of the default binder but should probably be removed long term.
                     EnsureTrackerRepresentsNonGenericType((TypeTracker)target.Value);
-                } else if (targetType.IsInterface()) {
+                } else if (targetType.IsInterface) {
                     // all interfaces have object members
                     targetType = typeof(object);
                     members = GetMember(MemberRequestKind.Get, targetType, getMemInfo.Name);

Src/Microsoft.Dynamic/Actions/DefaultBinder.Invoke.cs

@@ -68,7 +68,7 @@ public partial class DefaultBinder : ActionBinder {
             if (targetInfo != null) {
                 // we're calling a well-known MethodBase
                 DynamicMetaObject res = MakeMetaMethodCall(signature, resolverFactory, targetInfo);
-                if (res.Expression.Type.IsValueType()) {
+                if (res.Expression.Type.IsValueType) {
                     res = new DynamicMetaObject(
                         AstUtils.Convert(res.Expression, typeof(object)),
                         res.Restrictions

Src/Microsoft.Dynamic/Actions/DefaultBinder.Operations.cs

@@ -254,7 +254,7 @@ private enum IndexType {
             BindingRestrictions restrictions = BindingRestrictionsHelpers.GetRuntimeTypeRestriction(args[0].Expression, args[0].GetLimitType()).Merge(BindingRestrictions.Combine(args));
 
             if (args[0].GetLimitType() == typeof(DynamicNull)) {
-                if (!otherType.IsValueType()) {
+                if (!otherType.IsValueType) {
                     return new DynamicMetaObject(
                         Expression.Equal(args[0].Expression, AstUtils.Constant(null)),
                         restrictions
@@ -268,7 +268,7 @@ private enum IndexType {
                     );
                 }
             } else if (otherType == typeof(DynamicNull)) {
-                if (!args[0].GetLimitType().IsValueType()) {
+                if (!args[0].GetLimitType().IsValueType) {
                     return new DynamicMetaObject(
                         Expression.Equal(args[0].Expression, AstUtils.Constant(null)),
                         restrictions

Src/Microsoft.Dynamic/Actions/DefaultBinder.SetMember.cs

@@ -267,7 +267,7 @@ public partial class DefaultBinder : ActionBinder {
                     memInfo.Body.FinishCondition(
                         MakeGenericPropertyExpression(memInfo)
                     );
-                } else if (setter.IsPublic && !setter.DeclaringType.IsValueType()) {
+                } else if (setter.IsPublic && !setter.DeclaringType.IsValueType) {
                     if (instance == null) {
                         memInfo.Body.FinishCondition(
                             Expression.Block(
@@ -327,7 +327,7 @@ public partial class DefaultBinder : ActionBinder {
             FieldTracker field = (FieldTracker)fields[0];
 
             // TODO: Tmp variable for target
-            if (instance != null && field.DeclaringType.IsGenericType() && field.DeclaringType.GetGenericTypeDefinition() == typeof(StrongBox<>)) {
+            if (instance != null && field.DeclaringType.IsGenericType && field.DeclaringType.GetGenericTypeDefinition() == typeof(StrongBox<>)) {
                 // work around a CLR bug where we can't access generic fields from dynamic methods.
                 Type[] generic = field.DeclaringType.GetGenericArguments();
                 memInfo.Body.FinishCondition(
@@ -356,14 +356,14 @@ public partial class DefaultBinder : ActionBinder {
                         typeof(object)
                     )
                 );
-            } else if (field.DeclaringType.IsValueType() && !field.IsStatic) {
+            } else if (field.DeclaringType.IsValueType && !field.IsStatic) {
                 memInfo.Body.FinishError(
                     errorSuggestion ?? MakeError(
                         MakeSetValueTypeFieldError(field, instance, target),
                         typeof(object)
                     )
                 );
-            } else if (field.IsPublic && field.DeclaringType.IsVisible()) {
+            } else if (field.IsPublic && field.DeclaringType.IsVisible) {
                 if (!field.IsStatic && instance == null) {
                     memInfo.Body.FinishError(
                         Expression.Throw(

Src/Microsoft.Dynamic/Actions/DefaultBinder.cs

@@ -172,7 +172,7 @@ public partial class DefaultBinder : ActionBinder {
                     return mi;
                 }
 
-                curType = curType.GetBaseType();
+                curType = curType.BaseType;
             } while (curType != null);
 
             return null;

Src/Microsoft.Dynamic/Actions/FieldTracker.cs

@@ -58,11 +58,11 @@ public class FieldTracker : MemberTracker {
                 return binder.ReturnMemberTracker(type, this);
             }
 
-            if (Field.DeclaringType.ContainsGenericParameters()) {
+            if (Field.DeclaringType.ContainsGenericParameters) {
                 return null;
             }
 
-            if (IsPublic && DeclaringType.IsPublic()) {
+            if (IsPublic && DeclaringType.IsPublic) {
                 return new DynamicMetaObject(
                     Expression.Convert(Expression.Field(null, Field), typeof(object)),
                     BindingRestrictions.Empty
@@ -82,7 +82,7 @@ public class FieldTracker : MemberTracker {
         public override ErrorInfo GetError(ActionBinder binder, Type instanceType) {
             // FieldTracker only has one error - accessing a static field from 
             // a generic type.
-            Debug.Assert(Field.DeclaringType.ContainsGenericParameters());
+            Debug.Assert(Field.DeclaringType.ContainsGenericParameters);
 
             return binder.MakeContainsGenericParametersError(this);
         }
@@ -92,7 +92,7 @@ public class FieldTracker : MemberTracker {
         #region Internal expression builders
 
         protected internal override DynamicMetaObject GetBoundValue(OverloadResolverFactory resolverFactory, ActionBinder binder, Type type, DynamicMetaObject instance) {
-            if (IsPublic && DeclaringType.IsVisible()) {
+            if (IsPublic && DeclaringType.IsVisible) {
                 return new DynamicMetaObject(
                     AstUtils.Convert(
                         Expression.Field(

Src/Microsoft.Dynamic/Actions/MethodTracker.cs

@@ -57,7 +57,7 @@ public class MethodTracker : MemberTracker {
         }
 
         internal override DynamicMetaObject Call(OverloadResolverFactory resolverFactory, ActionBinder binder, params DynamicMetaObject[] arguments) {
-            if (Method.IsPublic && Method.DeclaringType.IsVisible()) {
+            if (Method.IsPublic && Method.DeclaringType.IsVisible) {
                 return binder.MakeCallExpression(resolverFactory, Method, arguments);
             }
 

Src/Microsoft.Dynamic/Actions/NamespaceTracker.cs

@@ -210,7 +210,7 @@ public class NamespaceTracker : MemberTracker, IMembersList, IEnumerable<KeyValu
                     continue;
                 }
 
-                bool publishType = type.IsPublic() || _topPackage.DomainManager.Configuration.PrivateBinding;
+                bool publishType = type.IsPublic || _topPackage.DomainManager.Configuration.PrivateBinding;
                 if (!publishType) {
                     continue;
                 }