Analyzer: Replace occurrences of TypeInfo with Type and GetTypeInfo() with GetType()

[buyaa-n]

Related to #53217 (comment)
For obsoleting TypeInfo/GetTypeInfo we need an analyzer/code fixer that replaces GetTypeInfo() with calls to GetType(), and occurrences of TypeInfo with Type. A heavy reflection code base that migrated to Windows 8/was written for the Windows 8 era, would have had widely used both. The key would be making it easier for folks to replace them when the type is obsolete.

class DerivedClass : TypeInfo // Do not flag base types
{
   //  ...
}
class MyClass
{
    // I guess we don't want to warn/fix return type of a public/protected methods (maybe make it configurable)
    // flag/fix return type only for private methods by default
    // flag fix all local variables including the parameters
    TypeInfo GetTypeInfo(TypeInfo ti) => null;
    // flag/fix only private properties by default
    TypeInfo TypeInfo => null;
    // flag/fix only private fields by default
    private TypeInfo typeInfo = null;

    void ExampleBeforeFix()
    {
        TypeInfo ti = typeof(MyClass).GetTypeInfo();
        TypeInfo anotherInfo = GetTypeInfo(null); // TypeInfo comes from other API

        // possible references needs updated:
        IEnumerable<ConstructorInfo> constructors = ti.DeclaredConstructors;
        IEnumerable<EventInfo> events = ti.DeclaredEvents;
        IEnumerable<FieldInfo> fields = ti.DeclaredFields;
        IEnumerable<MemberInfo> memebrs = ti.DeclaredMembers;
        IEnumerable<MethodInfo> methods = ti.DeclaredMethods;
        IEnumerable<TypeInfo> nTypes = ti.DeclaredNestedTypes;
        IEnumerable<PropertyInfo> properties = ti.DeclaredProperties;
        Type[] genTypeParams = ti.GenericTypeParameters;
        IEnumerable<Type> interfaces = ti.ImplementedInterfaces;
        Type t = ti.AsType();
        EventInfo ei = ti.GetDeclaredEvent(name);
        FieldInfo fi = ti.GetDeclaredField(name);
        MethodInfo mi = ti.GetDeclaredMethod(name);
        IEnumerable<MethodInfo> mInfos = ti.GetDeclaredMethods(name);
        TypeInfo tInfo = ti.GetDeclaredNestedType(name);
        PropertyInfo pi = ti.GetDeclaredProperty(name);
        if (ti.IsAssignableFrom(anotherInfo));
        TypeInfo ati = ti.GetTypeInfo();
    }

    void ExampleAfterFix()
    {
        Type ti = typeof(MyClass);
        Type anotherInfo = GetTypeInfo(null); // TypeInfo comes from custom method

        // possible fixes for references
        IEnumerable<ConstructorInfo> constructors = ti.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        IEnumerable<EventInfo> events = ti.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        IEnumerable<FieldInfo> fields = ti.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        IEnumerable<MemberInfo> memebrs = ti.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        IEnumerable<MethodInfo> methods = ti.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        // Should we cast the result to IEnumerable or change the type of the variable into array of Type? (IEnumerable<TypeInfo> nTypes = ti.DeclaredNestedTypes;)
        IEnumerable<TypeInfo> nTypes = (IEnumerable<TypeInfo>)ti.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        IEnumerable<PropertyInfo> properties = ti.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly); ;
        Type[] genTypeParams = ti.GetGenericArguments(); // or use: IsGenericTypeDefinition ? GetGenericArguments() : Type.EmptyTypes;
        IEnumerable<Type> interfaces = ti.GetInterfaces(); // before: ti.ImplementedInterfaces;
        Type t = ti; // before:  ti.AsType();
        EventInfo ei = ti.GetEvent(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        FieldInfo fi = ti.GetField(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        MethodInfo mi = ti.GetMethod(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        // IEnumerable<MethodInfo> mInfos = ti.GetDeclaredMethods(name); No direct replacement, we might want to add correspodning method to the Type
        // Below type of tInfo changed from TypeInfo to Type 
        Type tInfo = ti.GetNestedType(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        PropertyInfo pi = ti.GetProperty(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
        if (ti.IsAssignableFrom(anotherInfo)); // no change needed
        Type ati = ti.GetType(); // or just Type ati = ti; in case analyzer update type of ti
    }

    // we might want to add this const to Type and use for the arguments
    public const BindingFlags DeclaredOnlyLookup = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;

    private string name = "name";
 }

Category: Maintainability or Design
Severity: Info

cc @terrajobst @carlossanlop

[ghost]

Tagging subscribers to this area: @buyaa-n
See info in area-owners.md if you want to be subscribed.

Issue Details

---

Related to #53217 (comment)
For obsoleting TypeInfo/GetTypeInfo we need an analyzer/code fixer that replaces GetTypeInfo() with calls to GetType(), and occurrences of TypeInfo with Type. A heavy reflection code base that migrated to Windows 8/was written for the Windows 8 era, would have had widely used both. The key would be making it easier for folks to replace them when the type is obsolete.

Category: Reliability
Severity: Info

Author:	buyaa-n
Assignees:	-
Labels:	area-System.Reflection, code-analyzer, code-fixer
Milestone:	-

[carlossanlop]

Suggested severity: Suggestion
Suggested category: Design
Suggested milestone: 7.0 (same as issue suggesting obsoleting TypeInfo and GetTypeInfo())

Flag

MemoryStream ms = new MemoryStream();

Type type = ms.GetType();
MemberInfo[] members1 = type.GetMembers();


// Before
TypeInfo typeInfo1 = type.GetTypeInfo();
MemberInfo[] members2 = typeInfo1.GetMembers();


// After
Type typeInfo1 = type;
MemberInfo[] members2 = typeInfo1.GetMembers();

Edit: The main description contains all the cases to address.

[bartonjs]

Video

• Generally looks good as proposed.
• While a fixer may produce errors in a few edge cases, it seems generally valueable, so we should make one.
• The analyzer should check the Type/TypeInfo hierarchy to not run when it's not appropriate (e.g. netstandard1.x).
• It should not flag uses where any TypeInfo-specific members are used.

Category: Maintainability
Severity: Info