public ImplicitUseFlags SuppressUsageInspectionsOnElement()

in resharper/resharper-unity/src/Unity/CSharp/Daemon/UsageChecking/UsageInspectionsSuppressor.cs [50:122]
57 lines of code
28 McCabe index (conditional complexity)

        public ImplicitUseFlags SuppressUsageInspectionsOnElement(IDeclaredElement element)
        {
            if (!element.IsFromUnityProject()) return ImplicitUseFlags.Empty;

            var solution = element.GetSolution();
            var unityApi = solution.GetComponent<UnityApi>();

            switch (element)
            {
                case IClass cls when unityApi.IsUnityType(cls) ||
                                     cls.IsDotsImplicitlyUsedType() ||
                                     IsUxmlFactory(cls) ||
                                     unityApi.IsOdinType(cls):
                    return new ImplicitUseFlags(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature);

                case IStruct @struct when unityApi.IsUnityType(@struct) ||
                                     @struct.IsDotsImplicitlyUsedType() :
                    return new ImplicitUseFlags(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature);

                case ITypeElement typeElement when unityApi.IsSerializableTypeDeclaration(typeElement).HasFlag(SerializedFieldStatus.SerializedField):
                    // TODO: We should only really mark it as in use if it's actually used somewhere
                    // That is, it should be used as a field in a Unity type, or another serializable type
                    return new ImplicitUseFlags(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature);

                case ITypeElement typeElement when IsImplicitlyUsedInterfaceType(typeElement):
                    return new ImplicitUseFlags(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature);

                case IMethod method:
                    var function = unityApi.GetUnityEventFunction(method, out var match);
                    if (function != null)
                    {
                        if (match == MethodSignatureMatch.ExactMatch)
                        {
                            return HasOptionalParameter(function)
                                ? new ImplicitUseFlags(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)
                                : new ImplicitUseFlags(ImplicitUseKindFlags.Access);
                        }

                        return ImplicitUseFlags.Empty;
                    }

                    if (IsEventHandler(unityApi, method) ||
                        IsRequiredSignatureMethod(method) ||
                        IsAnimationEvent(solution, method) ||
                        IsImplicitlyUsedInterfaceMethod(method) ||
                        IsImplicitlyUsedByInputActions(solution, method))
                    {
                        return new ImplicitUseFlags(ImplicitUseKindFlags.Access);
                    }
                    break;

                case IField field when unityApi.IsSerialisedField(field).HasFlag(SerializedFieldStatus.SerializedField):
                    return new ImplicitUseFlags(ImplicitUseKindFlags.Assign);

                case IField field when unityApi.IsOdinInspectorField(field):
                    return new ImplicitUseFlags(ImplicitUseKindFlags.Assign);

                case IProperty property when IsEventHandler(unityApi, property.Setter) ||
                                             IsImplicitlyUsedInterfaceProperty(property) ||
                                             IsAnimationEvent(solution, property) ||
                                             unityApi.IsSerialisedAutoProperty(property, useSwea:true).HasFlag(SerializedFieldStatus.SerializedField):
                    return new ImplicitUseFlags(ImplicitUseKindFlags.Assign);

                case IProperty property when unityApi.IsOdinInspectorProperty(property):
                    return new ImplicitUseFlags(ImplicitUseKindFlags.Assign);

                case IParameter parameter
                    when parameter.IsRefMember() && parameter.GetContainingType().IsDotsImplicitlyUsedType():
                    return new ImplicitUseFlags(ImplicitUseKindFlags.Assign);
            }

            return ImplicitUseFlags.Empty;
        }